static void _dbus_geany_dbus_application_open_documents (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error; char** filenames = NULL; int filenames_length1; GVariant* _tmp1_; char** _tmp2_; int _tmp2__length; int _tmp2__size; int _tmp2__length1; GVariantIter _tmp3_; GVariant* _tmp4_; GVariantIter _arguments_iter; GVariant* _reply; GVariantBuilder _reply_builder; error = NULL; g_variant_iter_init (&_arguments_iter, parameters); filenames_length1 = 0; _tmp1_ = g_variant_iter_next_value (&_arguments_iter); _tmp2_ = g_new (char*, 5); _tmp2__length = 0; _tmp2__size = 4; _tmp2__length1 = 0; g_variant_iter_init (&_tmp3_, _tmp1_); for (; _tmp4_ = g_variant_iter_next_value (&_tmp3_); _tmp2__length1++) { if (_tmp2__size == _tmp2__length) { _tmp2__size = 2 * _tmp2__size; _tmp2_ = g_renew (char*, _tmp2_, _tmp2__size + 1); } _tmp2_[_tmp2__length++] = g_variant_dup_string (_tmp4_, NULL); g_variant_unref (_tmp4_); }
static void _dbus_steadyflow_iapp_service_set_visible (SteadyflowIAppService* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error = NULL; GVariantIter _arguments_iter; gboolean visible = FALSE; GVariant* _tmp1_; GDBusMessage* _reply_message; GVariant* _reply; GVariantBuilder _reply_builder; g_variant_iter_init (&_arguments_iter, parameters); _tmp1_ = g_variant_iter_next_value (&_arguments_iter); visible = g_variant_get_boolean (_tmp1_); g_variant_unref (_tmp1_); steadyflow_iapp_service_set_visible (self, visible, &error); if (error) { g_dbus_method_invocation_return_gerror (invocation, error); return; } _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation)); g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE); _reply = g_variant_builder_end (&_reply_builder); g_dbus_message_set_body (_reply_message, _reply); g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL); g_object_unref (invocation); g_object_unref (_reply_message); }
gboolean storage_remove_crypto_config (UDisksBlock *block, GError **error) { GVariant *conf = udisks_block_get_configuration (block); GVariantIter iter; GVariant *item; g_variant_iter_init (&iter, conf); while ((item = g_variant_iter_next_value (&iter))) { const gchar *type; g_variant_get (item, "(&s*)", &type, NULL); if (strcmp (type, "crypttab") == 0) { if (!udisks_block_call_remove_configuration_item_sync (block, item, g_variant_new ("a{sv}", NULL), NULL, error)) { g_variant_unref (item); return FALSE; } g_variant_unref (item); } } return TRUE; }
static void mms_ofono_manager_set_modems( MMSOfonoManager* ofono, GVariant* modems) { GVariantIter iter; GVariant* child; MMS_DEBUG("%u modem(s) found", (guint)g_variant_n_children(modems)); g_hash_table_remove_all(ofono->modems); for (g_variant_iter_init(&iter, modems); (child = g_variant_iter_next_value(&iter)) != NULL; g_variant_unref(child)) { MMSOfonoModem* modem; const char* path = NULL; GVariant* properties = NULL; g_variant_get(child, "(&o@a{sv})", &path, &properties); MMS_ASSERT(path); MMS_ASSERT(properties); modem = mms_ofono_modem_new(ofono->bus, path, properties); if (modem) g_hash_table_replace(ofono->modems, modem->path, modem); g_variant_unref(properties); } }
GVariant * g_variant_lookup_value (GVariant *dictionary, const gchar *key, const GVariantType *expected_type) { GVariantIter iter; GVariant *entry; GVariant *value; g_return_val_if_fail (g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{s*}")) || g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{o*}")), NULL); g_variant_iter_init (&iter, dictionary); while ((entry = g_variant_iter_next_value (&iter))) { GVariant *entry_key; gboolean matches; entry_key = g_variant_get_child_value (entry, 0); matches = strcmp (g_variant_get_string (entry_key, NULL), key) == 0; g_variant_unref (entry_key); if (matches) break; g_variant_unref (entry); } if (entry == NULL) return NULL; value = g_variant_get_child_value (entry, 1); g_variant_unref (entry); if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARIANT)) { GVariant *tmp; tmp = g_variant_get_variant (value); g_variant_unref (value); if (expected_type && !g_variant_is_of_type (tmp, expected_type)) { g_variant_unref (tmp); tmp = NULL; } value = tmp; } g_return_val_if_fail (expected_type == NULL || value == NULL || g_variant_is_of_type (value, expected_type), NULL); return value; }
static void update_failures (EmpathyWebcredentialsMonitor *self) { GVariant *failures, *f; GVariantIter iter; GList *new_list = NULL; guint i; failures = g_dbus_proxy_get_cached_property (self->priv->proxy, FAILURES_PROP); if (failures == NULL) { g_debug ("Does not implement Failures property"); return; } g_variant_iter_init (&iter, failures); while ((f = g_variant_iter_next_value (&iter)) != NULL) { guint32 id; AgAccount *account; id = g_variant_get_uint32 (f); account = ag_manager_get_account (self->priv->manager, id); if (account == NULL) continue; /* Pass ownership of 'account' to the list */ new_list = g_list_append (new_list, account); if (!tp_g_ptr_array_contains (self->priv->failures, account)) { g_ptr_array_add (self->priv->failures, g_object_ref (account)); g_signal_emit (self, signals[SIG_FAILURE_ADDED], 0, account); } g_variant_unref (f); } g_variant_unref (failures); for (i = 0; i < self->priv->failures->len; i++) { AgAccount *account = g_ptr_array_index (self->priv->failures, i); if (g_list_find (new_list, account) == NULL) { g_object_ref (account); g_ptr_array_remove (self->priv->failures, account); g_signal_emit (self, signals[SIG_FAILURE_REMOVED], 0, account); g_object_unref (account); } } g_list_free_full (new_list, g_object_unref); }
static PPDName * get_ppd_item_from_output (GVariant *output) { GVariant *array; PPDName *ppd_item = NULL; gint j; static const char * const match_levels[] = { "exact-cmd", "exact", "close", "generic", "none"}; if (output) { g_variant_get (output, "(@a(ss))", &array); if (array) { GVariantIter *iter; GVariant *item; gchar *driver; gchar *match; for (j = 0; j < G_N_ELEMENTS (match_levels) && !ppd_item; j++) { g_variant_get (array, "a(ss)", &iter); while ((item = g_variant_iter_next_value (iter)) && !ppd_item) { g_variant_get (item, "(ss)", &driver, &match); if (g_str_equal (match, match_levels[j])) { ppd_item = g_new0 (PPDName, 1); ppd_item->ppd_name = g_strdup (driver); if (g_strcmp0 (match, "exact-cmd") == 0) ppd_item->ppd_match_level = PPD_EXACT_CMD_MATCH; else if (g_strcmp0 (match, "exact") == 0) ppd_item->ppd_match_level = PPD_EXACT_MATCH; else if (g_strcmp0 (match, "close") == 0) ppd_item->ppd_match_level = PPD_CLOSE_MATCH; else if (g_strcmp0 (match, "generic") == 0) ppd_item->ppd_match_level = PPD_GENERIC_MATCH; else if (g_strcmp0 (match, "none") == 0) ppd_item->ppd_match_level = PPD_NO_MATCH; } g_free (driver); g_free (match); g_variant_unref (item); } } g_variant_unref (array); } } return ppd_item; }
static void storage_remove_config (StorageProvider *provider, UDisksBlock *block, GVariant *config) { GVariantIter iter; GVariant *item; GError *error = NULL; gs_unref_object UDisksBlock *block_to_use = NULL; if (block == NULL) { /* Any block can be used to add/remove any configuration item. Let's hope we have at least one... XXX - UDisks should offer a method for manipulating fstab and crypttab on the Manager. */ UDisksClient *client = storage_provider_get_udisks_client (provider); GDBusObjectManager *manager = udisks_client_get_object_manager (client); GList *objects = g_dbus_object_manager_get_objects (manager); for (GList *l = objects; l; l = l->next) { UDisksObject *object = l->data; block_to_use = udisks_object_get_block (object); if (block_to_use) break; } g_list_free_full (objects, g_object_unref); if (block_to_use == NULL) { g_warning ("Can't remove config: no block object found."); return; } } else block_to_use = g_object_ref (block); g_variant_iter_init (&iter, config); while ((item = g_variant_iter_next_value (&iter)) != NULL) { if (!udisks_block_call_remove_configuration_item_sync (block_to_use, item, g_variant_new ("a{sv}", NULL), NULL, &error)) { gs_free gchar *config_text = g_variant_print (config, FALSE); g_warning ("Can't remove storage configuration '%s': %s", config_text, error->message); g_clear_error (&error); } } }
static int korva_control_list_devices (KorvaController1 *proxy) { GVariant *devices, *dict, *value; char *key; GVariantIter *outer, *inner; GError *error = NULL; korva_controller1_call_get_devices_sync (proxy, &devices, NULL, &error); if (error != NULL) { g_print ("Could not get device list: %s\n", error->message); g_error_free (error); return 1; } outer = g_variant_iter_new (devices); dict = g_variant_iter_next_value (outer); while (dict != NULL) { g_print ("Device:\n"); inner = g_variant_iter_new (dict); while (g_variant_iter_next (inner, "{sv}", &key, &value)) { if (strcmp (key, "UID") == 0 || strcmp (key, "DisplayName") == 0) { g_print (" %s: %s\n", key, g_variant_get_string (value, NULL)); } g_free (key); g_variant_unref (value); } g_variant_iter_free (inner); g_variant_unref (dict); dict = g_variant_iter_next_value (outer); } g_variant_iter_free (outer); return 0; }
void preferences_load (Preferences* self) { IBusConfig* _tmp0_; GVariant* _tmp1_ = NULL; GVariant* _tmp2_; GVariant* values; GVariant* _tmp3_; g_return_if_fail (self != NULL); _tmp0_ = self->priv->config; _tmp1_ = ibus_config_get_values (_tmp0_, "engine/skk"); _tmp2_ = _g_variant_ref0 (_tmp1_); values = _tmp2_; _tmp3_ = values; if (_tmp3_ != NULL) { GVariant* _tmp4_; GVariantIter* _tmp5_ = NULL; GVariantIter* iter; GVariant* entry; _tmp4_ = values; _tmp5_ = g_variant_iter_new (_tmp4_); iter = _tmp5_; entry = NULL; while (TRUE) { GVariantIter* _tmp6_; GVariant* _tmp7_ = NULL; GVariant* _tmp8_; gchar* name = NULL; GVariant* value = NULL; GVariant* _tmp9_; GeeMap* _tmp10_; const gchar* _tmp11_; GVariant* _tmp12_; _tmp6_ = iter; _tmp7_ = g_variant_iter_next_value (_tmp6_); _g_variant_unref0 (entry); entry = _tmp7_; _tmp8_ = entry; if (!(_tmp8_ != NULL)) { break; } _tmp9_ = entry; g_variant_get (_tmp9_, "{sv}", &name, &value, NULL); _tmp10_ = self->priv->current; _tmp11_ = name; _tmp12_ = value; gee_map_set (_tmp10_, _tmp11_, _tmp12_); _g_variant_unref0 (value); _g_free0 (name); } _g_variant_unref0 (entry); _g_variant_iter_free0 (iter); } _g_variant_unref0 (values); }
static void on_flash_progress(GDBusConnection* connection, const gchar* sender_name, const gchar* object_path, const gchar* interface_name, const gchar* signal_name, GVariant* parameters, gpointer user_data) { Flash *flash = object_get_flash((Object*)user_data); object_get_shared_resource((Object*)user_data); GVariantIter *iter = g_variant_iter_new(parameters); g_variant_iter_next_value(iter); GVariant* v_progress = g_variant_iter_next_value(iter); uint8_t progress = g_variant_get_byte(v_progress); gchar *s; s = g_strdup_printf("Flashing: %d%%",progress); flash_set_status(flash,s); g_free(s); }
static gboolean x11_fd_dispatch(GSource* source, GSourceFunc callback, gpointer user_data) { Display *dpy = ((x11_source_t*)source)->dpy; XEvent e; while (XPending(dpy)) { XNextEvent(dpy, &e); if (e.type == KeyPress) { // g_print("KeyPress!!!\n"); static const gchar *names[64] = {0}; names[0] = "xkb:us::eng"; static int inited = 0; if (!inited) { IBusConfig *config = ibus_bus_get_config (bus); GVariant *engines = ibus_config_get_value (config, "general", "preload-engines"); if (!engines) continue; int i = 1; GVariantIter iter; GVariant *child; g_variant_iter_init (&iter, engines); while ((child = g_variant_iter_next_value (&iter)) != NULL) { const gchar *engine_name = g_variant_get_string (child, NULL); // g_print("engine_name %s\n", engine_name); names[i] = engine_name; i++; g_variant_unref (child); } inited = 1; } static int n = 0; n = n==0? 1 : 0; ibus_bus_set_global_engine(bus, names[n]); } } return TRUE; }
static GVariant * _get_session_property ( GDBusProxy *proxy, const gchar *object_path, const gchar *prop_key) { GError *error = NULL; GVariant *result = NULL; GVariant *prop_value = NULL; result = g_dbus_connection_call_sync ( g_dbus_proxy_get_connection (proxy), g_dbus_proxy_get_name (proxy), object_path, "org.freedesktop.DBus.Properties", "GetAll", g_variant_new ("(s)", "org.freedesktop.login1.Session"), G_VARIANT_TYPE ("(a{sv})"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { printf ("Failed with error %d:%s", error->code, error->message); g_error_free (error); error = NULL; return NULL; } if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(a{sv})"))) { GVariantIter *iter = NULL; GVariant *item = NULL; g_variant_get (result, "(a{sv})", &iter); while ((item = g_variant_iter_next_value (iter))) { gchar *key; GVariant *value; g_variant_get (item, "{sv}", &key, &value); if (g_strcmp0 (key, prop_key) == 0) { prop_value = value; g_free (key); key = NULL; break; } g_free (key); key = NULL; g_variant_unref (value); value = NULL; } } g_variant_unref (result); return prop_value; }
static void gvariant_foreach (GVariant *variant, GVariantForeachFunc func, gpointer user_data) { GVariantIter iter; GVariant *variant_child; g_variant_iter_init (&iter, variant); while ((variant_child = g_variant_iter_next_value (&iter)) != NULL) { func (variant_child, user_data); g_variant_unref (variant_child); } }
static void get_missing_executables_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVariant *output; IMEData *data = (IMEData *) user_data; GError *error = NULL; GList *executables = NULL; GList *item; output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object), res, &error); if (output) { GVariant *array; g_variant_get (output, "(@as)", &array); if (array) { GVariantIter *iter; GVariant *item; gchar *executable; g_variant_get (array, "as", &iter); while ((item = g_variant_iter_next_value (iter))) { g_variant_get (item, "s", &executable); executables = g_list_append (executables, executable); g_variant_unref (item); } g_variant_unref (array); } g_variant_unref (output); } else if (error->domain == G_DBUS_ERROR && (error->code == G_DBUS_ERROR_SERVICE_UNKNOWN || error->code == G_DBUS_ERROR_UNKNOWN_METHOD)) { g_warning ("Install system-config-printer which provides \ DBus method \"MissingExecutables\" to find missing executables and filters."); g_error_free (error); }
/* ---------------------------------------------------------------------------------------------------- */ int get_object(GDBusProxy *proxy, GPIO* gpio, object_info* obj_info) { g_print("Checking Presence: %s\n",gpio->name); GError *error; GVariant *parm; GVariant *result; error = NULL; parm = g_variant_new("(ss)","GPIO_PRESENT",gpio->name); result = g_dbus_proxy_call_sync (proxy, "getObjectFromId", parm, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); g_assert_no_error (error); const gchar* bus_name; const gchar* obj_path; gsize bus_name_size; gsize obj_path_size; GVariantIter *iter = g_variant_iter_new(result); GVariant* dict = g_variant_iter_next_value(iter); GVariant* b = g_variant_lookup_value(dict,"bus_name",(const GVariantType *) "s"); bus_name = g_variant_get_string(b,&bus_name_size); GVariant* o = g_variant_lookup_value(dict,"obj_path",(const GVariantType *) "s"); obj_path = g_variant_get_string(o,&obj_path_size); int rc = 0; if (bus_name_size == 0 || obj_path_size == 0) { g_print("ERROR: gpio %s not found in lookup\n",gpio->name); rc = 1; } else { obj_info->bus_name = bus_name; obj_info->path = obj_path; } g_variant_unref(b); g_variant_unref(o); g_variant_unref(dict); g_variant_unref(result); return rc; }
static void build_json_dictionary (JsonBuilder *builder, const GVariantType *entry_type, GVariant *dict) { const GVariantType *key_type; GVariantIter iter; GVariant *child; GVariant *key; GVariant *value; gboolean is_string; gchar *key_string; json_builder_begin_object (builder); key_type = g_variant_type_key (entry_type); is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) || g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE)); g_variant_iter_init (&iter, dict); while ((child = g_variant_iter_next_value (&iter)) != NULL) { key = g_variant_get_child_value (child, 0); value = g_variant_get_child_value (child, 1); if (is_string) { json_builder_set_member_name (builder, g_variant_get_string (key, NULL)); } else { key_string = g_variant_print (key, FALSE); json_builder_set_member_name (builder, key_string); g_free (key_string); } build_json (builder, value); g_variant_unref (key); g_variant_unref (value); } json_builder_end_object (builder); }
void DeviceOptions::bind_enum(const QString &name, int key, GVariant *const gvar_list, boost::function<QString (GVariant*)> printer) { GVariant *gvar; GVariantIter iter; vector< pair<GVariant*, QString> > values; assert(gvar_list); g_variant_iter_init (&iter, gvar_list); while ((gvar = g_variant_iter_next_value (&iter))) values.push_back(make_pair(gvar, printer(gvar))); _properties.push_back(boost::shared_ptr<Property>( new Enum(name, values, bind(config_getter, _sdi, key), bind(config_setter, _sdi, key, _1)))); }
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 void _dbus_geany_dbus_application_open_document (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error; char* filename = NULL; GVariant* _tmp0_; gboolean result; GVariantIter _arguments_iter; GVariant* _reply; GVariantBuilder _reply_builder; error = NULL; g_variant_iter_init (&_arguments_iter, parameters); _tmp0_ = g_variant_iter_next_value (&_arguments_iter); filename = g_variant_dup_string (_tmp0_, NULL); g_variant_unref (_tmp0_); result = geany_dbus_application_open_document (self, filename); g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE); _g_free0 (filename); g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result)); _reply = g_variant_builder_end (&_reply_builder); g_dbus_method_invocation_return_value (invocation, _reply); }
void gsearchtool_set_columns_order (GtkTreeView * treeview) { GtkTreeViewColumn * last = NULL; GSettings * settings; GVariant * value; settings = g_settings_new ("org.mate.search-tool"); value = g_settings_get_value (settings, "columns-order"); if (value) { GVariantIter *iter; GVariant *item; g_variant_get (value, "ai", &iter); while ((item = g_variant_iter_next_value (iter))) { GtkTreeViewColumn * cur; gint id; g_variant_get (item, "i", &id); if (id >= 0 && id < NUM_COLUMNS) { cur = gsearchtool_gtk_tree_view_get_column_with_sort_column_id (treeview, id); if (cur && cur != last) { gtk_tree_view_move_column_after (treeview, cur, last); last = cur; } } g_variant_unref (item); } g_variant_iter_free (iter); g_variant_unref (value); } g_object_unref (settings); }
void DeviceOptions::bind_enum(const QString &name, int key, GVariant *const gvar_list, Property::Getter getter, Property::Setter setter, function<QString (GVariant*)> printer) { GVariant *gvar; GVariantIter iter; vector< pair<GVariant*, QString> > values; assert(_dev_inst); if (!gvar_list) { qDebug() << "Config key " << key << " was listed, but no " "options were given"; return; } g_variant_iter_init (&iter, gvar_list); while ((gvar = g_variant_iter_next_value (&iter))) values.push_back(make_pair(gvar, printer(gvar))); _properties.push_back(shared_ptr<Property>(new Enum(name, values, getter, setter))); }
gboolean _g_dbus_gvariant_to_dbus_1 (DBusMessage *message, GVariant *value, GError **error) { gboolean ret; guint n; ret = FALSE; if (value != NULL) { DBusMessageIter iter; GVariantIter gv_iter; GVariant *item; dbus_message_iter_init_append (message, &iter); g_variant_iter_init (&gv_iter, value); n = 0; while ((item = g_variant_iter_next_value (&gv_iter))) { if (!dconf_dbus_from_gv (&iter, item, error)) { g_prefix_error (error, _("Error encoding in-arg %d: "), n); goto out; } n++; } } ret = TRUE; out: return ret; }
QVariantList QGSettings::choices(const QString &key) const { Q_D(const QGSettings); QVariantList choices; if (!d->valid) return choices; gchar *keyName = Utils::fromCamelCase(key); GSettingsSchemaKey *schemaKey = g_settings_schema_get_key(d->schema, keyName); GVariant *range = g_settings_schema_key_get_range(schemaKey); g_settings_schema_key_unref(schemaKey); g_free(keyName); if (!range) return choices; const gchar *type; GVariant *value; g_variant_get(range, "(&sv)", &type, &value); if (g_str_equal(type, "enum")) { GVariantIter iter; g_variant_iter_init(&iter, value); GVariant *child; while ((child = g_variant_iter_next_value(&iter))) { choices.append(Utils::toQVariant(child)); g_variant_unref(child); } } g_variant_unref(value); g_variant_unref(range); return choices; }
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); }
/** * cockpit_fake_manager_scrape: * @self: a fake manager * @variant: a variant to scrape * * Get all object paths out of the variant in question * (which is usually the parameters to a signal) and * try and poke those object paths. */ void cockpit_fake_manager_scrape (CockpitFakeManager *self, GVariant *variant) { GVariantIter iter; GVariant *child; const gchar *path; if (g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH)) { path = g_variant_get_string (variant, NULL); if (!g_str_equal (path, "/")) cockpit_fake_manager_poke (self, path); } else if (g_variant_is_container (variant)) { g_variant_iter_init (&iter, variant); while ((child = g_variant_iter_next_value (&iter)) != NULL) { cockpit_fake_manager_scrape (self, child); g_variant_unref (child); } } }
void rpmostree_print_package_diffs (GVariant *variant) { GQueue queue = G_QUEUE_INIT; GVariantIter iter; GVariant *child; /* GVariant format should be a(sua{sv}) */ g_return_if_fail (variant != NULL); g_variant_iter_init (&iter, variant); /* Queue takes ownership of the child variant. */ while ((child = g_variant_iter_next_value (&iter)) != NULL) g_queue_insert_sorted (&queue, child, pkg_diff_variant_compare, NULL); while (!g_queue_is_empty (&queue)) { child = g_queue_pop_head (&queue); pkg_diff_variant_print (child); g_variant_unref (child); } }
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; }
/* Returns a new floating variant (essentially a fixed-up copy of @value) */ static GVariant * _my_replace (GVariant *value) { GVariant *ret; const gchar *dbus_type; if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARDICT) && g_variant_lookup (value, "_dbus_type", "&s", &dbus_type)) { GVariant *passed_value; passed_value = g_variant_lookup_value (value, "value", NULL); if (passed_value != NULL) { JsonNode *serialized; GError *error; serialized = json_gvariant_serialize (passed_value); error = NULL; ret = json_gvariant_deserialize (serialized, dbus_type, &error); json_node_free (serialized); if (ret == NULL) { /* * HACK: Work around bug in JSON-glib, see: * https://bugzilla.gnome.org/show_bug.cgi?id=724319 */ if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_INVALID_DATA && g_variant_is_of_type (passed_value, G_VARIANT_TYPE_INT64) && g_strcmp0 (dbus_type, "d") == 0) { ret = g_variant_new_double (g_variant_get_int64 (passed_value)); g_clear_error (&error); } else { g_warning ("Error converting JSON to requested type %s: %s (%s, %d)", dbus_type, error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); ret = g_variant_ref (value); } } } else { g_warning ("Malformed _dbus_type vardict"); ret = g_variant_ref (value); } } else if (g_variant_is_container (value)) { GVariantBuilder builder; GVariantIter iter; GVariant *child; g_variant_builder_init (&builder, g_variant_get_type (value)); g_variant_iter_init (&iter, value); while ((child = g_variant_iter_next_value (&iter)) != NULL) { g_variant_builder_add_value (&builder, _my_replace (child)); g_variant_unref (child); } ret = g_variant_builder_end (&builder); } else { ret = g_variant_ref (value); } return ret; }