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

◆ GNUNET_RECLAIM_id_is_zero

#define GNUNET_RECLAIM_id_is_zero (   a)

◆ GNUNET_RECLAIM_id_generate

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

Definition at line 102 of file gnunet_reclaim_lib.h.

Referenced by add_attribute_cont(), add_credential_cont(), attr_store_task(), cred_store_task(), filter_tickets_finished_cb(), and rvk_move_attr_cb().

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.

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

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.

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

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 }
const char * name
The name of the attribute.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * attr_name
The attribute.
size_t data_size
Number of bytes in data.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
const void * data
Binary value stored as attribute value.
uint32_t type
Type of Claim.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
uint32_t data
The data value.
#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:568
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.

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 consume_result_cb(), GNUNET_RECLAIM_ticket_issue(), and OIDC_build_authz_code().

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 }
#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.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

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().

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 }
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_AttributeList::list_head, and GNUNET_RECLAIM_AttributeList::list_tail.

Referenced by inspect_attrs(), and jwt_parse_attributes().

311 {
313 
315  ale->attribute =
317  type, data, data_size);
319  al->list_tail,
320  ale);
321 }
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.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
static char * attr_name
The attribute.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
uint32_t data
The data value.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
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.

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 consume_result_cb(), GNUNET_RECLAIM_ticket_issue(), and OIDC_build_authz_code().

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);
367  len = GNUNET_RECLAIM_attribute_serialize (ale->attribute, write_ptr);
368  total_len += len;
369  write_ptr += len;
370  }
371  return total_len;
372 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
size_t GNUNET_RECLAIM_attribute_serialize(const struct GNUNET_RECLAIM_Attribute *attr, char *result)
Serialize an attribute.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
static int result
Global testing status.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

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().

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 }
ssize_t GNUNET_RECLAIM_attribute_deserialize(const char *data, size_t data_size, struct GNUNET_RECLAIM_Attribute **attr)
Deserialize an attribute.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
A list of GNUNET_RECLAIM_Attribute structures.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Serialized claim.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
#define GNUNET_log(kind,...)
uint32_t data
The data value.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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().

487 {
488  return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
489 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
Serialized claim.
const char * name
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.

References Attribute::attribute_flag, Attribute::attribute_id, Attribute::attribute_type, GNUNET_RECLAIM_Attribute::credential, Attribute::credential_id, GNUNET_RECLAIM_Attribute::data, Attribute::data_size, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_memcpy, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Attribute::name, Attribute::name_len, 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().

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 }
const char * name
The name of the attribute.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Serialized claim.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
uint32_t attribute_flag
Attribute flag.
uint32_t data_size
Data size.
static int result
Global testing status.
struct GNUNET_RECLAIM_Identifier id
ID.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
const char * name
uint32_t name_len
Name length.
const void * data
Binary value stored as attribute value.
uint32_t type
Type of Claim.
struct GNUNET_RECLAIM_Identifier attribute_id
Attribute ID.
uint32_t attribute_type
Attribute type.
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.

References Attribute::attribute_flag, Attribute::attribute_id, Attribute::attribute_type, GNUNET_RECLAIM_Attribute::credential, Attribute::credential_id, GNUNET_RECLAIM_Attribute::data, Attribute::data_size, GNUNET_RECLAIM_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().

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 }
const char * name
The name of the attribute.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Serialized claim.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
uint32_t attribute_flag
Attribute flag.
uint32_t data_size
Data size.
struct GNUNET_RECLAIM_Identifier id
ID.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
#define GNUNET_log(kind,...)
uint32_t name_len
Name length.
const void * data
Binary value stored as attribute value.
uint32_t type
Type of Claim.
struct GNUNET_RECLAIM_Identifier attribute_id
Attribute ID.
uint32_t data
The data value.
uint32_t attribute_type
Attribute type.
#define GNUNET_malloc(size)
Wrapper around malloc.
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.

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_AttributeList::list_tail, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_AttributeListEntry::next, result, and GNUNET_RECLAIM_Attribute::type.

Referenced by RECLAIM_TICKETS_issue().

425 {
427  struct GNUNET_RECLAIM_AttributeListEntry *result_ale;
429 
430  result = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
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 }
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.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
const char * name
The name of the attribute.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A list of GNUNET_RECLAIM_Attribute structures.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
static int result
Global testing status.
struct GNUNET_RECLAIM_Identifier id
ID.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
const void * data
Binary value stored as attribute value.
uint32_t type
Type of Claim.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

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

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 unsigned int num_plugins
Number of plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static void init()
Load plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static char * plugin
Solver plugin name as string.
static struct Plugin ** attr_plugins
Plugins.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

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

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 }
static unsigned int num_plugins
Number of plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static void init()
Load plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static char * plugin
Solver plugin name as string.
static struct Plugin ** attr_plugins
Plugins.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

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

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 }
static unsigned int num_plugins
Number of plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static void init()
Load plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static char * plugin
Solver plugin name as string.
static struct Plugin ** attr_plugins
Plugins.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

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

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 }
static unsigned int num_plugins
Number of plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static void init()
Load plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static char * plugin
Solver plugin name as string.
static struct Plugin ** attr_plugins
Plugins.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
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.

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

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_Credential * credential
The credential.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

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

Referenced by cleanup_adh(), and cleanup_handle().

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 }
struct GNUNET_RECLAIM_Credential * credential
The credential.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

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);
334  len = GNUNET_RECLAIM_credential_serialize (le->credential, write_ptr);
335  total_len += len;
336  write_ptr += len;
337  }
338  return total_len;
339 }
struct GNUNET_RECLAIM_Credential * credential
The credential.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
static int result
Global testing status.
size_t GNUNET_RECLAIM_credential_serialize(const struct GNUNET_RECLAIM_Credential *credential, char *result)
Serialize an credential.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

References GNUNET_RECLAIM_CredentialListEntry::credential, data, 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.

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 }
Serialized credential claim.
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize an credential.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
size_t GNUNET_RECLAIM_credential_serialize_get_size(const struct GNUNET_RECLAIM_Credential *credential)
Get required size for serialization buffer.
struct GNUNET_RECLAIM_Credential * credential
The credential.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
struct GNUNET_RECLAIM_CredentialListEntry * list_tail
List tail.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
A list of GNUNET_RECLAIM_Credential structures.
#define GNUNET_log(kind,...)
uint32_t data
The data value.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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().

451 {
452  return sizeof(struct Credential) + strlen (credential->name)
453  + credential->data_size;
454 }
Serialized credential claim.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
const char * name
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.

References Credential::credential_flag, Credential::credential_id, Credential::credential_type, GNUNET_RECLAIM_Credential::data, Credential::data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_RECLAIM_Credential::flag, GNUNET_memcpy, GNUNET_RECLAIM_Credential::id, GNUNET_RECLAIM_Credential::name, Credential::name_len, and GNUNET_RECLAIM_Credential::type.

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

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)
491  + credential->data_size;
492 }
Serialized credential claim.
uint32_t data_size
Data size.
struct GNUNET_RECLAIM_Identifier id
ID.
uint32_t type
Type/Format of Claim.
uint32_t name_len
Name length.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
size_t data_size
Number of bytes in data.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const void * data
Binary value stored as credential value.
uint32_t credential_type
Credential type.
static int result
Global testing status.
const char * name
The name of the credential.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
const char * name
uint32_t credential_flag
Credential flag.
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.

References credential, Credential::credential_flag, Credential::credential_id, Credential::credential_type, GNUNET_RECLAIM_Credential::data, Credential::data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_RECLAIM_Credential::flag, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_RECLAIM_Credential::id, GNUNET_RECLAIM_Credential::name, Credential::name_len, and GNUNET_RECLAIM_Credential::type.

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().

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  }
524  credential = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential)
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 }
Serialized credential claim.
uint32_t data_size
Data size.
struct GNUNET_RECLAIM_Identifier id
ID.
uint32_t type
Type/Format of Claim.
uint32_t name_len
Name length.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
size_t data_size
Number of bytes in data.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const void * data
Binary value stored as credential value.
uint32_t credential_type
Credential type.
const char * name
The name of the credential.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
#define GNUNET_log(kind,...)
uint32_t data
The data value.
uint32_t credential_flag
Credential flag.
#define GNUNET_malloc(size)
Wrapper around malloc.
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.

References GNUNET_RECLAIM_Credential::data, GNUNET_RECLAIM_Credential::data_size, 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().

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.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
size_t data_size
Number of bytes in data.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const void * data
Binary value stored as credential value.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * attr_name
The attribute.
const char * name
The name of the credential.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
uint32_t data
The data value.
#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:568
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

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

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 = credential_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 }
static struct Plugin ** credential_plugins
Plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

Referenced by parse_credential().

203 {
204  unsigned int i;
205  struct Plugin *plugin;
206 
207  init ();
208  for (i = 0; i < num_plugins; i++)
209  {
210  plugin = credential_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 }
static struct Plugin ** credential_plugins
Plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by cred_collect(), and cred_iter_cb().

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 = credential_plugins[i];
180  if (NULL !=
181  (ret = plugin->api->number_to_typename (plugin->api->cls, type)))
182  return ret;
183  }
184  return NULL;
185 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by cred_iter_finished(), and parse_credential().

146 {
147  unsigned int i;
148  struct Plugin *plugin;
149  uint32_t ret;
150  init ();
151  for (i = 0; i < num_plugins; i++)
152  {
153  plugin = credential_plugins[i];
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 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by cred_collect(), and cred_iter_cb().

547 {
548  unsigned int i;
549  struct Plugin *plugin;
551  init ();
552  for (i = 0; i < num_plugins; i++)
553  {
554  plugin = credential_plugins[i];
555  if (NULL !=
556  (ret = plugin->api->get_attributes (plugin->api->cls,
557  credential)))
558  return ret;
559  }
560  return NULL;
561 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
A list of GNUNET_RECLAIM_Attribute structures.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by cred_collect().

567 {
568  unsigned int i;
569  struct Plugin *plugin;
570  char *ret;
571  init ();
572  for (i = 0; i < num_plugins; i++)
573  {
574  plugin = credential_plugins[i];
575  if (NULL !=
576  (ret = plugin->api->get_issuer (plugin->api->cls,
577  credential)))
578  return ret;
579  }
580  return NULL;
581 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

Referenced by cred_collect().

588 {
589  unsigned int i;
590  struct Plugin *plugin;
591  init ();
592  for (i = 0; i < num_plugins; i++)
593  {
594  plugin = credential_plugins[i];
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 }
static struct Plugin ** credential_plugins
Plugins.
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

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 consume_result_cb(), OIDC_build_authz_code(), and send_ticket_result().

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 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
size_t GNUNET_RECLAIM_presentation_serialize_get_size(const struct GNUNET_RECLAIM_Presentation *presentation)
Get required size for serialization buffer.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

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().

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 }
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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 consume_result_cb(), OIDC_build_authz_code(), and send_ticket_result().

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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
static int result
Global testing status.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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.

References data, 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().

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 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Serialized presentation claim.
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_deserialize(const char *data, size_t data_size)
Deserialize an presentation.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
A list of GNUNET_RECLAIM_Presentation structures.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_PresentationListEntry * list_tail
List tail.
size_t GNUNET_RECLAIM_presentation_serialize_get_size(const struct GNUNET_RECLAIM_Presentation *presentation)
Get required size for serialization buffer.
uint32_t data
The data value.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

898 {
899  return sizeof(struct Presentation) + presentation->data_size;
900 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
Serialized presentation claim.
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.

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

Referenced by GNUNET_RECLAIM_presentation_list_serialize(), and issue_ticket().

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 }
uint32_t type
Type/Format of Claim.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Serialized presentation claim.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
static int result
Global testing status.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
const void * data
Binary value stored as presentation value.
size_t data_size
Number of bytes in data.
uint32_t data_size
Data size.
uint32_t presentation_type
Presentation type.
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.

References Presentation::credential_id, GNUNET_RECLAIM_Presentation::credential_id, GNUNET_RECLAIM_Presentation::data, Presentation::data_size, GNUNET_RECLAIM_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().

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 }
uint32_t type
Type/Format of Claim.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Serialized presentation claim.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
const void * data
Binary value stored as presentation value.
A credential presentation.
size_t data_size
Number of bytes in data.
uint32_t data_size
Data size.
uint32_t presentation_type
Presentation type.
#define GNUNET_log(kind,...)
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by generate_userinfo_json().

701 {
702  unsigned int i;
703  struct Plugin *plugin;
704  char *ret;
705 
706  init ();
707  for (i = 0; i < num_plugins; i++)
708  {
709  plugin = credential_plugins[i];
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 }
static struct Plugin ** credential_plugins
Plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References 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().

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 }
uint32_t type
Type/Format of Claim.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const void * data
Binary value stored as presentation value.
A credential presentation.
size_t data_size
Number of bytes in data.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

670 {
671  unsigned int i;
672  struct Plugin *plugin;
673 
674  init ();
675  for (i = 0; i < num_plugins; i++)
676  {
677  plugin = credential_plugins[i];
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 }
static struct Plugin ** credential_plugins
Plugins.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
uint32_t data
The data value.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by generate_userinfo_json().

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  {
646  plugin = credential_plugins[i];
647  if (NULL !=
648  (ret = plugin->api->number_to_typename_p (plugin->api->cls, type)))
649  return ret;
650  }
651  return NULL;
652 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by process_attrs().

973 {
974  unsigned int i;
975  struct Plugin *plugin;
977  init ();
978  for (i = 0; i < num_plugins; i++)
979  {
980  plugin = credential_plugins[i];
981  if (NULL !=
982  (ret = plugin->api->get_attributes_p (plugin->api->cls,
983  presentation)))
984  return ret;
985  }
986  return NULL;
987 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
A list of GNUNET_RECLAIM_Attribute structures.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

994 {
995  unsigned int i;
996  struct Plugin *plugin;
997  char *ret;
998  init ();
999  for (i = 0; i < num_plugins; i++)
1000  {
1001  plugin = credential_plugins[i];
1002  if (NULL !=
1003  (ret = plugin->api->get_issuer_p (plugin->api->cls,
1004  presentation)))
1005  return ret;
1006  }
1007  return NULL;
1008 }
static struct Plugin ** credential_plugins
Plugins.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

1016 {
1017  unsigned int i;
1018  struct Plugin *plugin;
1019  init ();
1020  for (i = 0; i < num_plugins; i++)
1021  {
1022  plugin = credential_plugins[i];
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 }
static struct Plugin ** credential_plugins
Plugins.
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_OK, GNUNET_SYSERR, GNUNET_RECLAIM_Credential::id, init(), num_plugins, and plugin.

Referenced by filter_tickets_cb().

1048 {
1049  unsigned int i;
1050  struct Plugin *plugin;
1051  init ();
1052  for (i = 0; i < num_plugins; i++)
1053  {
1054  plugin = credential_plugins[i];
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.
static struct Plugin ** credential_plugins
Plugins.
static unsigned int num_plugins
Number of plugins.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
static void init()
Load plugins.
static char * plugin
Solver plugin name as string.
Handle for a plugin.
Definition: block.c:37
void * cls
Closure for all of the callbacks.
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 88 of file gnunet_reclaim_lib.h.

Referenced by start_process().