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. More...
static enum GNUNET_CRYPTO_BlindSignatureAlgorithm	string_to_cipher (const char *cipher_s)
	Convert string value to numeric cipher value. More...
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. More...
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). More...
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. More...
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). More...
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. More...
static void	clean_variable_data (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing variable size data. More...
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). More...
static enum GNUNET_GenericReturnValue	parse_string (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to string. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_string (const char *name, const char **strptr)
	The expected field stores a string. More...
static enum GNUNET_GenericReturnValue	parse_json (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a JSON object. More...
static void	clean_json (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing JSON object. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_json (const char *name, json_t **jsonp)
	JSON object or array. More...
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. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_object_const (const char *name, const json_t **jsonp)
	JSON object, reference counter not incremented. More...
static enum GNUNET_GenericReturnValue	parse_array_const (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON to a JSON array. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_array_const (const char *name, const json_t **jsonp)
	JSON array, reference counter not incremented. More...
static enum GNUNET_GenericReturnValue	parse_bool (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a bool. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_bool (const char *name, bool *b)
	boolean. More...
static enum GNUNET_GenericReturnValue	parse_double (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a double. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_double (const char *name, double *f)
	double. More...
static enum GNUNET_GenericReturnValue	parse_u8 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint8_t. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint8 (const char *name, uint8_t *u8)
	8-bit integer. More...
static enum GNUNET_GenericReturnValue	parse_u16 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint16_t. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint16 (const char *name, uint16_t *u16)
	16-bit integer. More...
static enum GNUNET_GenericReturnValue	parse_u32 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint32_t. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint32 (const char *name, uint32_t *u32)
	32-bit integer. More...
static enum GNUNET_GenericReturnValue	parse_u64 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a uint64_t. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_uint64 (const char *name, uint64_t *u64)
	64-bit integer. More...
static enum GNUNET_GenericReturnValue	parse_i64 (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a int64_t. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_int64 (const char *name, int64_t *i64)
	64-bit signed integer. More...
static enum GNUNET_GenericReturnValue	parse_timestamp (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to a timestamp. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_timestamp (const char *name, struct GNUNET_TIME_Timestamp *t)
	Timestamp. More...
static enum GNUNET_GenericReturnValue	parse_timestamp_nbo (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to absolute time. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_timestamp_nbo (const char *name, struct GNUNET_TIME_TimestampNBO *at)
	Timestamp in network byte order. More...
static enum GNUNET_GenericReturnValue	parse_rel_time (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to relative time. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_relative_time (const char *name, struct GNUNET_TIME_Relative *rt)
	Relative time. More...
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. More...
static void	clean_rsa_public_key (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing RSA public key. More...
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. More...
static enum GNUNET_GenericReturnValue	parse_rsa_signature (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to RSA signature. More...
static void	clean_rsa_signature (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing RSA signature. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_rsa_signature (const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
	Specification for parsing an RSA signature. More...
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. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_boolean (const char *name, int *boolean)
	Boolean (true mapped to GNUNET_YES, false mapped to GNUNET_NO). More...
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. More...
static void	clean_blinded_message (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing blinded message. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_blinded_message (const char *name, struct GNUNET_CRYPTO_BlindedMessage **msg)
	Specification for parsing a blinded message. More...
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. More...
static void	clean_blinded_sig (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing blinded sig. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_blinded_signature (const char *field, struct GNUNET_CRYPTO_BlindedSignature **b_sig)
	Specification for parsing a blinded signature. More...
static enum GNUNET_GenericReturnValue	parse_unblinded_sig (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
	Parse given JSON object to unblinded signature. More...
static void	clean_unblinded_sig (void *cls, struct GNUNET_JSON_Specification *spec)
	Cleanup data left from parsing unblinded signature. More...
struct GNUNET_JSON_Specification	GNUNET_JSON_spec_unblinded_signature (const char *field, struct GNUNET_CRYPTO_UnblindedSignature **ub_sig)
	Specification for parsing an unblinded signature. More...

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,
    .cleaner = NULL,
    .cls = NULL
  };
 
  return ret;
}

References 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 52 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 77 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 117 of file json_helper.c.

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

References name, parse_fixed_data(), 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 144 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 181 of file json_helper.c.

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

References name, parse_fixed64_data(), 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 208 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 244 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 258 of file json_helper.c.

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

References clean_variable_data(), name, parse_variable_data(), 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 287 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 306 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(), 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_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 329 of file json_helper.c.

{
  if (! (json_is_object (root) || json_is_array (root)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  json_incref (root);
  *(json_t **) spec->ptr = 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 351 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_json().

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 365 of file json_helper.c.

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

References clean_json(), name, parse_json(), 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 392 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 409 of file json_helper.c.

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

References name, parse_object_const(), 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 435 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 452 of file json_helper.c.

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

References name, parse_array_const(), 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 478 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 500 of file json_helper.c.

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

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

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 526 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 removetrailingwhitespace::f, 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 543 of file json_helper.c.

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

References removetrailingwhitespace::f, name, parse_double(), ret, and GNUNET_JSON_Specification::size_ptr.

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 569 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 593 of file json_helper.c.

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

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

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 619 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 643 of file json_helper.c.

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

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

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 669 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 693 of file json_helper.c.

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

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

Referenced by parse_blinded_sig().

Here is the call graph for this function:

Here is the caller 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 719 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 738 of file json_helper.c.

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

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

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 764 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 783 of file json_helper.c.

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

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

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 811 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 862 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(), 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 885 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 907 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(), 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 930 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 977 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(), 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 1000 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 1047 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 1061 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(), 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 1085 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 1132 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 1146 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(), 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 1173 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 1190 of file json_helper.c.

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

References consensus-simulation::int, name, parse_boolean(), ret, and GNUNET_JSON_Specification::size_ptr.

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 1216 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 1314 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 1329 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(), 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 1356 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 1448 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 1464 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(), 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 1487 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 1580 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 1595 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(), and ret.

Here is the call graph for this function: