/*!
* Check a QMP "execute" response message.
*
* \param result Response from server.
* \param bytes Size of \p result.
* \param expect_empty \c true if the result is expected to be an
* empty json message, else \c false.
*
* \warning FIXME: no validation performed on non-empty QMP messages yet.
*
* \return \c true on success, else \c false.
*/
static gboolean
clr_oci_qmp_check_result (const char *result, gsize bytes,
gboolean expect_empty)
{
gboolean ret;
JsonParser *parser = NULL;
JsonReader *reader = NULL;
GError *error = NULL;
gint count = 0;
g_assert (result);
parser = json_parser_new ();
reader = json_reader_new (NULL);
ret = json_parser_load_from_data (parser, result,
(gssize)bytes, &error);
if (! ret) {
g_critical ("failed to check qmp response: %s",
error->message);
g_error_free (error);
goto out;
}
json_reader_set_root (reader, json_parser_get_root (parser));
ret = json_reader_read_member (reader, "return");
if (! ret) {
goto out;
}
ret = json_reader_is_object (reader);
if (! ret) {
goto out;
}
count = json_reader_count_members (reader);
if (count && expect_empty) {
g_critical ("expected empty object denoting success, "
"but found %d members", count);
goto out;
}
ret = true;
out:
if (reader) {
json_reader_end_member (reader);
g_object_unref (reader);
}
if (parser) {
g_object_unref (parser);
}
return ret;
}
static void
get_kind_and_mime_type (JsonReader *reader, gchar **out_kind, gchar **out_mime_type, GError **error)
{
GError *child_error = NULL;
gboolean success;
gchar *kind = NULL;
gchar *mime_type = NULL;
guint i, members;
for (i = 0, members = (guint) json_reader_count_members (reader); i < members; i++) {
json_reader_read_element (reader, i);
if (gdata_parser_string_from_json_member (reader, "kind", P_REQUIRED | P_NON_EMPTY, &kind, &success, &child_error) == TRUE) {
if (!success && child_error != NULL) {
g_propagate_prefixed_error (error, child_error,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"Failed to find ‘kind’.");
json_reader_end_element (reader);
goto out;
}
}
if (gdata_parser_string_from_json_member (reader, "mimeType", P_DEFAULT, &mime_type, &success, &child_error) == TRUE) {
if (!success && child_error != NULL) {
g_propagate_prefixed_error (error, child_error,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"Failed to find ‘mimeType’.");
json_reader_end_element (reader);
goto out;
}
}
json_reader_end_element (reader);
}
if (out_kind != NULL) {
*out_kind = kind;
kind = NULL;
}
if (out_mime_type != NULL) {
*out_mime_type = mime_type;
mime_type = NULL;
}
out:
g_free (kind);
g_free (mime_type);
}
gboolean
is_in_members (JsonReader * reader, const char *member)
{
gchar **members = json_reader_list_members (reader);
int member_size = json_reader_count_members (reader);
for (int i = 0; i < member_size; i++) {
if (strcmp (members[i], member) == 0) {
//g_print("found member: %s = %s\n", members[i], member);
return TRUE;
}
}
return FALSE;
}
static gboolean
reader_get_properties (JsonReader *reader, GDataFreebaseTopicObject *object, GError **error)
{
GDataFreebaseTopicValueArray *array;
gboolean retval = TRUE;
gint count, i;
count = json_reader_count_members (reader);
for (i = 0; i < count; i++) {
GError *inner_error = NULL;
const gchar *name;
gchar *property;
json_reader_read_element (reader, i);
property = g_strdup (json_reader_get_member_name (reader));
name = property;
/* Reverse properties start with !, display those as
* regular properties, and skip that char
*/
if (name[0] == '!')
name++;
/* All Freebase properties and IDs start with '/' */
if (name[0] != '/')
continue;
/* Parse the value for this property, possibly with nested contents */
array = reader_create_value_array (reader, name, &inner_error);
json_reader_end_element (reader);
if (inner_error != NULL) {
g_propagate_error (error, inner_error);
retval = FALSE;
break;
} else if (array != NULL) {
/* Takes ownership of array */
object_add_value (object, name, array);
}
g_free (property);
}
return retval;
}
/* Save key/values on the table in the stack if the value is an
* object or an array, it calls recursively the function again.
*
* @param L, pointer to the L with nil on top of it;
* @param reader, pointed to the first element of main object;
*
* returns: the table in the stack with all json values
*/
static void
build_table_from_json_reader (lua_State *L,
JsonReader *reader)
{
const GError *err = json_reader_get_error (reader);
if (err != NULL) {
GRL_WARNING ("Error when building json: %s", err->message);
return;
}
if (lua_isnil (L, -1)) {
/* In the first execution of this recursive call, the main json object
* does not have a member name. The nil is in the top of the stack and
* it shall be converted to the table with json content */
lua_pop (L, 1);
} else if (lua_istable (L, -1)) {
const gchar *member_name = json_reader_get_member_name (reader);
if (member_name)
lua_pushstring (L, member_name);
} else if (!lua_isnumber (L, -1)) {
GRL_DEBUG ("getting value to either table or array");
return;
}
if (json_reader_is_object (reader)) {
guint index_member = 0;
guint num_members = json_reader_count_members (reader);
lua_createtable (L, num_members, 0);
for (index_member = 0; index_member < num_members; index_member++) {
json_reader_read_element (reader, index_member);
build_table_from_json_reader (L, reader);
json_reader_end_element (reader);
}
} else if (json_reader_is_array (reader)) {
guint index_element = 0;
guint num_elements = json_reader_count_elements (reader);
lua_createtable (L, num_elements, 0);
for (index_element = 0; index_element < num_elements; index_element++) {
json_reader_read_element (reader, index_element);
lua_pushinteger (L, index_element + 1);
build_table_from_json_reader (L, reader);
json_reader_end_element (reader);
}
} else if (json_reader_is_value (reader)) {
if (json_reader_get_null_value (reader)) {
lua_pushnil (L);
} else {
/* value of the element */
JsonNode *value = json_reader_get_value (reader);
switch (json_node_get_value_type (value)) {
case G_TYPE_STRING:
lua_pushstring (L, json_reader_get_string_value (reader));
break;
case G_TYPE_INT64:
lua_pushinteger (L, json_reader_get_int_value (reader));
break;
case G_TYPE_DOUBLE:
lua_pushnumber (L, json_reader_get_double_value (reader));
break;
case G_TYPE_BOOLEAN:
lua_pushnumber (L, json_reader_get_boolean_value (reader));
break;
default:
GRL_DEBUG ("'%d' (json-node-type) is not being handled",
(gint) json_node_get_value_type (value));
lua_pushnil (L);
}
}
}
if (lua_gettop (L) > 3) {
/* save this key/value on previous table */
lua_settable (L, -3);
}
}
