abd_serialization.c File Reference

API to serialize and deserialize delegation chains and abds. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_abd_service.h"
#include "gnunet_signatures.h"
#include "abd.h"
#include "abd_serialization.h"

Include dependency graph for abd_serialization.c:

Go to the source code of this file.

Functions
size_t	GNUNET_ABD_delegation_set_get_size (unsigned int ds_count, const struct GNUNET_ABD_DelegationSet *dsr)
	Calculate how many bytes we will need to serialize the given delegation chain.
ssize_t	GNUNET_ABD_delegation_set_serialize (unsigned int d_count, const struct GNUNET_ABD_DelegationSet *dsr, size_t dest_size, char *dest)
	Serizalize the given delegation chain entries and abd.
int	GNUNET_ABD_delegation_set_deserialize (size_t len, const char *src, unsigned int d_count, struct GNUNET_ABD_DelegationSet *dsr)
	Deserialize the given destination.
size_t	GNUNET_ABD_delegates_get_size (unsigned int c_count, const struct GNUNET_ABD_Delegate *cd)
	Calculate how many bytes we will need to serialize the abds.
ssize_t	GNUNET_ABD_delegates_serialize (unsigned int c_count, const struct GNUNET_ABD_Delegate *cd, size_t dest_size, char *dest)
	Serizalize the given abds.
int	GNUNET_ABD_delegates_deserialize (size_t len, const char *src, unsigned int c_count, struct GNUNET_ABD_Delegate *cd)
	Deserialize the given destination.
size_t	GNUNET_ABD_delegation_chain_get_size (unsigned int d_count, const struct GNUNET_ABD_Delegation *dd, unsigned int c_count, const struct GNUNET_ABD_Delegate *cd)
	Calculate how many bytes we will need to serialize the given delegation chain and abd.
ssize_t	GNUNET_ABD_delegation_chain_serialize (unsigned int d_count, const struct GNUNET_ABD_Delegation *dd, unsigned int c_count, const struct GNUNET_ABD_Delegate *cd, size_t dest_size, char *dest)
	Serizalize the given delegation chain entries and abd.
int	GNUNET_ABD_delegation_chain_deserialize (size_t len, const char *src, unsigned int d_count, struct GNUNET_ABD_Delegation *dd, unsigned int c_count, struct GNUNET_ABD_Delegate *cd)
	Deserialize the given destination.
int	GNUNET_ABD_delegate_serialize (struct GNUNET_ABD_Delegate *dele, char **data)
struct GNUNET_ABD_Delegate *	GNUNET_ABD_delegate_deserialize (const char *data, size_t data_size)

Detailed Description

API to serialize and deserialize delegation chains and abds.

Author

Martin Schanzenbach

Definition in file abd_serialization.c.

Function Documentation

GNUNET_ABD_delegation_set_get_size()

size_t GNUNET_ABD_delegation_set_get_size	(	unsigned int	ds_count,
		const struct GNUNET_ABD_DelegationSet *	dsr
	)

Calculate how many bytes we will need to serialize the given delegation chain.

Calculate how many bytes we will need to serialize the given delegation record.

Parameters

ds_count	number of delegation chain entries
dsr	array of GNUNET_ABD_DelegationSet

Returns

the required size to serialize

Definition at line 44 of file abd_serialization.c.

{
  unsigned int i;
  size_t ret;
 
  ret = sizeof (struct DelegationRecordData) * (ds_count);
 
  for (i = 0; i < ds_count; i++)
  {
    GNUNET_assert ((ret + dsr[i].subject_attribute_len) >= ret);
    ret += dsr[i].subject_attribute_len;
  }
  return ret;
}

References GNUNET_assert, ret, DelegationRecordData::subject_attribute_len, and GNUNET_ABD_DelegationSet::subject_attribute_len.

Referenced by abd_string_to_value().

Here is the caller graph for this function:

GNUNET_ABD_delegation_set_serialize()

ssize_t GNUNET_ABD_delegation_set_serialize	(	unsigned int	d_count,
		const struct GNUNET_ABD_DelegationSet *	dsr,
		size_t	dest_size,
		char *	dest
	)

Serizalize the given delegation chain entries and abd.

Serizalize the given delegation record entries.

Parameters

d_count	number of delegation chain entries
dsr	array of GNUNET_ABD_DelegationSet
dest_size	size of the destination
dest	where to store the result

Returns

the size of the data, -1 on failure

Definition at line 72 of file abd_serialization.c.

{
  struct DelegationRecordData rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < d_count; i++)
  {
    rec.subject_attribute_len = htonl ((uint32_t) dsr[i].subject_attribute_len);
    rec.subject_key = dsr[i].subject_key;
    if (off + sizeof (rec) > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
    off += sizeof (rec);
    if (0 == dsr[i].subject_attribute_len)
      continue;
    if (off + dsr[i].subject_attribute_len > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off],
                   dsr[i].subject_attribute,
                   dsr[i].subject_attribute_len);
    off += dsr[i].subject_attribute_len;
  }
  return off;
}

References GNUNET_memcpy, DelegationRecordData::subject_attribute_len, GNUNET_ABD_DelegationSet::subject_attribute_len, DelegationRecordData::subject_key, and GNUNET_ABD_DelegationSet::subject_key.

Referenced by abd_string_to_value().

Here is the caller graph for this function:

GNUNET_ABD_delegation_set_deserialize()

int GNUNET_ABD_delegation_set_deserialize	(	size_t	len,
		const char *	src,
		unsigned int	d_count,
		struct GNUNET_ABD_DelegationSet *	dsr
	)

Deserialize the given destination.

Parameters

len	size of the serialized delegation chain and cred
src	the serialized data
d_count	the number of delegation chain entries
dsr	where to put the delegation chain entries

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 114 of file abd_serialization.c.

{
  struct DelegationRecordData rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < d_count; i++)
  {
    if (off + sizeof (rec) > len)
      return GNUNET_SYSERR;
    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
    dsr[i].subject_key = rec.subject_key;
    off += sizeof (rec);
    dsr[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
    if (off + dsr[i].subject_attribute_len > len)
      return GNUNET_SYSERR;
    dsr[i].subject_attribute = (char *) &src[off];
    off += dsr[i].subject_attribute_len;
  }
  return GNUNET_OK;
}

References GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_ABD_DelegationSet::subject_attribute, DelegationRecordData::subject_attribute_len, GNUNET_ABD_DelegationSet::subject_attribute_len, DelegationRecordData::subject_key, and GNUNET_ABD_DelegationSet::subject_key.

Referenced by abd_value_to_string(), and backward_resolution().

Here is the caller graph for this function:

GNUNET_ABD_delegates_get_size()

size_t GNUNET_ABD_delegates_get_size	(	unsigned int	c_count,
		const struct GNUNET_ABD_Delegate *	cd
	)

Calculate how many bytes we will need to serialize the abds.

Parameters

c_count	number of abd entries
cd	a #GNUNET_ABD_Credential

Returns

the required size to serialize

Definition at line 151 of file abd_serialization.c.

{
  unsigned int i;
  size_t ret;
 
  ret = sizeof (struct DelegateEntry) * (c_count);
 
  for (i = 0; i < c_count; i++)
  {
    GNUNET_assert ((ret + cd[i].issuer_attribute_len
                    + cd[i].subject_attribute_len) >= ret);
    // subject_attribute_len should be 0
    ret += cd[i].issuer_attribute_len + cd[i].subject_attribute_len;
  }
  return ret;
}

References GNUNET_assert, DelegateEntry::issuer_attribute_len, GNUNET_ABD_Delegate::issuer_attribute_len, ret, DelegateEntry::subject_attribute_len, and GNUNET_ABD_Delegate::subject_attribute_len.

Referenced by GNUNET_ABD_delegation_chain_get_size(), and GNUNET_ABD_verify().

Here is the caller graph for this function:

GNUNET_ABD_delegates_serialize()

ssize_t GNUNET_ABD_delegates_serialize	(	unsigned int	c_count,
		const struct GNUNET_ABD_Delegate *	cd,
		size_t	dest_size,
		char *	dest
	)

Serizalize the given abds.

Parameters

c_count	number of abd entries
cd	a #GNUNET_ABD_Credential
dest_size	size of the destination
dest	where to store the result

Returns

the size of the data, -1 on failure

Definition at line 181 of file abd_serialization.c.

{
  struct DelegateEntry c_rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < c_count; i++)
  {
    c_rec.subject_attribute_len = htonl (cd[i].subject_attribute_len);
    c_rec.issuer_attribute_len = htonl (cd[i].issuer_attribute_len);
    c_rec.issuer_key = cd[i].issuer_key;
    c_rec.subject_key = cd[i].subject_key;
    c_rec.signature = cd[i].signature;
    c_rec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
    c_rec.purpose.size =
      htonl ((sizeof (struct DelegateEntry) + cd[i].issuer_attribute_len)
             - sizeof (struct GNUNET_CRYPTO_BlindableKeySignature));
    c_rec.expiration = GNUNET_htonll (cd[i].expiration.abs_value_us);
    if (off + sizeof (c_rec) > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off], &c_rec, sizeof (c_rec));
    off += sizeof (c_rec);
    if (off + cd[i].issuer_attribute_len > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off],
                   cd[i].issuer_attribute,
                   cd[i].issuer_attribute_len);
    off += cd[i].issuer_attribute_len;
  }
 
  return off;
}

References expiration, DelegateEntry::expiration, GNUNET_htonll(), GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_DELEGATE, DelegateEntry::issuer_attribute_len, GNUNET_ABD_Delegate::issuer_attribute_len, DelegateEntry::issuer_key, GNUNET_ABD_Delegate::issuer_key, DelegateEntry::purpose, GNUNET_CRYPTO_SignaturePurpose::purpose, DelegateEntry::signature, GNUNET_ABD_Delegate::signature, GNUNET_CRYPTO_SignaturePurpose::size, DelegateEntry::subject_attribute_len, DelegateEntry::subject_key, and GNUNET_ABD_Delegate::subject_key.

Referenced by GNUNET_ABD_delegation_chain_serialize(), and GNUNET_ABD_verify().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegates_deserialize()

int GNUNET_ABD_delegates_deserialize	(	size_t	len,
		const char *	src,
		unsigned int	c_count,
		struct GNUNET_ABD_Delegate *	cd
	)

Deserialize the given destination.

Parameters

len	size of the serialized creds
src	the serialized data
c_count	the number of abd entries
cd	where to put the abd data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 230 of file abd_serialization.c.

{
  struct DelegateEntry c_rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < c_count; i++)
  {
    if (off + sizeof (c_rec) > len)
      return GNUNET_SYSERR;
    GNUNET_memcpy (&c_rec, &src[off], sizeof (c_rec));
    cd[i].issuer_attribute_len = ntohl ((uint32_t) c_rec.issuer_attribute_len);
    cd[i].issuer_key = c_rec.issuer_key;
    cd[i].subject_key = c_rec.subject_key;
    cd[i].signature = c_rec.signature;
    cd[i].expiration.abs_value_us = GNUNET_ntohll (c_rec.expiration);
    off += sizeof (c_rec);
    if (off + cd[i].issuer_attribute_len > len)
      return GNUNET_SYSERR;
    cd[i].issuer_attribute = &src[off];
    off += cd[i].issuer_attribute_len;
    cd[i].subject_attribute_len = 0;
  }
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, DelegateEntry::expiration, GNUNET_ABD_Delegate::expiration, GNUNET_memcpy, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_ABD_Delegate::issuer_attribute, DelegateEntry::issuer_attribute_len, GNUNET_ABD_Delegate::issuer_attribute_len, DelegateEntry::issuer_key, GNUNET_ABD_Delegate::issuer_key, DelegateEntry::signature, GNUNET_ABD_Delegate::signature, GNUNET_ABD_Delegate::subject_attribute_len, DelegateEntry::subject_key, and GNUNET_ABD_Delegate::subject_key.

Referenced by GNUNET_ABD_delegation_chain_deserialize(), and handle_verify().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegation_chain_get_size()

size_t GNUNET_ABD_delegation_chain_get_size	(	unsigned int	d_count,
		const struct GNUNET_ABD_Delegation *	dd,
		unsigned int	c_count,
		const struct GNUNET_ABD_Delegate *	cd
	)

Calculate how many bytes we will need to serialize the given delegation chain and abd.

Parameters

d_count	number of delegation chain entries
dd	array of GNUNET_ABD_Delegation
c_count	number of abd entries
cd	a #GNUNET_ABD_Credential

Returns

the required size to serialize

Definition at line 272 of file abd_serialization.c.

{
  unsigned int i;
  size_t ret;
 
  ret = sizeof (struct ChainEntry) * (d_count);
 
  for (i = 0; i < d_count; i++)
  {
    GNUNET_assert (
      (ret + dd[i].issuer_attribute_len + dd[i].subject_attribute_len) >= ret);
    ret += dd[i].issuer_attribute_len + dd[i].subject_attribute_len;
  }
  return ret + GNUNET_ABD_delegates_get_size (c_count, cd);
}

References GNUNET_ABD_delegates_get_size(), GNUNET_assert, ChainEntry::issuer_attribute_len, GNUNET_ABD_Delegation::issuer_attribute_len, ret, ChainEntry::subject_attribute_len, and GNUNET_ABD_Delegation::subject_attribute_len.

Referenced by send_intermediate_response(), and send_lookup_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegation_chain_serialize()

ssize_t GNUNET_ABD_delegation_chain_serialize	(	unsigned int	d_count,
		const struct GNUNET_ABD_Delegation *	dd,
		unsigned int	c_count,
		const struct GNUNET_ABD_Delegate *	cd,
		size_t	dest_size,
		char *	dest
	)

Serizalize the given delegation chain entries and abd.

Parameters

d_count	number of delegation chain entries
dd	array of GNUNET_ABD_Delegation
c_count	number of abd entries
cd	a #GNUNET_ABD_Credential
dest_size	size of the destination
dest	where to store the result

Returns

the size of the data, -1 on failure

Definition at line 305 of file abd_serialization.c.

{
  struct ChainEntry rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < d_count; i++)
  {
    rec.issuer_attribute_len = htonl ((uint32_t) dd[i].issuer_attribute_len);
    rec.subject_attribute_len = htonl ((uint32_t) dd[i].subject_attribute_len);
    rec.issuer_key = dd[i].issuer_key;
    rec.subject_key = dd[i].subject_key;
    if (off + sizeof (rec) > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off], &rec, sizeof (rec));
    off += sizeof (rec);
    if (off + dd[i].issuer_attribute_len > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off],
                   dd[i].issuer_attribute,
                   dd[i].issuer_attribute_len);
    off += dd[i].issuer_attribute_len;
    if (0 == dd[i].subject_attribute_len)
      continue;
    if (off + dd[i].subject_attribute_len > dest_size)
      return -1;
    GNUNET_memcpy (&dest[off],
                   dd[i].subject_attribute,
                   dd[i].subject_attribute_len);
    off += dd[i].subject_attribute_len;
  }
  return off + GNUNET_ABD_delegates_serialize (c_count,
                                               cd,
                                               dest_size - off,
                                               &dest[off]);
}

References GNUNET_ABD_delegates_serialize(), GNUNET_memcpy, ChainEntry::issuer_attribute_len, GNUNET_ABD_Delegation::issuer_attribute_len, ChainEntry::issuer_key, GNUNET_ABD_Delegation::issuer_key, ChainEntry::subject_attribute_len, GNUNET_ABD_Delegation::subject_attribute_len, ChainEntry::subject_key, and GNUNET_ABD_Delegation::subject_key.

Referenced by send_intermediate_response(), and send_lookup_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegation_chain_deserialize()

int GNUNET_ABD_delegation_chain_deserialize	(	size_t	len,
		const char *	src,
		unsigned int	d_count,
		struct GNUNET_ABD_Delegation *	dd,
		unsigned int	c_count,
		struct GNUNET_ABD_Delegate *	cd
	)

Deserialize the given destination.

Parameters

len	size of the serialized delegation chain and cred
src	the serialized data
d_count	the number of delegation chain entries
dd	where to put the delegation chain entries
c_count	the number of abd entries
cd	where to put the abd data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 362 of file abd_serialization.c.

{
  struct ChainEntry rec;
  unsigned int i;
  size_t off;
 
  off = 0;
  for (i = 0; i < d_count; i++)
  {
    if (off + sizeof (rec) > len)
      return GNUNET_SYSERR;
    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
    dd[i].issuer_attribute_len = ntohl ((uint32_t) rec.issuer_attribute_len);
    dd[i].issuer_key = rec.issuer_key;
    dd[i].subject_key = rec.subject_key;
    off += sizeof (rec);
    if (off + dd[i].issuer_attribute_len > len)
      return GNUNET_SYSERR;
    dd[i].issuer_attribute = &src[off];
    off += dd[i].issuer_attribute_len;
    dd[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
    if (off + dd[i].subject_attribute_len > len)
      return GNUNET_SYSERR;
    dd[i].subject_attribute = &src[off];
    off += dd[i].subject_attribute_len;
  }
  return GNUNET_ABD_delegates_deserialize (len - off,
                                           &src[off],
                                           c_count,
                                           cd);
}

References GNUNET_ABD_delegates_deserialize(), GNUNET_memcpy, GNUNET_SYSERR, GNUNET_ABD_Delegation::issuer_attribute, ChainEntry::issuer_attribute_len, GNUNET_ABD_Delegation::issuer_attribute_len, ChainEntry::issuer_key, GNUNET_ABD_Delegation::issuer_key, GNUNET_ABD_Delegation::subject_attribute, ChainEntry::subject_attribute_len, GNUNET_ABD_Delegation::subject_attribute_len, ChainEntry::subject_key, and GNUNET_ABD_Delegation::subject_key.

Referenced by handle_intermediate(), and handle_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegate_serialize()

int GNUNET_ABD_delegate_serialize	(	struct GNUNET_ABD_Delegate *	dele,
		char **	data
	)

Definition at line 402 of file abd_serialization.c.

{
  size_t size;
  struct DelegateEntry *cdata;
  int attr_len;
 
  // +1 for \0
  if (0 == dele->subject_attribute_len)
  {
    attr_len = dele->issuer_attribute_len + 1;
  }
  else
  {
    attr_len = dele->issuer_attribute_len + dele->subject_attribute_len + 2;
  }
  size = sizeof (struct DelegateEntry) + attr_len;
 
  {
    char tmp_str[attr_len];
    GNUNET_memcpy (tmp_str, dele->issuer_attribute, dele->issuer_attribute_len);
    if (0 != dele->subject_attribute_len)
    {
      tmp_str[dele->issuer_attribute_len] = '\0';
      GNUNET_memcpy (tmp_str + dele->issuer_attribute_len + 1,
                     dele->subject_attribute,
                     dele->subject_attribute_len);
    }
    tmp_str[attr_len - 1] = '\0';
 
    *data = GNUNET_malloc (size);
    cdata = (struct DelegateEntry *) *data;
    cdata->subject_key = dele->subject_key;
    cdata->issuer_key = dele->issuer_key;
    cdata->expiration = GNUNET_htonll (dele->expiration.abs_value_us);
    cdata->signature = dele->signature;
    cdata->issuer_attribute_len = htonl (dele->issuer_attribute_len + 1);
    if (0 == dele->subject_attribute_len)
    {
      cdata->subject_attribute_len = htonl (0);
    }
    else
    {
      cdata->subject_attribute_len = htonl (dele->subject_attribute_len + 1);
    }
    cdata->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DELEGATE);
    cdata->purpose.size =
      htonl (size - sizeof (struct GNUNET_CRYPTO_BlindableKeySignature));
 
    GNUNET_memcpy (&cdata[1], tmp_str, attr_len);
  }
  if (GNUNET_OK !=
      GNUNET_CRYPTO_blinded_key_signature_verify_ (
        GNUNET_SIGNATURE_PURPOSE_DELEGATE,
        &cdata->purpose,
        &cdata->signature,
        &cdata->issuer_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Serialize: Invalid delegate\n");
    return 0;
  }
  return size;
}

References GNUNET_TIME_Absolute::abs_value_us, data, DelegateEntry::expiration, GNUNET_ABD_Delegate::expiration, GNUNET_CRYPTO_blinded_key_signature_verify_(), GNUNET_ERROR_TYPE_WARNING, GNUNET_htonll(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_DELEGATE, GNUNET_ABD_Delegate::issuer_attribute, DelegateEntry::issuer_attribute_len, GNUNET_ABD_Delegate::issuer_attribute_len, DelegateEntry::issuer_key, GNUNET_ABD_Delegate::issuer_key, DelegateEntry::purpose, GNUNET_CRYPTO_SignaturePurpose::purpose, DelegateEntry::signature, GNUNET_ABD_Delegate::signature, GNUNET_CRYPTO_SignaturePurpose::size, size, GNUNET_ABD_Delegate::subject_attribute, DelegateEntry::subject_attribute_len, GNUNET_ABD_Delegate::subject_attribute_len, DelegateEntry::subject_key, and GNUNET_ABD_Delegate::subject_key.

Referenced by abd_string_to_value(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ABD_delegate_deserialize()

struct GNUNET_ABD_Delegate * GNUNET_ABD_delegate_deserialize	(	const char *	data,
		size_t	data_size
	)

Definition at line 468 of file abd_serialization.c.

{
  struct GNUNET_ABD_Delegate *dele;
  struct DelegateEntry *cdata;
  char *attr_combo_str;
 
  if (data_size < sizeof (struct DelegateEntry))
    return NULL;
  cdata = (struct DelegateEntry *) data;
  if (GNUNET_OK !=
      GNUNET_CRYPTO_blinded_key_signature_verify_ (
        GNUNET_SIGNATURE_PURPOSE_DELEGATE,
        &cdata->purpose,
        &cdata->signature,
        &cdata->issuer_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deserialize: Invalid delegate\n");
    return NULL;
  }
  attr_combo_str = (char *) &cdata[1];
  {
    int iss_len = ntohl (cdata->issuer_attribute_len);
    int sub_len = ntohl (cdata->subject_attribute_len);
    int attr_combo_len = iss_len + sub_len;
 
    dele =
      GNUNET_malloc (sizeof (struct GNUNET_ABD_Delegate) + attr_combo_len);
 
    dele->issuer_key = cdata->issuer_key;
    dele->subject_key = cdata->subject_key;
    GNUNET_memcpy (&dele[1], attr_combo_str, attr_combo_len);
    dele->signature = cdata->signature;
 
    // Set the pointers for the attributes
    dele->issuer_attribute = (char *) &dele[1];
    dele->issuer_attribute_len = iss_len;
    dele->subject_attribute_len = sub_len;
    if (0 == sub_len)
    {
      dele->subject_attribute = NULL;
    }
    else
    {
      dele->subject_attribute = (char *) &dele[1] + iss_len;
    }
 
    dele->expiration.abs_value_us = GNUNET_ntohll (cdata->expiration);
  }
  return dele;
}

References GNUNET_TIME_Absolute::abs_value_us, data, data_size, DelegateEntry::expiration, GNUNET_ABD_Delegate::expiration, GNUNET_CRYPTO_blinded_key_signature_verify_(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_ntohll(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_DELEGATE, GNUNET_ABD_Delegate::issuer_attribute, DelegateEntry::issuer_attribute_len, GNUNET_ABD_Delegate::issuer_attribute_len, DelegateEntry::issuer_key, GNUNET_ABD_Delegate::issuer_key, DelegateEntry::purpose, DelegateEntry::signature, GNUNET_ABD_Delegate::signature, GNUNET_ABD_Delegate::subject_attribute, DelegateEntry::subject_attribute_len, GNUNET_ABD_Delegate::subject_attribute_len, DelegateEntry::subject_key, and GNUNET_ABD_Delegate::subject_key.

Referenced by abd_value_to_string(), forward_resolution(), and handle_delegate_collection_cb().

Here is the call graph for this function:

Here is the caller graph for this function: