/**
* Parse a hello URI string to a hello message.
*
* @param uri URI string to parse
* @param pubkey Pointer to struct where public key is parsed
* @param hello Pointer to struct where hello message is parsed
* @param plugins_find Function to find transport plugins by name
* @return GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors
*/
int
GNUNET_HELLO_parse_uri (const char *uri,
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey,
struct GNUNET_HELLO_Message **hello,
GNUNET_HELLO_TransportPluginsFind plugins_find)
{
const char *pks;
const char *exc;
struct GNUNET_HELLO_ParseUriContext ctx;
if (0 != strncmp (uri,
GNUNET_HELLO_URI_PREFIX,
strlen (GNUNET_HELLO_URI_PREFIX)))
return GNUNET_SYSERR;
pks = &uri[strlen (GNUNET_HELLO_URI_PREFIX)];
exc = strstr (pks, "!");
if (GNUNET_OK !=
GNUNET_STRINGS_string_to_data (pks,
(NULL == exc) ? strlen (pks) : (exc - pks),
(unsigned char *) pubkey,
sizeof (*pubkey)))
return GNUNET_SYSERR;
ctx.pos = exc;
ctx.ret = GNUNET_OK;
ctx.plugins_find = plugins_find;
*hello = GNUNET_HELLO_create (pubkey, &add_address_to_hello, &ctx);
return ctx.ret;
}
/**
* Parse given JSON object to fixed size data
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_fixed_data (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
const char *enc;
unsigned int len;
if (NULL == (enc = json_string_value (root)))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
len = strlen (enc);
if (((len * 5) / 8) != spec->ptr_size)
{
GNUNET_break_op (0);
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;
}
/**
* Convert human-readable version of a 'value' of a record to the binary
* representation.
*
* @param cls closure, unused
* @param type type of the record
* @param s human-readable string
* @param data set to value in binary encoding (will be allocated)
* @param data_size set to number of bytes in @a data
* @return #GNUNET_OK on success
*/
static int
conversation_string_to_value (void *cls,
uint32_t type,
const char *s,
void **data,
size_t *data_size)
{
if (NULL == s)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
switch (type)
{
case GNUNET_GNSRECORD_TYPE_PHONE:
{
struct GNUNET_CONVERSATION_PhoneRecord *pr;
char line_port[103];
const char *dash;
struct GNUNET_PeerIdentity peer;
if ( (NULL == (dash = strchr (s, '-'))) ||
(1 != sscanf (s, "%103s-", line_port)) ||
(GNUNET_OK !=
GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
strlen (dash + 1),
&peer.public_key)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse PHONE record `%s'\n"),
s);
return GNUNET_SYSERR;
}
pr = GNUNET_new (struct GNUNET_CONVERSATION_PhoneRecord);
pr->version = htonl (1);
pr->reserved = htonl (0);
if (GNUNET_OK !=
GNUNET_STRINGS_string_to_data (line_port,
strlen (line_port),
&pr->line_port,
sizeof (struct GNUNET_HashCode)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse PHONE record `%s'\n"),
s);
GNUNET_free (pr);
return GNUNET_SYSERR;
}
pr->peer = peer;
*data = pr;
*data_size = sizeof (struct GNUNET_CONVERSATION_PhoneRecord);
return GNUNET_OK;
}
default:
return GNUNET_SYSERR;
}
}
/**
* Convert ASCII encoding back to a 'struct GNUNET_CRYPTO_ShortHash'
*
* @param enc the encoding
* @param enclen number of characters in 'enc' (without 0-terminator, which can be missing)
* @param result where to store the GNUNET_CRYPTO_hash code
* @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
*/
int
GNUNET_CRYPTO_short_hash_from_string2 (const char *enc, size_t enclen,
struct GNUNET_CRYPTO_ShortHashCode * result)
{
char upper_enc[enclen];
char* up_ptr = upper_enc;
GNUNET_STRINGS_utf8_toupper(enc, &up_ptr);
return GNUNET_STRINGS_string_to_data (upper_enc, enclen,
(unsigned char*) result,
sizeof (struct GNUNET_CRYPTO_ShortHashCode));
}
/**
* Parse the PUT URI given at the command line and add it to our peerinfo
* database.
*
* @param put_uri URI string to parse
* @return GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors
*/
static int
parse_hello_uri (const char *put_uri)
{
const char *pks;
const char *exc;
struct GNUNET_HELLO_Message *hello;
struct GNUNET_PEERINFO_HelloAddressParsingContext ctx;
if (0 != strncmp (put_uri,
HELLO_URI_PREFIX,
strlen (HELLO_URI_PREFIX)))
return GNUNET_SYSERR;
pks = &put_uri[strlen (HELLO_URI_PREFIX)];
exc = strstr (pks, "!");
if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pks,
(NULL == exc) ? strlen (pks) : (exc - pks),
(unsigned char *) &my_public_key,
sizeof (my_public_key)))
return GNUNET_SYSERR;
ctx.pos = exc;
ctx.ret = GNUNET_OK;
hello = GNUNET_HELLO_create (&my_public_key, &add_address_to_hello, &ctx);
if (NULL != hello)
{
/* WARNING: this adds the address from URI WITHOUT verification! */
if (GNUNET_OK == ctx.ret)
ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, &add_continuation, NULL);
else
tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
GNUNET_free (hello);
}
/* wait 1s to give peerinfo operation a chance to succeed */
/* FIXME: current peerinfo API sucks to require this; not to mention
that we get no feedback to determine if the operation actually succeeded */
return ctx.ret;
}
/**
* Parse given JSON object to variable size data
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_variable_data (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
const char *str;
size_t size;
void *data;
int res;
str = json_string_value (root);
if (NULL == str)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
size = (strlen (str) * 5) / 8;
if (size >= 1024)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
data = GNUNET_malloc (size);
res = GNUNET_STRINGS_string_to_data (str,
strlen (str),
data,
size);
if (GNUNET_OK != res)
{
GNUNET_break_op (0);
GNUNET_free (data);
return GNUNET_SYSERR;
}
*(void**) spec->ptr = data;
*spec->size_ptr = size;
return GNUNET_OK;
}
/**
* Variable size object (in network byte order, encoded using
* Crockford Base32hex encoding).
*
* @param name name of the JSON field
* @param[out] obj pointer where to write the data, will be allocated
* @param[out] size where to store the number of bytes allocated for @a obj
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_varsize (const char *name,
void **obj,
size_t *size)
{
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;
}
/**
* Parse given JSON object to string.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_string (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
const char *str;
str = json_string_value (root);
if (NULL == str)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*(const char **) spec->ptr = str;
return GNUNET_OK;
}
/**
* The expected field stores a string.
*
* @param name name of the JSON field
* @param strptr where to store a pointer to the field
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_string (const char *name,
const char **strptr)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_string,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = strptr,
.ptr_size = 0,
.size_ptr = NULL
};
*strptr = NULL;
return ret;
}
/**
* Parse given JSON object to a JSON object. (Yes, trivial.)
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_object (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* Cleanup data left from parsing JSON object.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_object (void *cls,
struct GNUNET_JSON_Specification *spec)
{
json_t **ptr = (json_t **) spec->ptr;
if (NULL != *ptr)
{
json_decref (*ptr);
*ptr = NULL;
}
}
/**
* JSON object.
*
* @param name name of the JSON field
* @param[out] jsonp where to store the JSON found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_json (const char *name,
json_t **jsonp)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_object,
.cleaner = &clean_object,
.cls = NULL,
.field = name,
.ptr = jsonp,
.ptr_size = 0,
.size_ptr = NULL
};
*jsonp = NULL;
return ret;
}
/**
* Parse given JSON object to a uint8_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u8 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* 8-bit integer.
*
* @param name name of the JSON field
* @param[out] u8 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint8 (const char *name,
uint8_t *u8)
{
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;
}
/**
* Parse given JSON object to a uint16_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u16 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* 16-bit integer.
*
* @param name name of the JSON field
* @param[out] u16 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint16 (const char *name,
uint16_t *u16)
{
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;
}
/**
* Parse given JSON object to a uint32_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u32 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* 32-bit integer.
*
* @param name name of the JSON field
* @param[out] u32 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint32 (const char *name,
uint32_t *u32)
{
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;
}
/**
* Parse given JSON object to a uint8_t.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_u64 (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* 64-bit integer.
*
* @param name name of the JSON field
* @param[out] u64 where to store the integer found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_uint64 (const char *name,
uint64_t *u64)
{
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;
}
/* ************ GNUnet-specific parser specifications ******************* */
/**
* Parse given JSON object to absolute time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_abs_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Absolute *abs = spec->ptr;
const char *val;
unsigned long long int tval;
val = json_string_value (root);
if (NULL == val)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if ( (0 == strcasecmp (val,
"/forever/")) ||
(0 == strcasecmp (val,
"/end of time/")) ||
(0 == strcasecmp (val,
"/never/")) )
{
*abs = GNUNET_TIME_UNIT_FOREVER_ABS;
return GNUNET_OK;
}
if (1 != sscanf (val,
"/Date(%llu)/",
&tval))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
/* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
abs->abs_value_us = tval * 1000LL * 1000LL;
if ( (abs->abs_value_us) / 1000LL / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Absolute time.
*
* @param name name of the JSON field
* @param[out] at where to store the absolute time found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *at)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_abs_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = at,
.ptr_size = sizeof (uint64_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to relative time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rel_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Relative *rel = spec->ptr;
const char *val;
unsigned long long int tval;
val = json_string_value (root);
if (NULL == val)
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if ( (0 == strcasecmp (val,
"/forever/")) )
{
*rel = GNUNET_TIME_UNIT_FOREVER_REL;
return GNUNET_OK;
}
if (1 != sscanf (val,
"/Delay(%llu)/",
&tval))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
/* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Relative */
rel->rel_value_us = tval * 1000LL * 1000LL;
if ( (rel->rel_value_us) / 1000LL / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Relative time.
*
* @param name name of the JSON field
* @param[out] rt where to store the relative time found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_relative_time (const char *name,
struct GNUNET_TIME_Relative *rt)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rel_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = rt,
.ptr_size = sizeof (uint64_t),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to RSA public key.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rsa_public_key (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* Cleanup data left from parsing RSA public key.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_rsa_public_key (void *cls,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaPublicKey **pk = spec->ptr;
if (NULL != *pk)
{
GNUNET_CRYPTO_rsa_public_key_free (*pk);
*pk = NULL;
}
}
/**
* Specification for parsing an RSA public key.
*
* @param name name of the JSON field
* @param pk where to store the RSA key found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_rsa_public_key (const char *name,
struct GNUNET_CRYPTO_RsaPublicKey **pk)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rsa_public_key,
.cleaner = &clean_rsa_public_key,
.cls = NULL,
.field = name,
.ptr = pk,
.ptr_size = 0,
.size_ptr = NULL
};
*pk = NULL;
return ret;
}
/**
* Parse given JSON object to RSA signature.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
parse_rsa_signature (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
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;
}
/**
* Cleanup data left from parsing RSA signature.
*
* @param cls closure, NULL
* @param[out] spec where to free the data
*/
static void
clean_rsa_signature (void *cls,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_CRYPTO_RsaSignature **sig = spec->ptr;
if (NULL != *sig)
{
GNUNET_CRYPTO_rsa_signature_free (*sig);
*sig = NULL;
}
}
/**
* Specification for parsing an RSA signature.
*
* @param name name of the JSON field
* @param sig where to store the RSA signature found under @a name
*/
struct GNUNET_JSON_Specification
GNUNET_JSON_spec_rsa_signature (const char *name,
struct GNUNET_CRYPTO_RsaSignature **sig)
{
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;
}
