/**
* fwupd_release_to_json:
* @release: A #FwupdRelease
* @builder: A #JsonBuilder
*
* Adds a fwupd release to a JSON builder
*
* Since: 1.2.6
**/
void
fwupd_release_to_json (FwupdRelease *release, JsonBuilder *builder)
{
FwupdReleasePrivate *priv = GET_PRIVATE (release);
g_autoptr(GList) keys = NULL;
g_return_if_fail (FWUPD_IS_RELEASE (release));
g_return_if_fail (builder != NULL);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_APPSTREAM_ID, priv->appstream_id);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_REMOTE_ID, priv->remote_id);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_SUMMARY, priv->summary);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_DESCRIPTION, priv->description);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_VERSION, priv->version);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_FILENAME, priv->filename);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_PROTOCOL, priv->protocol);
if (priv->checksums->len > 0) {
json_builder_set_member_name (builder, FWUPD_RESULT_KEY_CHECKSUM);
json_builder_begin_array (builder);
for (guint i = 0; i < priv->checksums->len; i++) {
const gchar *checksum = g_ptr_array_index (priv->checksums, i);
json_builder_add_string_value (builder, checksum);
}
json_builder_end_array (builder);
}
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_LICENSE, priv->license);
fwupd_release_json_add_int (builder, FWUPD_RESULT_KEY_SIZE, priv->size);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_URI, priv->uri);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_HOMEPAGE, priv->homepage);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_DETAILS_URL, priv->details_url);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_SOURCE_URL, priv->source_url);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_VENDOR, priv->vendor);
if (priv->flags != FWUPD_RELEASE_FLAG_NONE) {
json_builder_set_member_name (builder, FWUPD_RESULT_KEY_FLAGS);
json_builder_begin_array (builder);
for (guint i = 0; i < 64; i++) {
const gchar *tmp;
if ((priv->flags & ((guint64) 1 << i)) == 0)
continue;
tmp = fwupd_release_flag_to_string ((guint64) 1 << i);
json_builder_add_string_value (builder, tmp);
}
json_builder_end_array (builder);
}
fwupd_release_json_add_int (builder, FWUPD_RESULT_KEY_INSTALL_DURATION, priv->install_duration);
fwupd_release_json_add_string (builder, FWUPD_RESULT_KEY_UPDATE_MESSAGE, priv->update_message);
/* metadata */
keys = g_hash_table_get_keys (priv->metadata);
for (GList *l = keys; l != NULL; l = l->next) {
const gchar *key = l->data;
const gchar *value = g_hash_table_lookup (priv->metadata, key);
fwupd_release_json_add_string (builder, key, value);
}
}
static JsonBuilder* kkc_user_rule_create_rom_kana (KkcRuleMetadata* parent, const gchar* name) {
JsonBuilder* result = NULL;
JsonBuilder* builder = NULL;
JsonBuilder* _tmp0_ = NULL;
KkcRuleMetadata* _tmp1_ = NULL;
const gchar* _tmp2_ = NULL;
const gchar* _tmp3_ = NULL;
gchar* _tmp4_ = NULL;
gchar* _tmp5_ = NULL;
const gchar* _tmp6_ = NULL;
gchar* _tmp7_ = NULL;
gchar* _tmp8_ = NULL;
g_return_val_if_fail (parent != NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
_tmp0_ = json_builder_new ();
builder = _tmp0_;
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "include");
json_builder_begin_array (builder);
_tmp1_ = parent;
_tmp2_ = kkc_metadata_file_get_name ((KkcMetadataFile*) _tmp1_);
_tmp3_ = _tmp2_;
_tmp4_ = g_strconcat (_tmp3_, "/", NULL);
_tmp5_ = _tmp4_;
_tmp6_ = name;
_tmp7_ = g_strconcat (_tmp5_, _tmp6_, NULL);
_tmp8_ = _tmp7_;
json_builder_add_string_value (builder, _tmp8_);
_g_free0 (_tmp8_);
_g_free0 (_tmp5_);
json_builder_end_array (builder);
json_builder_end_object (builder);
result = builder;
return result;
}
static void
add_thread_info (JsonBuilder *bob, const MuMsgIterThreadInfo *ti)
{
bob = json_builder_set_member_name (bob, "thread");
bob = json_builder_begin_object(bob);
add_string_member (bob, "path", ti->threadpath);
add_int_member (bob, "level", ti->level);
bob = json_builder_set_member_name (bob, "flags");
bob = json_builder_begin_array (bob);
if (ti->prop & MU_MSG_ITER_THREAD_PROP_FIRST_CHILD)
bob = json_builder_add_string_value (bob, "first-child");
if (ti->prop & MU_MSG_ITER_THREAD_PROP_LAST_CHILD)
bob = json_builder_add_string_value (bob, "last-child");
if (ti->prop & MU_MSG_ITER_THREAD_PROP_EMPTY_PARENT)
bob = json_builder_add_string_value (bob, "empty-parent");
if (ti->prop & MU_MSG_ITER_THREAD_PROP_DUP)
bob = json_builder_add_string_value (bob, "duplicate");
if (ti->prop & MU_MSG_ITER_THREAD_PROP_HAS_CHILD)
bob = json_builder_add_string_value (bob, "has-child");
bob = json_builder_end_array (bob);
bob = json_builder_end_object(bob);
}
static void
add_body_txt_params (JsonBuilder *bob, MuMsg *msg, MuMsgOptions opts)
{
const GSList *params;
params = mu_msg_get_body_text_content_type_parameters (msg, opts);
if (!params)
return;
bob = json_builder_set_member_name (bob, "body-txt-params");
bob = json_builder_begin_array (bob);
while (params) {
const char *key, *val;
key = (const char *)params->data;
params = g_slist_next(params);
if (!params)
break;
val = (const char *)params->data;
if (key && val) {
bob = json_builder_begin_object(bob);
add_string_member(bob, key, val);
bob = json_builder_end_object(bob);
}
params = g_slist_next(params);
}
bob = json_builder_end_array(bob);
}
static void
add_part_type (JsonBuilder *bob, MuMsgPartType ptype)
{
unsigned u;
struct PartTypes {
MuMsgPartType ptype;
const char* name;
} ptypes[] = {
{ MU_MSG_PART_TYPE_LEAF, "leaf" },
{ MU_MSG_PART_TYPE_MESSAGE, "message" },
{ MU_MSG_PART_TYPE_INLINE, "inline" },
{ MU_MSG_PART_TYPE_ATTACHMENT, "attachment" },
{ MU_MSG_PART_TYPE_SIGNED, "signed" },
{ MU_MSG_PART_TYPE_ENCRYPTED, "encrypted" }
};
bob = json_builder_set_member_name (bob, "type");
bob = json_builder_begin_array(bob);
for (u = 0; u!= G_N_ELEMENTS(ptypes); ++u)
if (ptype & ptypes[u].ptype)
json_builder_add_string_value (bob, ptypes[u].name);
bob = json_builder_end_array(bob);
}
static void
maybe_append_list_post_as_reply_to (JsonBuilder *bob, MuMsg *msg)
{
/* some mailing lists do not set the reply-to; see pull #1278. So for
* those cases, check the List-Post address and use that instead */
GMatchInfo *minfo;
GRegex *rx;
const char* list_post;
list_post = mu_msg_get_header (msg, "List-Post");
if (!list_post)
return;
rx = g_regex_new ("^(<?mailto:)?([a-z0-9%[email protected]]+)>?", G_REGEX_CASELESS, 0, NULL);
g_return_if_fail(rx);
if (g_regex_match (rx, list_post, 0, &minfo)) {
char *addr;
addr = g_match_info_fetch (minfo, 2);
bob = json_builder_set_member_name (bob, "reply-to");
bob = json_builder_begin_array(bob);
bob = json_builder_begin_object(bob);
add_string_member(bob, "email", addr);
g_free (addr);
bob = json_builder_end_object(bob);
bob = json_builder_end_array(bob);
}
g_match_info_free (minfo);
g_regex_unref (rx);
}
/**
* fwupd_build_history_report_json:
* @devices: (element-type FwupdDevice): devices
* @error: A #GError or %NULL
*
* Builds a JSON report for the list of devices. No filtering is done on the
* @devices array, and it is expected that the caller will filter to something
* sane, e.g. %FWUPD_DEVICE_FLAG_REPORTED at the bare minimum.
*
* Returns: a string, or %NULL if the ID is not present
*
* Since: 1.0.4
**/
gchar *
fwupd_build_history_report_json (GPtrArray *devices, GError **error)
{
gchar *data;
g_autofree gchar *machine_id = NULL;
g_autoptr(JsonBuilder) builder = NULL;
g_autoptr(JsonGenerator) json_generator = NULL;
g_autoptr(JsonNode) json_root = NULL;
/* get a hash that represents the machine */
machine_id = fwupd_build_machine_id ("fwupd", error);
if (machine_id == NULL)
return NULL;
/* create header */
builder = json_builder_new ();
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "ReportVersion");
json_builder_add_int_value (builder, 2);
json_builder_set_member_name (builder, "MachineId");
json_builder_add_string_value (builder, machine_id);
/* this is system metadata not stored in the database */
json_builder_set_member_name (builder, "Metadata");
json_builder_begin_object (builder);
if (!fwupd_build_history_report_json_metadata (builder, error))
return NULL;
json_builder_end_object (builder);
/* add each device */
json_builder_set_member_name (builder, "Reports");
json_builder_begin_array (builder);
for (guint i = 0; i < devices->len; i++) {
FwupdDevice *dev = g_ptr_array_index (devices, i);
json_builder_begin_object (builder);
fwupd_build_history_report_json_device (builder, dev);
json_builder_end_object (builder);
}
json_builder_end_array (builder);
json_builder_end_object (builder);
/* export as a string */
json_root = json_builder_get_root (builder);
json_generator = json_generator_new ();
json_generator_set_pretty (json_generator, TRUE);
json_generator_set_root (json_generator, json_root);
data = json_generator_to_data (json_generator, NULL);
if (data == NULL) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"Failed to convert to JSON string");
return NULL;
}
return data;
}
static gchar *
build_save_items_request (GList *file_list)
{
GList *l;
JsonBuilder *json_builder = json_builder_new ();
json_builder_begin_object (json_builder);
json_builder_set_member_name (json_builder, "items");
json_builder_begin_array (json_builder);
for (l = file_list; l; l = l->next) {
gchar *path = l->data;
json_builder_begin_object (json_builder);
json_builder_set_member_name (json_builder, "itemType");
json_builder_add_string_value (json_builder, "attachment");
json_builder_set_member_name (json_builder, "path");
json_builder_add_string_value (json_builder, path);
json_builder_set_member_name (json_builder, "attachments");
json_builder_begin_array (json_builder);
/* empty (but required for each item) */
json_builder_end_array (json_builder);
json_builder_end_object (json_builder);
}
json_builder_end_array (json_builder);
json_builder_set_member_name (json_builder, "attachmentMode");
json_builder_add_string_value (json_builder, "file");
json_builder_end_object (json_builder);
JsonGenerator *json_gen = json_generator_new ();
JsonNode *root = json_builder_get_root (json_builder);
json_generator_set_root (json_gen, root);
gchar *save_items_request = json_generator_to_data (json_gen, NULL);
json_node_free (root);
g_object_unref (json_gen);
g_object_unref (json_builder);
return save_items_request;
}
static void
add_parts (JsonBuilder *bob, MuMsg *msg, MuMsgOptions opts)
{
PartInfo pinfo;
pinfo.opts = opts;
bob = json_builder_set_member_name (bob, "parts");
bob = json_builder_begin_array (bob);
mu_msg_part_foreach (msg, opts, (MuMsgPartForeachFunc)each_part, &pinfo);
bob = json_builder_end_array (bob);
}
static void insertToJson(gpointer name, gpointer v, gpointer user_data)
{
JsonBuilder *builder = (JsonBuilder *)user_data;
if (name != NULL)
json_builder_set_member_name (builder, (const char *)name);
switch (G_VALUE_TYPE(v)) {
case G_TYPE_BOOLEAN:
json_builder_add_boolean_value (builder, g_value_get_boolean((GValue *)v));
break;
case G_TYPE_STRING:
json_builder_add_string_value (builder, g_value_get_string((GValue *)v));
break;
case G_TYPE_INT:
json_builder_add_int_value (builder, g_value_get_int((GValue *)v));
break;
case G_TYPE_INT64:
json_builder_add_int_value (builder, g_value_get_int64((GValue *)v));
break;
case G_TYPE_DOUBLE:
json_builder_add_double_value (builder, g_value_get_double((GValue *)v));
break;
default:
if (G_VALUE_TYPE(v) == G_TYPE_HASH_TABLE)
{
json_builder_begin_object (builder);
GHashTable *map = (GHashTable *) g_value_get_boxed((GValue *)v);
g_hash_table_foreach (map, insertToJson, builder);
json_builder_end_object (builder);
}
else if (G_VALUE_TYPE(v) == G_TYPE_VALUE_ARRAY)
{
json_builder_begin_array (builder);
GValueArray *array = (GValueArray *) g_value_get_boxed((GValue *)v);
for (guint i = 0; i < array->n_values; i++)
{
GValue *value = g_value_array_get_nth(array, i);
insertToJson(0, value, builder);
}
json_builder_end_array (builder);
}
else
{
g_print("unhandled type %s\n", G_VALUE_TYPE_NAME(v));
json_builder_add_null_value (builder);
}
break;
}
}
static void
on_object_removed (GDBusObjectManager *manager,
GDBusObject *object,
gpointer user_data)
{
CockpitDBusJson1 *self = user_data;
cleanup_unref_object JsonBuilder *builder = prepare_builder ("object-removed");
json_builder_begin_array (builder);
json_builder_add_string_value (builder, g_dbus_object_get_object_path (object));
json_builder_end_array (builder);
write_builder (self, builder);
}
static void
add_flags (JsonBuilder *bob, MuMsg *msg)
{
FlagData fdata;
fdata.msgflags = mu_msg_get_flags (msg);
fdata.bob = bob;
bob = json_builder_set_member_name (bob, "flags");
bob = json_builder_begin_array (bob);
mu_flags_foreach ((MuFlagsForeachFunc)each_flag, &fdata);
bob = json_builder_end_array (bob);
}
static void
json_add_recipients(JsonBuilder *builder, MuMsg *msg)
{
InternetAddressList *addr_from;
InternetAddressList *addr_to;
InternetAddressList *addr_cc;
addr_from = internet_address_list_parse_string( mu_msg_get_from (msg) );
if (addr_from) {
json_builder_set_member_name (builder, "from");
json_builder_begin_array (builder);
json_add_address_list(builder, addr_from);
json_builder_end_array (builder);
g_object_unref(addr_from);
}
addr_to = internet_address_list_parse_string( mu_msg_get_to (msg) );
if (addr_to) {
json_builder_set_member_name (builder, "to");
json_builder_begin_array (builder);
json_add_address_list(builder, addr_to);
json_builder_end_array (builder);
g_object_unref(addr_to);
}
addr_cc = internet_address_list_parse_string( mu_msg_get_cc (msg) );
if (addr_cc) {
json_builder_set_member_name (builder, "cc");
json_builder_begin_array (builder);
json_add_address_list(builder, addr_cc);
json_builder_end_array (builder);
g_object_unref(addr_cc);
}
}
static void
add_list_member (JsonBuilder *bob, const char* elm, const GSList *lst)
{
const GSList *cur;
if (!lst)
return; /* empty list, don't include */
bob = json_builder_set_member_name (bob, elm);
bob = json_builder_begin_array (bob);
for (cur = lst; cur; cur = g_slist_next(cur))
bob = json_builder_add_string_value (bob, (const char*)cur->data);
bob = json_builder_end_array (bob);
}
static void
build_json_array_or_tuple (JsonBuilder *builder,
GVariant *value)
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
build_json (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
static JsonNode *query_network_address(IpcamIAjax *iajax)
{
const gchar *token = ipcam_base_app_get_config(IPCAM_BASE_APP(iajax), "token");
IpcamRequestMessage *req_msg;
IpcamMessage *resp_msg;
JsonBuilder *builder;
JsonNode *addr_node = NULL;
gboolean ret;
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
json_builder_add_string_value(builder, "address");
json_builder_end_array(builder);
json_builder_end_object(builder);
req_msg = g_object_new(IPCAM_REQUEST_MESSAGE_TYPE,
"action", "get_network",
"body", json_builder_get_root(builder),
NULL);
ipcam_base_app_send_message(IPCAM_BASE_APP(iajax), IPCAM_MESSAGE(req_msg),
"iconfig", token, NULL, 5);
ret = ipcam_base_app_wait_response(IPCAM_BASE_APP(iajax),
ipcam_request_message_get_id(req_msg),
5000, &resp_msg);
if (ret)
{
JsonNode *resp_body;
JsonObject *items_obj;
g_object_get(G_OBJECT(resp_msg), "body", &resp_body, NULL);
items_obj = json_object_get_object_member(json_node_get_object(resp_body), "items");
addr_node = json_node_copy(json_object_get_member(items_obj, "address"));
g_object_unref(resp_msg);
}
g_object_unref(req_msg);
g_object_unref(builder);
return addr_node;
}
static void
on_connection_signal (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
CockpitDBusJson *self = user_data;
gs_unref_object JsonBuilder *builder = prepare_builder ("interface-signal");
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "objpath");
json_builder_add_string_value (builder, object_path);
json_builder_set_member_name (builder, "iface_name");
json_builder_add_string_value (builder, interface_name);
json_builder_set_member_name (builder, "signal_name");
json_builder_add_string_value (builder, signal_name);
json_builder_set_member_name (builder, "args");
json_builder_begin_array (builder);
g_variant_iter_init (&iter, parameters);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
build_json (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
json_builder_end_object (builder);
write_builder (self, builder);
}
static void
on_interface_proxy_signal (GDBusObjectManager *manager,
GDBusObjectProxy *object_proxy,
GDBusProxy *interface_proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
CockpitDBusJson1 *self = user_data;
cleanup_unref_object JsonBuilder *builder = prepare_builder ("interface-signal");
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "objpath");
json_builder_add_string_value (builder, g_dbus_object_get_object_path (G_DBUS_OBJECT (object_proxy)));
json_builder_set_member_name (builder, "iface_name");
json_builder_add_string_value (builder, g_dbus_proxy_get_interface_name (interface_proxy));
json_builder_set_member_name (builder, "signal_name");
json_builder_add_string_value (builder, signal_name);
json_builder_set_member_name (builder, "args");
json_builder_begin_array (builder);
g_variant_iter_init (&iter, parameters);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
json_builder_end_object (builder);
write_builder (self, builder);
}
static void ipcam_itrain_before_start(IpcamBaseService *base_service)
{
IpcamITrain *itrain = IPCAM_ITRAIN(base_service);
IpcamITrainPrivate *priv = ipcam_itrain_get_instance_private(itrain);
const gchar *addr = ipcam_base_app_get_config(IPCAM_BASE_APP(itrain), "itrain:address");
const gchar *port = ipcam_base_app_get_config(IPCAM_BASE_APP(itrain), "itrain:port");
const gchar *osd_port = ipcam_base_app_get_config(IPCAM_BASE_APP(itrain), "itrain:osd-port");
JsonBuilder *builder;
const gchar *token = ipcam_base_app_get_config(IPCAM_BASE_APP(itrain), "token");
IpcamRequestMessage *req_msg;
if (!addr || !port)
{
g_critical("address and port must be specified.\n");
return;
}
priv->itrain_server = g_object_new(IPCAM_TYPE_ITRAIN_SERVER,
"itrain", itrain,
"address", addr,
"port", strtoul(port, NULL, 0),
"osd-port", strtoul(osd_port, NULL, 0),
NULL);
ipcam_base_app_register_notice_handler(IPCAM_BASE_APP(itrain), "video_occlusion_event", IPCAM_TYPE_ITRAIN_EVENT_HANDLER);
ipcam_base_app_register_notice_handler(IPCAM_BASE_APP(itrain), "set_base_info", IPCAM_TYPE_ITRAIN_EVENT_HANDLER);
ipcam_base_app_register_notice_handler(IPCAM_BASE_APP(itrain), "set_szyc", IPCAM_TYPE_ITRAIN_EVENT_HANDLER);
/* Request the Base Information */
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
json_builder_add_string_value(builder, "device_name");
json_builder_add_string_value(builder, "comment");
json_builder_add_string_value(builder, "location");
json_builder_add_string_value(builder, "hardware");
json_builder_add_string_value(builder, "firmware");
json_builder_add_string_value(builder, "manufacturer");
json_builder_add_string_value(builder, "model");
json_builder_add_string_value(builder, "serial");
json_builder_add_string_value(builder, "device_type");
json_builder_end_array(builder);
json_builder_end_object(builder);
req_msg = g_object_new(IPCAM_REQUEST_MESSAGE_TYPE,
"action", "get_base_info",
"body", json_builder_get_root(builder),
NULL);
ipcam_base_app_send_message(IPCAM_BASE_APP(itrain), IPCAM_MESSAGE(req_msg),
"iconfig", token,
base_info_message_handler, 60);
g_object_unref(req_msg);
g_object_unref(builder);
/* Request the SZYC Information */
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
json_builder_add_string_value(builder, "train_num");
json_builder_add_string_value(builder, "carriage_num");
json_builder_add_string_value(builder, "position_num");
json_builder_end_array(builder);
json_builder_end_object(builder);
req_msg = g_object_new(IPCAM_REQUEST_MESSAGE_TYPE,
"action", "get_szyc",
"body", json_builder_get_root(builder),
NULL);
ipcam_base_app_send_message(IPCAM_BASE_APP(itrain), IPCAM_MESSAGE(req_msg),
"iconfig", token,
szyc_message_handler, 60);
g_object_unref(req_msg);
g_object_unref(builder);
}
static JsonBuilder *
_json_builder_add_gvariant (JsonBuilder *builder,
GVariant *value)
{
g_return_val_if_fail (JSON_IS_BUILDER (builder), builder);
g_variant_ref_sink (value);
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
json_builder_add_boolean_value (builder, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
json_builder_add_int_value (builder, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
json_builder_add_int_value (builder, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
json_builder_add_int_value (builder, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
json_builder_add_int_value (builder, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
json_builder_add_int_value (builder, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
json_builder_add_int_value (builder, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
json_builder_add_int_value (builder, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_HANDLE:
json_builder_add_int_value (builder, g_variant_get_handle (value));
break;
case G_VARIANT_CLASS_DOUBLE:
json_builder_add_double_value (builder, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING: /* explicit fall-through */
case G_VARIANT_CLASS_OBJECT_PATH: /* explicit fall-through */
case G_VARIANT_CLASS_SIGNATURE:
json_builder_add_string_value (builder, g_variant_get_string (value, NULL));
break;
/* TODO: */
case G_VARIANT_CLASS_VARIANT:
{
GVariant *child;
child = g_variant_get_variant (value);
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
break;
case G_VARIANT_CLASS_MAYBE:
g_assert_not_reached ();
break;
case G_VARIANT_CLASS_ARRAY:
{
const GVariantType *type;
const GVariantType *element_type;
type = g_variant_get_type (value);
element_type = g_variant_type_element (type);
if (g_variant_type_is_dict_entry (element_type))
{
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_object (builder);
}
else
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
}
break;
case G_VARIANT_CLASS_TUPLE:
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
break;
case G_VARIANT_CLASS_DICT_ENTRY:
{
GVariant *dict_key;
GVariant *dict_value;
gchar *dict_key_string;
dict_key = g_variant_get_child_value (value, 0);
dict_value = g_variant_get_child_value (value, 1);
if (g_variant_is_of_type (dict_key, G_VARIANT_TYPE("s")))
dict_key_string = g_variant_dup_string (dict_key, NULL);
else
dict_key_string = g_variant_print (dict_key, FALSE);
json_builder_set_member_name (builder, dict_key_string);
_json_builder_add_gvariant (builder, dict_value);
g_free (dict_key_string);
g_variant_unref (dict_key);
g_variant_unref (dict_value);
}
break;
}
g_variant_unref (value);
return builder;
}
static gboolean get_network_parameters(IpcamIOnvifDiscovery *ionvif_discovery,
struct NetworkParameters *param)
{
JsonBuilder *builder;
JsonNode *response;
/* Request the Network setting */
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
json_builder_add_string_value(builder, "address");
json_builder_add_string_value(builder, "port");
json_builder_end_array(builder);
json_builder_end_object(builder);
if (onvif_invocate_action(ionvif_discovery, "get_network", json_builder_get_root(builder), &response)) {
JsonObject *items_obj;
items_obj = json_object_get_object_member(json_node_get_object(response), "items");
if (json_object_has_member(items_obj, "port"))
{
JsonObject *port_obj = json_object_get_object_member(items_obj, "port");
if (json_object_has_member(port_obj, "http"))
{
param->http_port = json_object_get_int_member(port_obj, "http");
}
}
if (json_object_has_member(items_obj, "address"))
{
JsonObject *addr_obj = json_object_get_object_member(items_obj, "address");
if (json_object_has_member(addr_obj, "ipaddr"))
{
inet_aton(json_object_get_string_member(addr_obj, "ipaddr"), ¶m->ipaddr);
}
}
}
g_object_unref(builder);
/* Request the mac address */
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
json_builder_add_string_value(builder, "hwaddr");
json_builder_end_array(builder);
json_builder_end_object(builder);
if (onvif_invocate_action(ionvif_discovery, "get_base_info", json_builder_get_root(builder), &response)) {
JsonObject *items_obj;
items_obj = json_object_get_object_member(json_node_get_object(response), "items");
if (json_object_has_member(items_obj, "hwaddr"))
{
int *mac_addr = param->mac_addr;
const gchar *mac_addr_str = json_object_get_string_member(items_obj, "hwaddr");
sscanf(mac_addr_str, "%x:%x:%x:%x:%x:%x",
&mac_addr[0], &mac_addr[1], &mac_addr[2],
&mac_addr[3], &mac_addr[4], &mac_addr[5]);
}
}
g_object_unref(builder);
return TRUE;
}
static gchar* do_get_action(IpcamIAjax *iajax, GList *item_list)
{
JsonBuilder *builder = NULL;
JsonNode *res_node = NULL;
GList *item;
JsonGenerator *generator;
GList *user;
GList *users = ipcam_iajax_get_users(iajax);
users = g_list_sort(users, (GCompareFunc)g_strcmp0);
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_array(builder);
for (user = g_list_first(users); user; user = g_list_next(user))
{
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "username");
json_builder_add_string_value(builder, user->data);
if (item_list)
{
for (item = g_list_first(item_list); item; item = g_list_next(item))
{
if (g_str_equal(item->data, "password"))
{
gchar *pwd = ipcam_iajax_get_user_pwd(iajax, user->data);
json_builder_set_member_name(builder, "password");
json_builder_add_string_value(builder, pwd);
}
else if (g_str_equal(item->data, "role"))
{
gchar *role = ipcam_iajax_get_user_role(iajax, user->data);
json_builder_set_member_name(builder, "role");
json_builder_add_string_value(builder, role);
g_free(role);
}
else
{
g_warn_if_reached();
}
}
}
json_builder_end_object(builder);
}
g_list_free_full(users, g_free);
json_builder_end_array(builder);
json_builder_end_object(builder);
generator = json_generator_new();
res_node = json_builder_get_root(builder);
json_generator_set_root(generator, res_node);
json_generator_set_pretty(generator, TRUE);
gchar *result = json_generator_to_data(generator, NULL);;
json_node_free(res_node);
g_object_unref(G_OBJECT(builder));
g_object_unref(G_OBJECT(generator));
return result;
}
static void directory_foreach_file(gpointer data, gpointer json_builder)
{
file_entry_t *file = (file_entry_t *)data;
json_builder_begin_object(json_builder);
json_builder_set_member_name(json_builder, "name");
if(file != NULL)
{
json_builder_add_string_value(json_builder, file->name);
}
else
{
json_builder_add_string_value(json_builder, "Error");
}
json_builder_set_member_name(json_builder, "size");
json_builder_add_int_value(json_builder, file->size);
json_builder_set_member_name(json_builder, "hidden");
json_builder_add_boolean_value(json_builder, file->hidden);
json_builder_set_member_name(json_builder, "type");
switch(file->type)
{
case G_FILE_TYPE_REGULAR:
{
json_builder_add_string_value(json_builder, "regular");
break;
}
case G_FILE_TYPE_DIRECTORY:
{
json_builder_add_string_value(json_builder, "directory");
break;
}
case G_FILE_TYPE_SYMBOLIC_LINK:
{
json_builder_add_string_value(json_builder, "symlink");
break;
}
case G_FILE_TYPE_SPECIAL:
{
json_builder_add_string_value(json_builder, "special");
break;
}
case G_FILE_TYPE_SHORTCUT:
{
json_builder_add_string_value(json_builder, "shortcut");
break;
}
case G_FILE_TYPE_MOUNTABLE:
{
json_builder_add_string_value(json_builder, "mountable");
break;
}
case G_FILE_TYPE_UNKNOWN: default:
{
json_builder_add_string_value(json_builder, "unknown");
break;
}
}
json_builder_set_member_name(json_builder, "last_modified");
json_builder_begin_array(json_builder);
json_builder_add_int_value(json_builder, file->mod_time_sec);
json_builder_add_int_value(json_builder, file->mod_time_usec);
json_builder_end_array(json_builder);
json_builder_set_member_name(json_builder, "mime");
json_builder_add_string_value(json_builder, file->mime);
json_builder_set_member_name(json_builder, "access");
json_builder_begin_array(json_builder);
json_builder_add_boolean_value(json_builder, file->access_read);
json_builder_add_boolean_value(json_builder, file->access_write);
json_builder_add_boolean_value(json_builder, file->access_execute);
json_builder_end_array(json_builder);
json_builder_set_member_name(json_builder, "owner");
json_builder_add_string_value(json_builder, file->owner);
json_builder_set_member_name(json_builder, "group");
json_builder_add_string_value(json_builder, file->group);
json_builder_end_object(json_builder);
}
static JsonNode *
clutter_paint_node_to_json (ClutterPaintNode *node)
{
JsonBuilder *builder;
JsonNode *res;
builder = json_builder_new ();
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "type");
json_builder_add_string_value (builder, g_type_name (G_TYPE_FROM_INSTANCE (node)));
json_builder_set_member_name (builder, "name");
json_builder_add_string_value (builder, node->name);
json_builder_set_member_name (builder, "node-data");
json_builder_add_value (builder, clutter_paint_node_serialize (node));
json_builder_set_member_name (builder, "operations");
json_builder_begin_array (builder);
if (node->operations != NULL)
{
guint i;
for (i = 0; i < node->operations->len; i++)
{
const ClutterPaintOperation *op;
op = &g_array_index (node->operations, ClutterPaintOperation, i);
json_builder_begin_object (builder);
switch (op->opcode)
{
case PAINT_OP_TEX_RECT:
json_builder_set_member_name (builder, "texrect");
json_builder_begin_array (builder);
json_builder_add_double_value (builder, op->op.texrect[0]);
json_builder_add_double_value (builder, op->op.texrect[1]);
json_builder_add_double_value (builder, op->op.texrect[2]);
json_builder_add_double_value (builder, op->op.texrect[3]);
json_builder_add_double_value (builder, op->op.texrect[4]);
json_builder_add_double_value (builder, op->op.texrect[5]);
json_builder_add_double_value (builder, op->op.texrect[6]);
json_builder_add_double_value (builder, op->op.texrect[7]);
json_builder_end_array (builder);
break;
case PAINT_OP_PATH:
json_builder_set_member_name (builder, "path");
json_builder_add_int_value (builder, (gint64) op->op.path);
break;
case PAINT_OP_PRIMITIVE:
json_builder_set_member_name (builder, "primitive");
json_builder_add_int_value (builder, (gint64) op->op.primitive);
break;
case PAINT_OP_INVALID:
break;
}
json_builder_end_object (builder);
}
}
json_builder_end_array (builder);
json_builder_set_member_name (builder, "children");
json_builder_begin_array (builder);
if (node->first_child != NULL)
{
ClutterPaintNode *child;
for (child = node->first_child;
child != NULL;
child = child->next_sibling)
{
JsonNode *n = clutter_paint_node_to_json (child);
json_builder_add_value (builder, n);
}
}
json_builder_end_array (builder);
json_builder_end_object (builder);
res = json_builder_get_root (builder);
g_object_unref (builder);
return res;
}
/* Save state */
static gboolean save_state(gpointer data) {
queue_status qs;
gboolean repeat, shuffle;
int cur_track;
GArray* tracks = NULL;
JsonBuilder* jb = NULL;
JsonGenerator* gen = NULL;
gchar* out = NULL;
GError* err = NULL;
g_debug("savestate: starting to save the current state...");
/* Get data about the current state */
qs = queue_get_status(NULL, &cur_track, NULL);
tracks = queue_tracks();
repeat = queue_get_repeat();
shuffle = queue_get_shuffle();
/* Save them in JSON */
jb = json_builder_new();
json_builder_begin_object(jb);
json_builder_set_member_name(jb, "status");
switch (qs) {
case STOPPED:
json_builder_add_string_value(jb, "stopped"); break;
case PLAYING:
json_builder_add_string_value(jb, "playing"); break;
case PAUSED:
json_builder_add_string_value(jb, "paused"); break;
default:
g_warning("savestate: bad queue_status value: %d", qs);
goto savestate_clean;
}
json_builder_set_member_name(jb, "repeat");
json_builder_add_boolean_value(jb, repeat);
json_builder_set_member_name(jb, "shuffle");
json_builder_add_boolean_value(jb, shuffle);
json_builder_set_member_name(jb, "current_track");
json_builder_add_int_value(jb, cur_track);
json_builder_set_member_name(jb, "tracks");
json_builder_begin_array(jb);
int i;
for (i=0; i < tracks->len; i++) {
sp_track* tr = g_array_index(tracks, sp_track*, i);
if (!sp_track_is_loaded(tr)) {
g_warning("savestate: queue track %d is not loaded", i);
goto savestate_clean;
}
sp_link* lnk = sp_link_create_from_track(tr, 0);
gchar uri[1024];
int uri_len = sp_link_as_string(lnk, uri, 1024);
sp_link_release(lnk);
if (uri_len >= 1024) {
g_warning("savestate: URI too long for track %d", i);
goto savestate_clean;
}
json_builder_add_string_value(jb, uri);
}
json_builder_end_array(jb);
json_builder_end_object(jb);
/* Store JSON to file */
gen = json_generator_new();
json_generator_set_root(gen, json_builder_get_root(jb));
out = json_generator_to_data(gen, NULL);
if (g_file_set_contents(g_state_file_path, out, -1, &err))
g_debug("savestate: state saved to %s.", g_state_file_path);
else
g_warning("savestate: unable to dump status to file: %s", err->message);
savestate_clean:
if (tracks)
g_array_free(tracks, TRUE);
if (gen)
g_object_unref(gen);
if (jb)
g_object_unref(jb);
if (out)
g_free(out);
return FALSE;
}
void
snarf_alert_add_flow_v4(snarf_alert_t *alert,
uint64_t stime, uint32_t elapsed,
uint32_t sip, uint32_t dip,
uint16_t sport, uint16_t dport,
uint8_t proto,
uint32_t packets, uint32_t bytes,
uint8_t flags, uint8_t flags_initial,
uint16_t application_id,
char *sensor_name,
char *flow_class, char *flow_type)
{
JsonBuilder *builder;
// Populate the envelope
builder=json_builder_new();
json_builder_begin_array(builder);
json_builder_begin_object(builder);
json_builder_set_member_name(builder,"stime");
char jsontime[32];
time_t sectime = stime / (1000*1000);
struct tm gmt;
gmtime_r(§ime,&gmt);
strftime(jsontime,21,"%Y-%m-%dT%H:%M:%SZ",&gmt);
json_builder_add_string_value(builder,jsontime);
json_builder_set_member_name(builder,"elapsed");
json_builder_add_int_value(builder,elapsed);
struct in_addr ip;
ip.s_addr=htonl(sip);
json_builder_set_member_name(builder,"sip");
json_builder_add_string_value(builder,inet_ntoa(ip));
ip.s_addr=htonl(dip);
json_builder_set_member_name(builder,"dip");
json_builder_add_string_value(builder,inet_ntoa(ip));
json_builder_set_member_name(builder,"sport");
json_builder_add_int_value(builder,sport);
json_builder_set_member_name(builder,"dport");
json_builder_add_int_value(builder,dport);
json_builder_set_member_name(builder,"proto");
json_builder_add_int_value(builder,proto);
json_builder_set_member_name(builder,"packets");
json_builder_add_int_value(builder,packets);
json_builder_set_member_name(builder,"bytes");
json_builder_add_int_value(builder,bytes);
// flags
json_builder_set_member_name(builder,"flags");
GString *flag_string = snarf_alert_flags_to_string(flags);
json_builder_add_string_value(builder,flag_string->str);
g_string_free(flag_string,TRUE);
// flags initial
json_builder_set_member_name(builder,"flags_initial");
GString *flag_initial_string = snarf_alert_flags_to_string(flags_initial);
json_builder_add_string_value(builder,flag_initial_string->str);
//g_print(flag_initial_string);
g_string_free(flag_initial_string,TRUE);
// application id
json_builder_set_member_name(builder,"application_id");
json_builder_add_int_value(builder,application_id);
// sensor
json_builder_set_member_name(builder,"sensor_name");
json_builder_add_string_value(builder,sensor_name);
// flow class
json_builder_set_member_name(builder,"flow_class");
json_builder_add_string_value(builder,flow_class);
// flow type
json_builder_set_member_name(builder,"flow_type");
json_builder_add_string_value(builder,flow_type);
json_builder_end_object(builder);
json_builder_end_array(builder);
//json_builder_end_object(builder);
JsonNode *root = json_builder_get_root(builder);
JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");
json_object_set_member(bodyobj,"flow",root);
}
static void
fwupd_build_history_report_json_device (JsonBuilder *builder, FwupdDevice *dev)
{
FwupdRelease *rel = fwupd_device_get_release_default (dev);
GPtrArray *checksums;
/* identify the firmware used */
json_builder_set_member_name (builder, "Checksum");
checksums = fwupd_release_get_checksums (rel);
json_builder_add_string_value (builder, fwupd_checksum_get_by_kind (checksums, G_CHECKSUM_SHA1));
/* identify the firmware written */
checksums = fwupd_device_get_checksums (dev);
if (checksums->len > 0) {
json_builder_set_member_name (builder, "ChecksumDevice");
json_builder_begin_array (builder);
for (guint i = 0; i < checksums->len; i++) {
const gchar *checksum = g_ptr_array_index (checksums, i);
json_builder_add_string_value (builder, checksum);
}
json_builder_end_array (builder);
}
/* include the protocol used */
if (fwupd_release_get_protocol (rel) != NULL) {
json_builder_set_member_name (builder, "Protocol");
json_builder_add_string_value (builder, fwupd_release_get_protocol (rel));
}
/* set the error state of the report */
json_builder_set_member_name (builder, "UpdateState");
json_builder_add_int_value (builder, fwupd_device_get_update_state (dev));
if (fwupd_device_get_update_error (dev) != NULL) {
json_builder_set_member_name (builder, "UpdateError");
json_builder_add_string_value (builder, fwupd_device_get_update_error (dev));
}
if (fwupd_release_get_update_message (rel) != NULL) {
json_builder_set_member_name (builder, "UpdateMessage");
json_builder_add_string_value (builder, fwupd_release_get_update_message (rel));
}
/* map back to the dev type on the LVFS */
json_builder_set_member_name (builder, "Guid");
json_builder_add_string_value (builder, fwupd_device_get_guid_default (dev));
json_builder_set_member_name (builder, "Plugin");
json_builder_add_string_value (builder, fwupd_device_get_plugin (dev));
/* report what we're trying to update *from* and *to* */
json_builder_set_member_name (builder, "VersionOld");
json_builder_add_string_value (builder, fwupd_device_get_version (dev));
json_builder_set_member_name (builder, "VersionNew");
json_builder_add_string_value (builder, fwupd_release_get_version (rel));
/* to know the state of the dev we're trying to update */
json_builder_set_member_name (builder, "Flags");
json_builder_add_int_value (builder, fwupd_device_get_flags (dev));
/* to know when the update tried to happen, and how soon after boot */
json_builder_set_member_name (builder, "Created");
json_builder_add_int_value (builder, fwupd_device_get_created (dev));
json_builder_set_member_name (builder, "Modified");
json_builder_add_int_value (builder, fwupd_device_get_modified (dev));
/* add saved metadata to the report */
json_builder_set_member_name (builder, "Metadata");
json_builder_begin_object (builder);
fwupd_build_history_report_json_metadata_device (builder, dev);
json_builder_end_object (builder);
}
void JSONBuilder::end_array() {
std::unique_lock<std::mutex> lock(thread_safe_);
json_builder_end_array(builder_);
}
static JsonBuilder* kkc_user_rule_create_keymap (KkcRuleMetadata* parent, const gchar* name, KkcKeymap* keymap) {
JsonBuilder* result = NULL;
JsonBuilder* builder = NULL;
JsonBuilder* _tmp0_ = NULL;
JsonBuilder* _tmp1_ = NULL;
JsonBuilder* _tmp2_ = NULL;
JsonBuilder* _tmp3_ = NULL;
JsonBuilder* _tmp4_ = NULL;
KkcRuleMetadata* _tmp5_ = NULL;
const gchar* _tmp6_ = NULL;
const gchar* _tmp7_ = NULL;
gchar* _tmp8_ = NULL;
gchar* _tmp9_ = NULL;
const gchar* _tmp10_ = NULL;
gchar* _tmp11_ = NULL;
gchar* _tmp12_ = NULL;
JsonBuilder* _tmp13_ = NULL;
KkcKeymap* _tmp14_ = NULL;
JsonBuilder* _tmp37_ = NULL;
g_return_val_if_fail (parent != NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
_tmp0_ = json_builder_new ();
builder = _tmp0_;
_tmp1_ = builder;
json_builder_begin_object (_tmp1_);
_tmp2_ = builder;
json_builder_set_member_name (_tmp2_, "include");
_tmp3_ = builder;
json_builder_begin_array (_tmp3_);
_tmp4_ = builder;
_tmp5_ = parent;
_tmp6_ = kkc_metadata_file_get_name ((KkcMetadataFile*) _tmp5_);
_tmp7_ = _tmp6_;
_tmp8_ = g_strconcat (_tmp7_, "/", NULL);
_tmp9_ = _tmp8_;
_tmp10_ = name;
_tmp11_ = g_strconcat (_tmp9_, _tmp10_, NULL);
_tmp12_ = _tmp11_;
json_builder_add_string_value (_tmp4_, _tmp12_);
_g_free0 (_tmp12_);
_g_free0 (_tmp9_);
_tmp13_ = builder;
json_builder_end_array (_tmp13_);
_tmp14_ = keymap;
if (_tmp14_ != NULL) {
JsonBuilder* _tmp15_ = NULL;
JsonBuilder* _tmp16_ = NULL;
JsonBuilder* _tmp17_ = NULL;
JsonBuilder* _tmp18_ = NULL;
KkcKeymapEntry* entries = NULL;
KkcKeymap* _tmp19_ = NULL;
gint _tmp20_ = 0;
KkcKeymapEntry* _tmp21_ = NULL;
gint entries_length1 = 0;
gint _entries_size_ = 0;
KkcKeymapEntry* _tmp22_ = NULL;
gint _tmp22__length1 = 0;
JsonBuilder* _tmp35_ = NULL;
JsonBuilder* _tmp36_ = NULL;
_tmp15_ = builder;
json_builder_set_member_name (_tmp15_, "define");
_tmp16_ = builder;
json_builder_begin_object (_tmp16_);
_tmp17_ = builder;
json_builder_set_member_name (_tmp17_, "keymap");
_tmp18_ = builder;
json_builder_begin_object (_tmp18_);
_tmp19_ = keymap;
_tmp21_ = kkc_keymap_local_entries (_tmp19_, &_tmp20_);
entries = _tmp21_;
entries_length1 = _tmp20_;
_entries_size_ = entries_length1;
_tmp22_ = entries;
_tmp22__length1 = entries_length1;
{
KkcKeymapEntry* entry_collection = NULL;
gint entry_collection_length1 = 0;
gint _entry_collection_size_ = 0;
gint entry_it = 0;
entry_collection = _tmp22_;
entry_collection_length1 = _tmp22__length1;
for (entry_it = 0; entry_it < _tmp22__length1; entry_it = entry_it + 1) {
KkcKeymapEntry _tmp23_ = {0};
KkcKeymapEntry entry = {0};
kkc_keymap_entry_copy (&entry_collection[entry_it], &_tmp23_);
entry = _tmp23_;
{
JsonBuilder* _tmp24_ = NULL;
KkcKeymapEntry _tmp25_ = {0};
KkcKeyEvent* _tmp26_ = NULL;
gchar* _tmp27_ = NULL;
gchar* _tmp28_ = NULL;
KkcKeymapEntry _tmp29_ = {0};
const gchar* _tmp30_ = NULL;
_tmp24_ = builder;
_tmp25_ = entry;
_tmp26_ = _tmp25_.key;
_tmp27_ = kkc_key_event_to_string (_tmp26_);
_tmp28_ = _tmp27_;
json_builder_set_member_name (_tmp24_, _tmp28_);
_g_free0 (_tmp28_);
_tmp29_ = entry;
_tmp30_ = _tmp29_.command;
if (_tmp30_ == NULL) {
JsonBuilder* _tmp31_ = NULL;
_tmp31_ = builder;
json_builder_add_null_value (_tmp31_);
} else {
JsonBuilder* _tmp32_ = NULL;
KkcKeymapEntry _tmp33_ = {0};
const gchar* _tmp34_ = NULL;
_tmp32_ = builder;
_tmp33_ = entry;
_tmp34_ = _tmp33_.command;
json_builder_add_string_value (_tmp32_, _tmp34_);
}
kkc_keymap_entry_destroy (&entry);
}
}
}
_tmp35_ = builder;
json_builder_end_object (_tmp35_);
_tmp36_ = builder;
json_builder_end_object (_tmp36_);
entries = (_vala_KkcKeymapEntry_array_free (entries, entries_length1), NULL);
}
_tmp37_ = builder;
json_builder_end_object (_tmp37_);
result = builder;
return result;
}
