/** * 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; }