json_helper.c File Reference

functions to generate specifciations for JSON parsing More...

#include "platform.h"
#include "gnunet_json_lib.h"
#include "gnunet_common.h"

Include dependency graph for json_helper.c:

Go to the source code of this file.

Functions
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_end ()
	End of a parser specification.
static enum GNUNET_CRYPTO_BlindSignatureAlgorithm	string_to_cipher (const char *cipher_s)
	Convert string value to numeric cipher value.
static enum GNUNET_GenericReturnValue	parse_fixed_data (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to fixed size data.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_fixed (const char *name, void *obj, size_t size)
	Variable size object (in network byte order, encoded using Crockford Base32hex encoding).
static enum GNUNET_GenericReturnValue	parse_fixed64_data (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to fixed size data.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_fixed64 (const char *name, void *obj, size_t size)
	Variable size object (in network byte order, encoded using base64 encoding).
static enum GNUNET_GenericReturnValue	parse_variable_data (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to variable size data.
static void	clean_variable_data (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing variable size data.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_varsize (const char *name, void **obj, size_t *size)
	Variable size object (in network byte order, encoded using Crockford Base32hex encoding).
static enum GNUNET_GenericReturnValue	parse_string (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to string.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_string (const char *name, const char **strptr)
	The expected field stores a string.
static enum GNUNET_GenericReturnValue	parse_string_copy (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to string, and make a copy.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_string_copy (const char *name, char **strptr)
	The expected field stores a string.
static enum GNUNET_GenericReturnValue	parse_json (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a JSON object.
static void	clean_json (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing JSON object.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_json (const char *name, json_t **jsonp)
	JSON object or array.
static enum GNUNET_GenericReturnValue	parse_object_const (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a JSON object.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_object_const (const char *name, const json_t **jsonp)
	JSON object, reference counter not incremented.
static enum GNUNET_GenericReturnValue	parse_object_copy (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a JSON object and increment the reference counter.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_object_copy (const char *name, json_t **jsonp)
	JSON object, reference counter not incremented.
static enum GNUNET_GenericReturnValue	parse_array_const (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON to a JSON array.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_array_const (const char *name, const json_t **jsonp)
	JSON array, reference counter not incremented.
static enum GNUNET_GenericReturnValue	parse_array_copy (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON to a JSON array and increment the reference counter.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_array_copy (const char *name, json_t **jsonp)
	JSON array, reference counter not incremented.
static enum GNUNET_GenericReturnValue	parse_bool (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a bool.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_bool (const char *name, bool *b)
	boolean.
static enum GNUNET_GenericReturnValue	parse_double (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a double.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_double (const char *name, double *f)
	double.
static enum GNUNET_GenericReturnValue	parse_u8 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint8_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint8 (const char *name, uint8_t *u8)
	8-bit integer.
static enum GNUNET_GenericReturnValue	parse_u16 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint16_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint16 (const char *name, uint16_t *u16)
	16-bit integer.
static enum GNUNET_GenericReturnValue	parse_u32 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint32_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint32 (const char *name, uint32_t *u32)
	32-bit integer.
static enum GNUNET_GenericReturnValue	parse_ui (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to an unsigned int.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint (const char *name, unsigned int *ui)
	Unsigned integer.
static enum GNUNET_GenericReturnValue	parse_ull (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to an unsigned long long.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_ull (const char *name, unsigned long long *ull)
	Unsigned long long.
static enum GNUNET_GenericReturnValue	parse_u64 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint64_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint64 (const char *name, uint64_t *u64)
	64-bit integer.
static enum GNUNET_GenericReturnValue	parse_i16 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a int16_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_int16 (const char *name, int16_t *i16)
	16-bit signed integer.
static enum GNUNET_GenericReturnValue	parse_i64 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a int64_t.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_int64 (const char *name, int64_t *i64)
	64-bit signed integer.
static enum GNUNET_GenericReturnValue	parse_timestamp (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a timestamp.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_timestamp (const char *name, struct GNUNET_TIME_Timestamp *t)
	Timestamp.
static enum GNUNET_GenericReturnValue	parse_timestamp_nbo (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to absolute time.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_timestamp_nbo (const char *name, struct GNUNET_TIME_TimestampNBO *at)
	Timestamp in network byte order.
static enum GNUNET_GenericReturnValue	parse_rel_time (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to relative time.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_relative_time (const char *name, struct GNUNET_TIME_Relative *rt)
	Relative time.
static enum GNUNET_GenericReturnValue	parse_rsa_public_key (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to RSA public key.
static void	clean_rsa_public_key (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing RSA public key.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_rsa_public_key (const char *name, struct GNUNET_CRYPTO_RsaPublicKey **pk)
	Specification for parsing an RSA public key.
static enum GNUNET_GenericReturnValue	parse_rsa_signature (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to RSA signature.
static void	clean_rsa_signature (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing RSA signature.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_rsa_signature (const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
	Specification for parsing an RSA signature.
static enum GNUNET_GenericReturnValue	parse_boolean (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to an int as a boolean.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_boolean (const char *name, int *boolean)
	Boolean (true mapped to GNUNET_YES, false mapped to GNUNET_NO).
static enum GNUNET_GenericReturnValue	parse_blinded_message (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a blinded message.
static void	clean_blinded_message (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing blinded message.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_blinded_message (const char *name, struct GNUNET_CRYPTO_BlindedMessage **msg)
	Specification for parsing a blinded message.
static enum GNUNET_GenericReturnValue	parse_blinded_sig (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a blinded signature.
static void	clean_blinded_sig (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing blinded sig.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_blinded_signature (const char *field, struct GNUNET_CRYPTO_BlindedSignature **b_sig)
	Specification for parsing a blinded signature.
static enum GNUNET_GenericReturnValue	parse_unblinded_sig (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to unblinded signature.
static void	clean_unblinded_sig (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing unblinded signature.
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_unblinded_signature (const char *field, struct GNUNET_CRYPTO_UnblindedSignature **ub_sig)
	Specification for parsing an unblinded signature.

Detailed Description

functions to generate specifciations for JSON parsing

Author

Florian Dold

Benedikt Mueller

Christian Grothoff

Definition in file json_helper.c.

Function Documentation

GNUNET_JSON_spec_end()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_end

(

void

)

End of a parser specification.

Definition at line 33 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = NULL,
  };
 
  return ret;
}

References GNUNET_JSON_Specification::parser, and ret.

Referenced by add_attribute_cont(), add_credential_cont(), bulk_tx_start(), consume_ticket_cont(), namestore_add_or_update(), parse_blinded_message(), parse_blinded_sig(), parse_unblinded_sig(), and revoke_ticket_cont().

Here is the caller graph for this function:

string_to_cipher()

static enum GNUNET_CRYPTO_BlindSignatureAlgorithm string_to_cipher ( const char *  cipher_s )

static

Convert string value to numeric cipher value.

Parameters

cipher_s

input string

Returns

numeric cipher value

Definition at line 50 of file json_helper.c.

{
  if ((0 == strcasecmp (cipher_s,
                        "RSA")) ||
      (0 == strcasecmp (cipher_s,
                        "RSA+age_restricted")))
    return GNUNET_CRYPTO_BSA_RSA;
  if ((0 == strcasecmp (cipher_s,
                        "CS")) ||
      (0 == strcasecmp (cipher_s,
                        "CS+age_restricted")))
    return GNUNET_CRYPTO_BSA_CS;
  return GNUNET_CRYPTO_BSA_INVALID;
}

References GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, and GNUNET_CRYPTO_BSA_RSA.

Referenced by parse_blinded_message(), parse_blinded_sig(), and parse_unblinded_sig().

Here is the caller graph for this function:

parse_fixed_data()

static enum GNUNET_GenericReturnValue parse_fixed_data ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to fixed size data.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 75 of file json_helper.c.

{
  const char *enc;
  size_t len;
 
  if (NULL == (enc = json_string_value (root)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  len = strlen (enc);
  if (len >= SIZE_MAX / 5)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (((len * 5) / 8) != spec->ptr_size)
  {
    GNUNET_break_op (0);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Field `%s' has wrong length\n",
                spec->field);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     len,
                                     spec->ptr,
                                     spec->ptr_size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References enc, GNUNET_JSON_Specification::field, GNUNET_break_op, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, GNUNET_JSON_Specification::ptr_size, and SIZE_MAX.

Referenced by GNUNET_JSON_spec_fixed().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_fixed()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_fixed	(	const char *	name,
		void *	obj,
		size_t	size
	)

Variable size object (in network byte order, encoded using Crockford Base32hex encoding).

Parameters

	name	name of the JSON field
[out]	obj	pointer where to write the data, must have size bytes
	size	number of bytes expected in obj

Definition at line 115 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_fixed_data,
    .field = name,
    .ptr = obj,
    .ptr_size = size,
  };
 
  return ret;
}

References name, parse_fixed_data(), GNUNET_JSON_Specification::parser, ret, and size.

Here is the call graph for this function:

parse_fixed64_data()

static enum GNUNET_GenericReturnValue parse_fixed64_data ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to fixed size data.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 139 of file json_helper.c.

{
  const char *enc;
  unsigned int len;
  void *output;
  size_t olen;
 
  if (NULL == (enc = json_string_value (root)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  len = strlen (enc);
  output = NULL;
  olen = GNUNET_STRINGS_base64_decode (enc,
                                       len,
                                       &output);
  if (olen != spec->ptr_size)
  {
    GNUNET_break_op (0);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Field `%s' has wrong length\n",
                spec->field);
    GNUNET_free (output);
    return GNUNET_SYSERR;
  }
  memcpy (spec->ptr,
          output,
          olen);
  GNUNET_free (output);
  return GNUNET_OK;
}

References enc, GNUNET_JSON_Specification::field, GNUNET_break_op, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_STRINGS_base64_decode(), GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, and GNUNET_JSON_Specification::ptr_size.

Referenced by GNUNET_JSON_spec_fixed64().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_fixed64()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_fixed64	(	const char *	name,
		void *	obj,
		size_t	size
	)

Variable size object (in network byte order, encoded using base64 encoding).

Parameters

	name	name of the JSON field
[out]	obj	pointer where to write the data, must have size bytes
	size	number of bytes expected in obj

Definition at line 176 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_fixed64_data,
    .field = name,
    .ptr = obj,
    .ptr_size = size,
  };
 
  return ret;
}

References name, parse_fixed64_data(), GNUNET_JSON_Specification::parser, ret, and size.

Here is the call graph for this function:

parse_variable_data()

static enum GNUNET_GenericReturnValue parse_variable_data ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to variable size data.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 200 of file json_helper.c.

{
  const char *str;
  size_t size;
  void *data;
 
  str = json_string_value (root);
  if (NULL == str)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data_alloc (str,
                                           strlen (str),
                                           &data,
                                           &size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *(void **) spec->ptr = data;
  *spec->size_ptr = size;
  return GNUNET_OK;
}

References data, GNUNET_break_op, GNUNET_OK, GNUNET_STRINGS_string_to_data_alloc(), GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, size, and GNUNET_JSON_Specification::size_ptr.

Referenced by GNUNET_JSON_spec_varsize().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_variable_data()

static void clean_variable_data ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing variable size data.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 236 of file json_helper.c.

{
  (void) cls;
  if (0 != *spec->size_ptr)
  {
    GNUNET_free (*(void **) spec->ptr);
    *(void **) spec->ptr = NULL;
    *spec->size_ptr = 0;
  }
}

References GNUNET_JSON_Specification::cls, GNUNET_free, GNUNET_JSON_Specification::ptr, and GNUNET_JSON_Specification::size_ptr.

Referenced by GNUNET_JSON_spec_varsize().

Here is the caller graph for this function:

GNUNET_JSON_spec_varsize()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_varsize	(	const char *	name,
		void **	obj,
		size_t *	size
	)

Variable size object (in network byte order, encoded using Crockford Base32hex encoding).

Parameters

	name	name of the JSON field
[out]	obj	pointer where to write the data, will be allocated
[out]	size	where to store the number of bytes allocated for obj

Definition at line 250 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_variable_data,
    .cleaner = &clean_variable_data,
    .field = name,
    .ptr = obj,
    .size_ptr = size
  };
 
  *obj = NULL;
  *size = 0;
  return ret;
}

References clean_variable_data(), name, parse_variable_data(), GNUNET_JSON_Specification::parser, ret, and size.

Referenced by parse_blinded_message().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_string()

static enum GNUNET_GenericReturnValue parse_string ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to string.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 277 of file json_helper.c.

{
  const char *str;
 
  (void) cls;
  str = json_string_value (root);
  if (NULL == str)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *(const char **) spec->ptr = str;
  return GNUNET_OK;
}

References GNUNET_JSON_Specification::cls, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_string().

Here is the caller graph for this function:

GNUNET_JSON_spec_string()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_string	(	const char *	name,
		const char **	strptr
	)

The expected field stores a string.

Parameters

name	name of the JSON field
strptr	where to store a pointer to the field

Definition at line 296 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_string,
    .field = name,
    .ptr = strptr
  };
 
  *strptr = NULL;
  return ret;
}

References name, parse_string(), GNUNET_JSON_Specification::parser, and ret.

Referenced by consume_ticket_cont(), parse_blinded_message(), parse_blinded_sig(), and parse_unblinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_string_copy()

static enum GNUNET_GenericReturnValue parse_string_copy ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to string, and make a copy.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 319 of file json_helper.c.

{
  const char *str;
 
  (void) cls;
  str = json_string_value (root);
  if (NULL == str)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *((char **) spec->ptr) = GNUNET_strdup (str);
  return GNUNET_OK;
}

References GNUNET_JSON_Specification::cls, GNUNET_break_op, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_string_copy().

Here is the caller graph for this function:

GNUNET_JSON_spec_string_copy()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_string_copy	(	const char *	name,
		char **	strptr
	)

The expected field stores a string.

Parameters

name	name of the JSON field
strptr	where to store a pointer to the field

Definition at line 338 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_string_copy,
    .field = name,
    .ptr = strptr
  };
 
  *strptr = NULL;
  return ret;
}

References name, parse_string_copy(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_json()

static enum GNUNET_GenericReturnValue parse_json ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a JSON object.

(Yes, trivial.)

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 361 of file json_helper.c.

{
  if (! (json_is_object (root) || json_is_array (root)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *(json_t **) spec->ptr = json_incref (root);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_json().

Here is the caller graph for this function:

clean_json()

static void clean_json ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing JSON object.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 382 of file json_helper.c.

{
  json_t **ptr = (json_t **) spec->ptr;
 
  if (NULL != *ptr)
  {
    json_decref (*ptr);
    *ptr = NULL;
  }
}

References GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_array_copy(), GNUNET_JSON_spec_json(), and GNUNET_JSON_spec_object_copy().

Here is the caller graph for this function:

GNUNET_JSON_spec_json()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_json	(	const char *	name,
		json_t **	jsonp
	)

JSON object or array.

Reference counter is incremented.

Parameters

	name	name of the JSON field
[out]	jsonp	where to store the JSON found under name

Definition at line 396 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_json,
    .cleaner = &clean_json,
    .field = name,
    .ptr = jsonp,
  };
 
  *jsonp = NULL;
  return ret;
}

References clean_json(), name, parse_json(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_object_const()

static enum GNUNET_GenericReturnValue parse_object_const ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a JSON object.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 420 of file json_helper.c.

{
  if (NULL == root)
    return GNUNET_OK;
  if (! json_is_object (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *(const json_t **) spec->ptr = (const json_t *) root;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_object_const().

Here is the caller graph for this function:

GNUNET_JSON_spec_object_const()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_object_const	(	const char *	name,
		const json_t **	jsonp
	)

JSON object, reference counter not incremented.

Parameters

	name	name of the JSON field
[out]	jsonp	where to store the JSON found under name

Definition at line 437 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_object_const,
    .field = name,
    .ptr = jsonp,
  };
 
  *jsonp = NULL;
  return ret;
}

References name, parse_object_const(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_object_copy()

static enum GNUNET_GenericReturnValue parse_object_copy ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a JSON object and increment the reference counter.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 460 of file json_helper.c.

{
  if (NULL == root)
    return GNUNET_OK;
  if (! json_is_object (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *((json_t **) spec->ptr) = json_incref (root);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_object_copy().

Here is the caller graph for this function:

GNUNET_JSON_spec_object_copy()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_object_copy	(	const char *	name,
		json_t **	jsonp
	)

JSON object, reference counter not incremented.

Parameters

	name	name of the JSON field
[out]	jsonp	where to store the JSON found under name

Definition at line 477 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_object_copy,
    .cls = &clean_json,
    .field = name,
    .ptr = jsonp,
  };
 
  *jsonp = NULL;
  return ret;
}

References clean_json(), name, parse_object_copy(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_array_const()

static enum GNUNET_GenericReturnValue parse_array_const ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON to a JSON array.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 501 of file json_helper.c.

{
  if (NULL == root)
    return GNUNET_OK;
  if (! json_is_array (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *(const json_t **) spec->ptr = (const json_t *) root;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_array_const().

Here is the caller graph for this function:

GNUNET_JSON_spec_array_const()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_array_const	(	const char *	name,
		const json_t **	jsonp
	)

JSON array, reference counter not incremented.

Parameters

	name	name of the JSON field
[out]	jsonp	where to store the JSON found under name

Definition at line 518 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_array_const,
    .field = name,
    .ptr = jsonp
  };
 
  *jsonp = NULL;
  return ret;
}

References name, parse_array_const(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_array_copy()

static enum GNUNET_GenericReturnValue parse_array_copy ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON to a JSON array and increment the reference counter.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 541 of file json_helper.c.

{
  if (NULL == root)
    return GNUNET_OK;
  if (! json_is_array (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *((json_t **) spec->ptr) = json_incref (root);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_array_copy().

Here is the caller graph for this function:

GNUNET_JSON_spec_array_copy()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_array_copy	(	const char *	name,
		json_t **	jsonp
	)

JSON array, reference counter not incremented.

Parameters

	name	name of the JSON field
[out]	jsonp	where to store the JSON found under name

Definition at line 558 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_array_copy,
    .cleaner = &clean_json,
    .field = name,
    .ptr = jsonp
  };
 
  *jsonp = NULL;
  return ret;
}

References clean_json(), name, parse_array_copy(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_bool()

static enum GNUNET_GenericReturnValue parse_bool ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a bool.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 582 of file json_helper.c.

{
  bool *b = spec->ptr;
 
  if (json_true () == root)
  {
    *b = true;
    return GNUNET_OK;
  }
  if (json_false () == root)
  {
    *b = false;
    return GNUNET_OK;
  }
  GNUNET_break_op (0);
  return GNUNET_SYSERR;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_bool().

Here is the caller graph for this function:

GNUNET_JSON_spec_bool()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_bool	(	const char *	name,
		bool *	b
	)

boolean.

Parameters

	name	name of the JSON field
[out]	b	where to store the boolean found under name

Definition at line 604 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_bool,
    .field = name,
    .ptr = b,
    .ptr_size = sizeof(bool),
  };
 
  return ret;
}

References name, parse_bool(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_double()

static enum GNUNET_GenericReturnValue parse_double ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a double.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 627 of file json_helper.c.

{
  double *f = spec->ptr;
 
  if (! json_is_real (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *f = json_real_value (root);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_double().

Here is the caller graph for this function:

GNUNET_JSON_spec_double()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_double	(	const char *	name,
		double *	f
	)

double.

Parameters

	name	name of the JSON field
[out]	f	where to store the double found under name

Definition at line 644 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_double,
    .field = name,
    .ptr = f,
    .ptr_size = sizeof(double),
  };
 
  return ret;
}

References name, parse_double(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_u8()

static enum GNUNET_GenericReturnValue parse_u8 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a uint8_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 667 of file json_helper.c.

{
  json_int_t val;
  uint8_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ((0 > val) || (val > UINT8_MAX))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (uint8_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_uint8().

Here is the caller graph for this function:

GNUNET_JSON_spec_uint8()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_uint8	(	const char *	name,
		uint8_t *	u8
	)

8-bit integer.

Parameters

	name	name of the JSON field
[out]	u8	where to store the integer found under name

Definition at line 691 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_u8,
    .field = name,
    .ptr = u8,
    .ptr_size = sizeof(uint8_t),
  };
 
  return ret;
}

References name, parse_u8(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_u16()

static enum GNUNET_GenericReturnValue parse_u16 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a uint16_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 714 of file json_helper.c.

{
  json_int_t val;
  uint16_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ((0 > val) || (val > UINT16_MAX))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (uint16_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_uint16().

Here is the caller graph for this function:

GNUNET_JSON_spec_uint16()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_uint16	(	const char *	name,
		uint16_t *	u16
	)

16-bit integer.

Parameters

	name	name of the JSON field
[out]	u16	where to store the integer found under name

Definition at line 738 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_u16,
    .field = name,
    .ptr = u16,
    .ptr_size = sizeof(uint16_t),
  };
 
  return ret;
}

References name, parse_u16(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_u32()

static enum GNUNET_GenericReturnValue parse_u32 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a uint32_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 761 of file json_helper.c.

{
  json_int_t val;
  uint32_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ((0 > val) || (val > UINT32_MAX))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (uint32_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_uint32().

Here is the caller graph for this function:

GNUNET_JSON_spec_uint32()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_uint32	(	const char *	name,
		uint32_t *	u32
	)

32-bit integer.

Parameters

	name	name of the JSON field
[out]	u32	where to store the integer found under name

Definition at line 785 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_u32,
    .field = name,
    .ptr = u32,
    .ptr_size = sizeof(uint32_t),
  };
 
  return ret;
}

References name, parse_u32(), GNUNET_JSON_Specification::parser, and ret.

Referenced by parse_blinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_ui()

static enum GNUNET_GenericReturnValue parse_ui ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to an unsigned int.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 808 of file json_helper.c.

{
  json_int_t val;
  unsigned int *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ((0 > val) || (val > UINT_MAX))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (unsigned int) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_uint().

Here is the caller graph for this function:

GNUNET_JSON_spec_uint()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_uint	(	const char *	name,
		unsigned int *	ui
	)

Unsigned integer.

Parameters

	name	name of the JSON field
[out]	ui	where to store the integer found under name

Definition at line 832 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_ui,
    .field = name,
    .ptr = ui,
    .ptr_size = sizeof(unsigned int),
  };
 
  return ret;
}

References name, parse_ui(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_ull()

static enum GNUNET_GenericReturnValue parse_ull ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to an unsigned long long.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 855 of file json_helper.c.

{
  json_int_t val;
  unsigned long long *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ((0 > val) || (val > ULLONG_MAX))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (unsigned long long) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_ull().

Here is the caller graph for this function:

GNUNET_JSON_spec_ull()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_ull	(	const char *	name,
		unsigned long long *	ull
	)

Unsigned long long.

Parameters

	name	name of the JSON field
[out]	ull	where to store the unsigned long long found under name

Definition at line 879 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_ull,
    .field = name,
    .ptr = ull,
    .ptr_size = sizeof(unsigned long long),
  };
 
  return ret;
}

References name, parse_ull(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_u64()

static enum GNUNET_GenericReturnValue parse_u64 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a uint64_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 902 of file json_helper.c.

{
  json_int_t val;
  uint64_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  *up = (uint64_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_uint64().

Here is the caller graph for this function:

GNUNET_JSON_spec_uint64()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_uint64	(	const char *	name,
		uint64_t *	u64
	)

64-bit integer.

Parameters

	name	name of the JSON field
[out]	u64	where to store the integer found under name

Definition at line 921 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_u64,
    .field = name,
    .ptr = u64,
    .ptr_size = sizeof(uint64_t),
  };
 
  return ret;
}

References name, parse_u64(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_i16()

static enum GNUNET_GenericReturnValue parse_i16 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a int16_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 944 of file json_helper.c.

{
  json_int_t val;
  int16_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  if ( (val < INT16_MIN) ||
       (val > INT16_MAX) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *up = (int16_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_int16().

Here is the caller graph for this function:

GNUNET_JSON_spec_int16()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_int16	(	const char *	name,
		int16_t *	i16
	)

16-bit signed integer.

Parameters

	name	name of the JSON field
[out]	i16	where to store the integer found under name

Definition at line 969 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_i16,
    .field = name,
    .ptr = i16,
    .ptr_size = sizeof(int16_t),
  };
 
  return ret;
}

References name, parse_i16(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_i64()

static enum GNUNET_GenericReturnValue parse_i64 ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a int64_t.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 992 of file json_helper.c.

{
  json_int_t val;
  int64_t *up = spec->ptr;
 
  if (! json_is_integer (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  val = json_integer_value (root);
  *up = (int64_t) val;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_int64().

Here is the caller graph for this function:

GNUNET_JSON_spec_int64()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_int64	(	const char *	name,
		int64_t *	i64
	)

64-bit signed integer.

Parameters

	name	name of the JSON field
[out]	i64	where to store the integer found under name

Definition at line 1011 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_i64,
    .field = name,
    .ptr = i64,
    .ptr_size = sizeof(int64_t),
  };
 
  return ret;
}

References name, parse_i64(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_timestamp()

static enum GNUNET_GenericReturnValue parse_timestamp ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a timestamp.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1036 of file json_helper.c.

{
  struct GNUNET_TIME_Timestamp *ts = spec->ptr;
  json_t *json_t_s;
  unsigned long long int tval;
 
  if (! json_is_object (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  json_t_s = json_object_get (root,
                              "t_s");
  if (json_is_integer (json_t_s))
  {
    tval = json_integer_value (json_t_s);
    /* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
    ts->abs_time.abs_value_us
      = tval * GNUNET_TIME_UNIT_SECONDS.rel_value_us;
    if (ts->abs_time.abs_value_us
        / GNUNET_TIME_UNIT_SECONDS.rel_value_us
        != tval)
    {
      /* Integer overflow */
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    return GNUNET_OK;
  }
  if (json_is_string (json_t_s))
  {
    const char *val;
 
    val = json_string_value (json_t_s);
    if ((0 == strcasecmp (val,
                          "never")))
    {
      ts->abs_time = GNUNET_TIME_UNIT_FOREVER_ABS;
      return GNUNET_OK;
    }
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_break_op (0);
  return GNUNET_SYSERR;
}

References GNUNET_TIME_Timestamp::abs_time, GNUNET_TIME_Absolute::abs_value_us, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_SECONDS, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_timestamp(), and parse_timestamp_nbo().

Here is the caller graph for this function:

GNUNET_JSON_spec_timestamp()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_timestamp	(	const char *	name,
		struct GNUNET_TIME_Timestamp *	t
	)

Timestamp.

Parameters

	name	name of the JSON field
[out]	t	at where to store the absolute time found under name

Definition at line 1087 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_timestamp,
    .field = name,
    .ptr = t,
    .ptr_size = sizeof(struct GNUNET_TIME_Timestamp)
  };
 
  return ret;
}

References name, parse_timestamp(), GNUNET_JSON_Specification::parser, ret, and t.

Here is the call graph for this function:

parse_timestamp_nbo()

static enum GNUNET_GenericReturnValue parse_timestamp_nbo ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to absolute time.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1110 of file json_helper.c.

{
  struct GNUNET_TIME_TimestampNBO *ts = spec->ptr;
  struct GNUNET_TIME_Timestamp a;
  struct GNUNET_JSON_Specification ispec;
 
  ispec = *spec;
  ispec.parser = &parse_timestamp;
  ispec.ptr = &a;
  if (GNUNET_OK !=
      parse_timestamp (NULL,
                       root,
                       &ispec))
    return GNUNET_SYSERR;
  *ts = GNUNET_TIME_timestamp_hton (a);
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_timestamp_hton(), parse_timestamp(), GNUNET_JSON_Specification::parser, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_timestamp_nbo().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_timestamp_nbo()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_timestamp_nbo	(	const char *	name,
		struct GNUNET_TIME_TimestampNBO *	tn
	)

Timestamp in network byte order.

Parameters

	name	name of the JSON field
[out]	tn	where to store the absolute time found under name

Definition at line 1132 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_timestamp_nbo,
    .field = name,
    .ptr = at,
    .ptr_size = sizeof(struct GNUNET_TIME_TimestampNBO)
  };
 
  return ret;
}

References name, parse_timestamp_nbo(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_rel_time()

static enum GNUNET_GenericReturnValue parse_rel_time ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to relative time.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1155 of file json_helper.c.

{
  struct GNUNET_TIME_Relative *rel = spec->ptr;
  json_t *json_d_us;
  unsigned long long int tval;
 
  if (! json_is_object (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  json_d_us = json_object_get (root,
                               "d_us");
  if (json_is_integer (json_d_us))
  {
    tval = json_integer_value (json_d_us);
    if (tval >= (1LLU << 53))
    {
      /* value is larger than allowed */
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    rel->rel_value_us = tval;
    return GNUNET_OK;
  }
  if (json_is_string (json_d_us))
  {
    const char *val;
 
    val = json_string_value (json_d_us);
    if ((0 == strcasecmp (val,
                          "forever")))
    {
      *rel = GNUNET_TIME_UNIT_FOREVER_REL;
      return GNUNET_OK;
    }
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_break_op (0);
  return GNUNET_SYSERR;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_JSON_Specification::ptr, and GNUNET_TIME_Relative::rel_value_us.

Referenced by GNUNET_JSON_spec_relative_time().

Here is the caller graph for this function:

GNUNET_JSON_spec_relative_time()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_relative_time	(	const char *	name,
		struct GNUNET_TIME_Relative *	rt
	)

Relative time.

Parameters

	name	name of the JSON field
[out]	rt	where to store the relative time found under name

Definition at line 1202 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_rel_time,
    .field = name,
    .ptr = rt,
    .ptr_size = sizeof(struct GNUNET_TIME_Relative)
  };
 
  return ret;
}

References name, parse_rel_time(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_rsa_public_key()

static enum GNUNET_GenericReturnValue parse_rsa_public_key ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to RSA public key.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1225 of file json_helper.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey **pk = spec->ptr;
  const char *enc;
  char *buf;
  size_t len;
  size_t buf_len;
 
  if (NULL == (enc = json_string_value (root)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  len = strlen (enc);
  buf_len = (len * 5) / 8;
  buf = GNUNET_malloc (buf_len);
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (enc,
                                     len,
                                     buf,
                                     buf_len))
  {
    GNUNET_break_op (0);
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  if (NULL == (*pk = GNUNET_CRYPTO_rsa_public_key_decode (buf,
                                                          buf_len)))
  {
    GNUNET_break_op (0);
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  return GNUNET_OK;
}

References enc, GNUNET_break_op, GNUNET_CRYPTO_rsa_public_key_decode(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, pk, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_rsa_public_key().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_rsa_public_key()

static void clean_rsa_public_key ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing RSA public key.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 1272 of file json_helper.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey **pk = spec->ptr;
 
  if (NULL != *pk)
  {
    GNUNET_CRYPTO_rsa_public_key_free (*pk);
    *pk = NULL;
  }
}

References GNUNET_CRYPTO_rsa_public_key_free(), pk, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_rsa_public_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_rsa_public_key()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_rsa_public_key	(	const char *	name,
		struct GNUNET_CRYPTO_RsaPublicKey **	pk
	)

Specification for parsing an RSA public key.

Parameters

name	name of the JSON field
pk	where to store the RSA key found under name

Definition at line 1286 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_rsa_public_key,
    .cleaner = &clean_rsa_public_key,
    .field = name,
    .ptr = pk
  };
 
  *pk = NULL;
  return ret;
}

References clean_rsa_public_key(), name, parse_rsa_public_key(), GNUNET_JSON_Specification::parser, pk, and ret.

Here is the call graph for this function:

parse_rsa_signature()

static enum GNUNET_GenericReturnValue parse_rsa_signature ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to RSA signature.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1310 of file json_helper.c.

{
  struct GNUNET_CRYPTO_RsaSignature **sig = spec->ptr;
  size_t size;
  const char *str;
  int res;
  void *buf;
 
  str = json_string_value (root);
  if (NULL == str)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  size = (strlen (str) * 5) / 8;
  buf = GNUNET_malloc (size);
  res = GNUNET_STRINGS_string_to_data (str,
                                       strlen (str),
                                       buf,
                                       size);
  if (GNUNET_OK != res)
  {
    GNUNET_free (buf);
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (NULL == (*sig = GNUNET_CRYPTO_rsa_signature_decode (buf,
                                                          size)))
  {
    GNUNET_break_op (0);
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_CRYPTO_rsa_signature_decode(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, res, and size.

Referenced by GNUNET_JSON_spec_rsa_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_rsa_signature()

static void clean_rsa_signature ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing RSA signature.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 1357 of file json_helper.c.

{
  struct GNUNET_CRYPTO_RsaSignature  **sig = spec->ptr;
 
  if (NULL != *sig)
  {
    GNUNET_CRYPTO_rsa_signature_free (*sig);
    *sig = NULL;
  }
}

References GNUNET_CRYPTO_rsa_signature_free(), and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_rsa_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_rsa_signature()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_rsa_signature	(	const char *	name,
		struct GNUNET_CRYPTO_RsaSignature **	sig
	)

Specification for parsing an RSA signature.

Parameters

name	name of the JSON field
sig	where to store the RSA signature found under name

Definition at line 1371 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_rsa_signature,
    .cleaner = &clean_rsa_signature,
    .cls = NULL,
    .field = name,
    .ptr = sig,
    .ptr_size = 0,
    .size_ptr = NULL
  };
 
  *sig = NULL;
  return ret;
}

References clean_rsa_signature(), name, parse_rsa_signature(), GNUNET_JSON_Specification::parser, and ret.

Referenced by parse_blinded_sig(), and parse_unblinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_boolean()

static enum GNUNET_GenericReturnValue parse_boolean ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to an int as a boolean.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1398 of file json_helper.c.

{
  int *bp = spec->ptr;
 
  if (! json_is_boolean (root))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  *bp = json_boolean_value (root) ? GNUNET_YES : GNUNET_NO;
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_boolean().

Here is the caller graph for this function:

GNUNET_JSON_spec_boolean()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_boolean	(	const char *	name,
		int *	boolean
	)

Boolean (true mapped to GNUNET_YES, false mapped to GNUNET_NO).

Parameters

	name	name of the JSON field
[out]	boolean	where to store the boolean found under name

Definition at line 1415 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_boolean,
    .field = name,
    .ptr = boolean,
    .ptr_size = sizeof(int),
  };
 
  return ret;
}

References name, parse_boolean(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_blinded_message()

static enum GNUNET_GenericReturnValue parse_blinded_message ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a blinded message.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1438 of file json_helper.c.

{
  struct GNUNET_CRYPTO_BlindedMessage **target = spec->ptr;
  struct GNUNET_CRYPTO_BlindedMessage *blinded_message;
  const char *cipher;
  struct GNUNET_JSON_Specification dspec[] = {
    GNUNET_JSON_spec_string ("cipher",
                             &cipher),
    GNUNET_JSON_spec_end ()
  };
  const char *emsg;
  unsigned int eline;
 
  (void) cls;
  if (GNUNET_OK !=
      GNUNET_JSON_parse (root,
                         dspec,
                         &emsg,
                         &eline))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  blinded_message = GNUNET_new (struct GNUNET_CRYPTO_BlindedMessage);
  blinded_message->rc = 1;
  blinded_message->cipher = string_to_cipher (cipher);
  switch (blinded_message->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_varsize (
          /* TODO: Change this field name to something
                   more generic / pass in as argument. */
          "rsa_blinded_planchet",
          &blinded_message->details.rsa_blinded_message.blinded_msg,
          &blinded_message->details.rsa_blinded_message.blinded_msg_size),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (blinded_message);
        return GNUNET_SYSERR;
      }
      *target = blinded_message;
      return GNUNET_OK;
    }
  case GNUNET_CRYPTO_BSA_CS:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_fixed_auto (
          "cs_nonce",
          &blinded_message->details.cs_blinded_message.nonce),
        GNUNET_JSON_spec_fixed_auto (
          "cs_blinded_c0",
          &blinded_message->details.cs_blinded_message.c[0]),
        GNUNET_JSON_spec_fixed_auto (
          "cs_blinded_c1",
          &blinded_message->details.cs_blinded_message.c[1]),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (blinded_message);
        return GNUNET_SYSERR;
      }
      *target = blinded_message;
      return GNUNET_OK;
    }
  }
  GNUNET_break_op (0);
  GNUNET_free (blinded_message);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_RsaBlindedMessage::blinded_msg, GNUNET_CRYPTO_RsaBlindedMessage::blinded_msg_size, GNUNET_CRYPTO_CsBlindedMessage::c, GNUNET_CRYPTO_BlindedMessage::cipher, GNUNET_JSON_Specification::cls, GNUNET_CRYPTO_BlindedMessage::cs_blinded_message, GNUNET_CRYPTO_BlindedMessage::details, GNUNET_break_op, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_free, GNUNET_JSON_parse(), GNUNET_JSON_spec_end(), GNUNET_JSON_spec_fixed_auto, GNUNET_JSON_spec_string(), GNUNET_JSON_spec_varsize(), GNUNET_new, GNUNET_OK, GNUNET_SYSERR, GNUNET_CRYPTO_CsBlindedMessage::nonce, GNUNET_JSON_Specification::ptr, GNUNET_CRYPTO_BlindedMessage::rc, GNUNET_CRYPTO_BlindedMessage::rsa_blinded_message, and string_to_cipher().

Referenced by GNUNET_JSON_spec_blinded_message().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_blinded_message()

static void clean_blinded_message ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing blinded message.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 1537 of file json_helper.c.

{
  struct GNUNET_CRYPTO_BlindedMessage **blinded_message = spec->ptr;
 
  (void) cls;
  if (NULL != blinded_message)
  {
    GNUNET_CRYPTO_blinded_message_decref (*blinded_message);
    *blinded_message = NULL;
  }
}

References GNUNET_CRYPTO_blinded_message_decref(), and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_blinded_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_blinded_message()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_blinded_message	(	const char *	name,
		struct GNUNET_CRYPTO_BlindedMessage **	msg
	)

Specification for parsing a blinded message.

Parameters

name	name of the JSON field
sig	where to store the blinded message found under name

Definition at line 1552 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_blinded_message,
    .cleaner = &clean_blinded_message,
    .cls = NULL,
    .field = name,
    .ptr = msg,
    .ptr_size = 0,
    .size_ptr = NULL
  };
 
  *msg = NULL;
  return ret;
}

References clean_blinded_message(), msg, name, parse_blinded_message(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_blinded_sig()

static enum GNUNET_GenericReturnValue parse_blinded_sig ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to a blinded signature.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1579 of file json_helper.c.

{
  struct GNUNET_CRYPTO_BlindedSignature **target = spec->ptr;
  struct GNUNET_CRYPTO_BlindedSignature *blinded_sig;
  const char *cipher;
  struct GNUNET_JSON_Specification dspec[] = {
    GNUNET_JSON_spec_string ("cipher",
                             &cipher),
    GNUNET_JSON_spec_end ()
  };
  const char *emsg;
  unsigned int eline;
 
  (void) cls;
  if (GNUNET_OK !=
      GNUNET_JSON_parse (root,
                         dspec,
                         &emsg,
                         &eline))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  blinded_sig = GNUNET_new (struct GNUNET_CRYPTO_BlindedSignature);
  blinded_sig->cipher = string_to_cipher (cipher);
  blinded_sig->rc = 1;
  switch (blinded_sig->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_rsa_signature (
          "blinded_rsa_signature",
          &blinded_sig->details.blinded_rsa_signature),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (blinded_sig);
        return GNUNET_SYSERR;
      }
      *target = blinded_sig;
      return GNUNET_OK;
    }
  case GNUNET_CRYPTO_BSA_CS:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_uint32 ("b",
                                 &blinded_sig->details.blinded_cs_answer.b),
        GNUNET_JSON_spec_fixed_auto ("s",
                                     &blinded_sig->details.blinded_cs_answer.
                                     s_scalar),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (blinded_sig);
        return GNUNET_SYSERR;
      }
      *target = blinded_sig;
      return GNUNET_OK;
    }
  }
  GNUNET_break_op (0);
  GNUNET_free (blinded_sig);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_CsBlindSignature::b, GNUNET_CRYPTO_BlindedSignature::blinded_cs_answer, GNUNET_CRYPTO_BlindedSignature::blinded_rsa_signature, GNUNET_CRYPTO_BlindedSignature::cipher, GNUNET_JSON_Specification::cls, GNUNET_CRYPTO_BlindedSignature::details, GNUNET_break_op, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_free, GNUNET_JSON_parse(), GNUNET_JSON_spec_end(), GNUNET_JSON_spec_fixed_auto, GNUNET_JSON_spec_rsa_signature(), GNUNET_JSON_spec_string(), GNUNET_JSON_spec_uint32(), GNUNET_new, GNUNET_OK, GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, GNUNET_CRYPTO_BlindedSignature::rc, and string_to_cipher().

Referenced by GNUNET_JSON_spec_blinded_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_blinded_sig()

static void clean_blinded_sig ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing blinded sig.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 1671 of file json_helper.c.

{
  struct GNUNET_CRYPTO_BlindedSignature **b_sig = spec->ptr;
 
  (void) cls;
 
  if (NULL != *b_sig)
  {
    GNUNET_CRYPTO_blinded_sig_decref (*b_sig);
    *b_sig = NULL;
  }
}

References GNUNET_CRYPTO_blinded_sig_decref(), and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_blinded_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_blinded_signature()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_blinded_signature	(	const char *	field,
		struct GNUNET_CRYPTO_BlindedSignature **	b_sig
	)

Specification for parsing a blinded signature.

Parameters

name	name of the JSON field
sig	where to store the blinded signature found under name

Definition at line 1687 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_blinded_sig,
    .cleaner = &clean_blinded_sig,
    .field = field,
    .ptr = b_sig
  };
 
  *b_sig = NULL;
  return ret;
}

References clean_blinded_sig(), GNUNET_JSON_Specification::field, parse_blinded_sig(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function:

parse_unblinded_sig()

static enum GNUNET_GenericReturnValue parse_unblinded_sig ( void *  cls, json_t *  root, struct GNUNET_JSON_Specification *  spec  )

static

Parse given JSON object to unblinded signature.

Parameters

	cls	closure, NULL
	root	the json object representing data
[out]	spec	where to write the data

Returns

GNUNET_OK upon successful parsing; GNUNET_SYSERR upon error

Definition at line 1712 of file json_helper.c.

{
  struct GNUNET_CRYPTO_UnblindedSignature **target = spec->ptr;
  struct GNUNET_CRYPTO_UnblindedSignature *unblinded_sig;
  const char *cipher;
  struct GNUNET_JSON_Specification dspec[] = {
    GNUNET_JSON_spec_string ("cipher",
                             &cipher),
    GNUNET_JSON_spec_end ()
  };
  const char *emsg;
  unsigned int eline;
 
  (void) cls;
  if (GNUNET_OK !=
      GNUNET_JSON_parse (root,
                         dspec,
                         &emsg,
                         &eline))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  unblinded_sig = GNUNET_new (struct GNUNET_CRYPTO_UnblindedSignature);
  unblinded_sig->cipher = string_to_cipher (cipher);
  unblinded_sig->rc = 1;
  switch (unblinded_sig->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_rsa_signature (
          "rsa_signature",
          &unblinded_sig->details.rsa_signature),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (unblinded_sig);
        return GNUNET_SYSERR;
      }
      *target = unblinded_sig;
      return GNUNET_OK;
    }
  case GNUNET_CRYPTO_BSA_CS:
    {
      struct GNUNET_JSON_Specification ispec[] = {
        GNUNET_JSON_spec_fixed_auto ("cs_signature_r",
                                     &unblinded_sig->details.cs_signature.
                                     r_point),
        GNUNET_JSON_spec_fixed_auto ("cs_signature_s",
                                     &unblinded_sig->details.cs_signature.
                                     s_scalar),
        GNUNET_JSON_spec_end ()
      };
 
      if (GNUNET_OK !=
          GNUNET_JSON_parse (root,
                             ispec,
                             &emsg,
                             &eline))
      {
        GNUNET_break_op (0);
        GNUNET_free (unblinded_sig);
        return GNUNET_SYSERR;
      }
      *target = unblinded_sig;
      return GNUNET_OK;
    }
  }
  GNUNET_break_op (0);
  GNUNET_free (unblinded_sig);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_UnblindedSignature::cipher, GNUNET_JSON_Specification::cls, GNUNET_CRYPTO_UnblindedSignature::cs_signature, GNUNET_CRYPTO_UnblindedSignature::details, GNUNET_break_op, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_free, GNUNET_JSON_parse(), GNUNET_JSON_spec_end(), GNUNET_JSON_spec_fixed_auto, GNUNET_JSON_spec_rsa_signature(), GNUNET_JSON_spec_string(), GNUNET_new, GNUNET_OK, GNUNET_SYSERR, GNUNET_JSON_Specification::ptr, GNUNET_CRYPTO_UnblindedSignature::rc, GNUNET_CRYPTO_UnblindedSignature::rsa_signature, and string_to_cipher().

Referenced by GNUNET_JSON_spec_unblinded_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_unblinded_sig()

static void clean_unblinded_sig ( void *  cls, struct GNUNET_JSON_Specification *  spec  )

static

Cleanup data left from parsing unblinded signature.

Parameters

	cls	closure, NULL
[out]	spec	where to free the data

Definition at line 1805 of file json_helper.c.

{
  struct GNUNET_CRYPTO_UnblindedSignature **ub_sig = spec->ptr;
 
  (void) cls;
  if (NULL != *ub_sig)
  {
    GNUNET_CRYPTO_unblinded_sig_decref (*ub_sig);
    *ub_sig = NULL;
  }
}

References GNUNET_CRYPTO_unblinded_sig_decref(), and GNUNET_JSON_Specification::ptr.

Referenced by GNUNET_JSON_spec_unblinded_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_JSON_spec_unblinded_signature()

struct GNUNET_JSON_Specification GNUNET_JSON_spec_unblinded_signature	(	const char *	field,
		struct GNUNET_CRYPTO_UnblindedSignature **	ub_sig
	)

Specification for parsing an unblinded signature.

Parameters

name	name of the JSON field
sig	where to store the unblinded signature found under name

Definition at line 1820 of file json_helper.c.

{
  struct GNUNET_JSON_Specification ret = {
    .parser = &parse_unblinded_sig,
    .cleaner = &clean_unblinded_sig,
    .field = field,
    .ptr = ub_sig
  };
 
  *ub_sig = NULL;
  return ret;
}

References clean_unblinded_sig(), GNUNET_JSON_Specification::field, parse_unblinded_sig(), GNUNET_JSON_Specification::parser, and ret.

Here is the call graph for this function: