static const gchar *lookup(GVariant *dictionary, const gchar *lookup_key, const gchar *default_value) { GVariantIter dictionary_iter; g_variant_iter_init(&dictionary_iter, dictionary); const char *key = NULL; GVariant *value = NULL; while (g_variant_iter_loop(&dictionary_iter, "{s@v}", &key, &value)) { if(strcmp(key, lookup_key) != 0) continue; GVariant *unboxed = g_variant_get_variant(value); if(strcmp(g_variant_get_type_string(unboxed), "s") == 0) { return g_variant_get_string(unboxed, NULL); } else if(strcmp(g_variant_get_type_string(unboxed), "ay") != 0) { return g_variant_print(unboxed, FALSE); } else if(g_variant_n_children(unboxed) < 256) { // skip preview gchar *buffer = (gchar *)malloc(256+1); int i=0; guchar c; GVariantIter char_iter; g_variant_iter_init(&char_iter, unboxed); while (g_variant_iter_loop(&char_iter, "y", &c)) { buffer[i] = c; ++i; } buffer[i] = 0; return buffer; } } return default_value; }
static void services_array_add (GUPnPConnmanManager *manager, GVariant *data) { GVariant *dict; CMService *cm_service; gchar *path; GVariantIter iter; GVariantIter dict_iter; guint port; g_object_get (manager, "port", &port, NULL); g_variant_iter_init (&iter, data); while (g_variant_iter_loop (&iter, "(&o@a{sv})", &path, &dict)) { if (path == NULL) continue; if (dict == NULL) continue; if (g_variant_iter_init (&dict_iter, dict) == 0) continue; cm_service = g_hash_table_lookup (manager->priv->cm_services, path); if (cm_service == NULL) cm_service_add (manager, dict, path, port); else cm_service_update (cm_service, dict, port); } }
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 NMSettingUpdateSecretResult update_secret_dict (NMSetting *setting, GVariant *secrets, GError **error) { NMSettingVpnPrivate *priv = NM_SETTING_VPN_GET_PRIVATE (setting); GVariantIter iter; const char *name, *value; NMSettingUpdateSecretResult result = NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; g_return_val_if_fail (secrets != NULL, NM_SETTING_UPDATE_SECRET_ERROR); /* Make sure the items are valid */ g_variant_iter_init (&iter, secrets); while (g_variant_iter_next (&iter, "{&s&s}", &name, &value)) { if (!name || !strlen (name)) { g_set_error_literal (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_SETTING, _("setting contained a secret with an empty name")); g_prefix_error (error, "%s: ", NM_SETTING_VPN_SETTING_NAME); return NM_SETTING_UPDATE_SECRET_ERROR; } if (!value || !strlen (value)) { g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, _("secret value was empty")); g_prefix_error (error, "%s.%s: ", NM_SETTING_VPN_SETTING_NAME, name); return NM_SETTING_UPDATE_SECRET_ERROR; } } /* Now add the items to the settings' secrets list */ g_variant_iter_init (&iter, secrets); while (g_variant_iter_next (&iter, "{&s&s}", &name, &value)) { if (value == NULL) { g_warn_if_fail (value != NULL); continue; } if (strlen (value) == 0) { g_warn_if_fail (strlen (value) > 0); continue; } if (g_strcmp0 (g_hash_table_lookup (priv->secrets, name), value) == 0) continue; g_hash_table_insert (priv->secrets, g_strdup (name), g_strdup (value)); result = NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED; } return result; }
static GHashTable * get_playing_song_info (GDBusProxy *mpris) { GHashTable *properties; GVariant *prop; GVariant *metadata; GVariantIter iter; GVariant *value; char *key; GError *error = NULL; prop = g_dbus_proxy_call_sync (mpris, "org.freedesktop.DBus.Properties.Get", g_variant_new ("(ss)", "org.mpris.MediaPlayer2.Player", "Metadata"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (annoy (&error)) { return NULL; } g_variant_get (prop, "(v)", &metadata); properties = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref); g_variant_iter_init (&iter, metadata); while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) { g_hash_table_insert (properties, g_strdup (key), g_variant_ref (value)); } g_variant_unref (prop); return properties; }
static void g_menu_exporter_unsubscribe (GMenuExporter *exporter, const gchar *sender, GVariant *group_ids) { GMenuExporterRemote *remote; GVariantIter iter; guint32 id; if (sender != NULL) remote = g_hash_table_lookup (exporter->remotes, sender); else remote = exporter->peer_remote; if (remote == NULL) return; g_variant_iter_init (&iter, group_ids); while (g_variant_iter_next (&iter, "u", &id)) g_menu_exporter_remote_unsubscribe (remote, id); if (!g_menu_exporter_remote_has_subscriptions (remote)) { if (sender != NULL) g_hash_table_remove (exporter->remotes, sender); else g_clear_pointer (&exporter->peer_remote, g_menu_exporter_remote_free); } }
static void get_managed_objects_cb (GDBusProxy *proxy, GAsyncResult *res, NMBluez5Manager *self) { GVariant *variant, *ifaces; GVariantIter i; GError *error = NULL; const char *path; variant = _nm_dbus_proxy_call_finish (proxy, res, G_VARIANT_TYPE ("(a{oa{sa{sv}}})"), &error); if (!variant) { if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD)) nm_log_warn (LOGD_BT, "Couldn't get managed objects: not running Bluez5?"); else { g_dbus_error_strip_remote_error (error); nm_log_warn (LOGD_BT, "Couldn't get managed objects: %s", error->message); } g_clear_error (&error); return; } g_variant_iter_init (&i, g_variant_get_child_value (variant, 0)); while ((g_variant_iter_next (&i, "{&o*}", &path, &ifaces))) { if (g_variant_lookup_value (ifaces, BLUEZ5_DEVICE_INTERFACE, G_VARIANT_TYPE_DICTIONARY)) { device_added (proxy, path, self); } g_variant_unref (ifaces); } g_variant_unref (variant); }
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); } }
static void do_countBools (SoupMessage *msg, SoupXMLRPCParams *params) { GVariant *args; GVariant *child; GVariantIter iter; gboolean val; int trues = 0, falses = 0; GVariantDict dict; if (!(args = parse_params (msg, params, "(ab)"))) return; child = g_variant_get_child_value (args, 0); g_variant_iter_init (&iter, child); while (g_variant_iter_loop (&iter, "b", &val)) { if (val) trues++; else falses++; } g_variant_dict_init (&dict, NULL); g_variant_dict_insert (&dict, "true", "i", trues); g_variant_dict_insert (&dict, "false", "i", falses); soup_xmlrpc_message_set_response (msg, g_variant_dict_end (&dict), NULL); g_variant_unref (args); g_variant_unref (child); }
gboolean gkd_secret_property_parse_all (GVariant *array, const gchar *interface, GckBuilder *builder) { CK_ATTRIBUTE_TYPE attr_type; const char *name; DataType data_type; GVariantIter iter; GVariant *variant; g_return_val_if_fail (array != NULL, FALSE); g_return_val_if_fail (builder != NULL, FALSE); g_variant_iter_init (&iter, array); while (g_variant_iter_next (&iter, "{&sv}", &name, &variant)) { /* Property interface.name */ if (!property_to_attribute (name, interface, &attr_type, &data_type)) return FALSE; /* Property value */ if (!iter_get_variant (variant, data_type, attr_type, builder)) { g_variant_unref (variant); return FALSE; } g_variant_unref (variant); } return TRUE; }
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 GVariant * g_menu_exporter_subscribe (GMenuExporter *exporter, const gchar *sender, GVariant *group_ids) { GMenuExporterRemote *remote; GVariantBuilder builder; GVariantIter iter; guint32 id; remote = g_hash_table_lookup (exporter->remotes, sender); if (remote == NULL) { guint watch_id; watch_id = g_bus_watch_name_on_connection (exporter->connection, sender, G_BUS_NAME_WATCHER_FLAGS_NONE, NULL, g_menu_exporter_name_vanished, exporter, NULL); remote = g_menu_exporter_remote_new (exporter, watch_id); g_hash_table_insert (exporter->remotes, g_strdup (sender), remote); } g_variant_builder_init (&builder, G_VARIANT_TYPE ("(a(uuaa{sv}))")); g_variant_builder_open (&builder, G_VARIANT_TYPE ("a(uuaa{sv})")); g_variant_iter_init (&iter, group_ids); while (g_variant_iter_next (&iter, "u", &id)) g_menu_exporter_remote_subscribe (remote, id, &builder); g_variant_builder_close (&builder); return g_variant_builder_end (&builder); }
static gboolean has_passphrase_in_configuration (ChangePassphraseData *data) { gboolean ret = FALSE; GVariantIter iter; const gchar *type; GVariant *details; g_variant_iter_init (&iter, udisks_block_get_configuration (data->block)); while (g_variant_iter_next (&iter, "(&s@a{sv})", &type, &details)) { if (g_strcmp0 (type, "crypttab") == 0) { const gchar *passphrase_path; if (g_variant_lookup (details, "passphrase-path", "^&ay", &passphrase_path) && strlen (passphrase_path) > 0) { g_variant_unref (details); ret = TRUE; goto out; } } g_variant_unref (details); } out: return ret; }
static gboolean iter_get_fields (GVariant *variant, gulong attr_type, GckBuilder *builder) { GString *result; const gchar *key, *value; GVariantIter iter; g_assert (variant != NULL); g_assert (builder != NULL); g_return_val_if_fail (g_variant_type_is_array (g_variant_get_type (variant)), FALSE); result = g_string_new (""); g_variant_iter_init (&iter, variant); while (g_variant_iter_next (&iter, "{&s&s}", &key, &value)) { /* Key */ g_string_append (result, key); g_string_append_c (result, '\0'); /* Value */ g_string_append (result, value); g_string_append_c (result, '\0'); } gck_builder_add_data (builder, attr_type, (const guchar *)result->str, result->len); g_string_free (result, TRUE); return TRUE; }
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); }
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 gboolean on_location_app_state_set (GtkSwitch *widget, gboolean state, gpointer user_data) { LocationAppStateData *data = (LocationAppStateData *) user_data; CcPrivacyPanel *self = data->self; GVariant *params; GVariantIter iter; gchar *key; gchar **value; GVariantBuilder builder; if (data->changing_state) return TRUE; data->changing_state = TRUE; data->pending_state = state; g_variant_iter_init (&iter, self->priv->location_apps_perms); g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); while (g_variant_iter_loop (&iter, "{s^as}", &key, &value)) { gchar *tmp = NULL; if (g_strv_length (value) < 2) /* It's OK to drop the entry if it's not in expected format */ continue; if (g_strcmp0 (data->app_id, key) == 0) { tmp = value[0]; value[0] = state ? "EXACT" : "NONE"; } g_variant_builder_add (&builder, "{s^as}", key, value); if (tmp != NULL) value[0] = tmp; } params = g_variant_new ("(sbsa{sas}v)", APP_PERMISSIONS_TABLE, TRUE, APP_PERMISSIONS_ID, &builder, self->priv->location_apps_data); g_dbus_proxy_call (self->priv->perm_store, "Set", params, G_DBUS_CALL_FLAGS_NONE, -1, self->priv->cancellable, on_perm_store_set_done, data); return TRUE; }
static gboolean handle_get_crypto_passphrase (CockpitStorageBlock *object, GDBusMethodInvocation *invocation) { StorageBlock *block = STORAGE_BLOCK(object); GError *error = NULL; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}")); GVariant *conf = NULL; if (!udisks_block_call_get_secret_configuration_sync (block->udisks_block, g_variant_builder_end (&options), &conf, NULL, &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_error_free (error); return TRUE; } GVariantIter iter; g_variant_iter_init (&iter, conf); const gchar *type; GVariant *details; while (g_variant_iter_next (&iter, "(&s*)", &type, &details)) { if (strcmp (type, "crypttab") == 0) { const gchar *phrase = variant_lookup (details, "passphrase-contents"); if (phrase) { gs_free gchar *phrase_locale = g_locale_to_utf8 (phrase, -1, NULL, NULL, NULL); if (phrase_locale) cockpit_storage_block_complete_get_crypto_passphrase (object, invocation, phrase_locale); else g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "Can't convert passphrase into UTF8"); g_variant_unref (details); return TRUE; } } g_variant_unref (details); } cockpit_storage_block_complete_get_crypto_passphrase (object, invocation, ""); return TRUE; }
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; }
void storage_mdraid_update (StorageMDRaid *mdraid) { UDisksMDRaid *udisks_mdraid = mdraid->udisks_mdraid; CockpitStorageMDRaid *iface = COCKPIT_STORAGE_MDRAID (mdraid); StorageProvider *provider = storage_object_get_provider (mdraid->object); UDisksClient *udisks_client = storage_provider_get_udisks_client (provider); cockpit_storage_mdraid_set_uuid (iface, udisks_mdraid_get_uuid (udisks_mdraid)); cockpit_storage_mdraid_set_name (iface, udisks_mdraid_get_name (udisks_mdraid)); cockpit_storage_mdraid_set_level (iface, udisks_mdraid_get_level (udisks_mdraid)); cockpit_storage_mdraid_set_num_devices (iface, udisks_mdraid_get_num_devices (udisks_mdraid)); cockpit_storage_mdraid_set_size (iface, udisks_mdraid_get_size (udisks_mdraid)); cockpit_storage_mdraid_set_sync_action (iface, udisks_mdraid_get_sync_action (udisks_mdraid)); cockpit_storage_mdraid_set_sync_completed (iface, udisks_mdraid_get_sync_completed (udisks_mdraid)); cockpit_storage_mdraid_set_sync_rate (iface, udisks_mdraid_get_sync_rate (udisks_mdraid)); cockpit_storage_mdraid_set_sync_remaining_time (iface, udisks_mdraid_get_sync_remaining_time (udisks_mdraid)); cockpit_storage_mdraid_set_degraded (iface, udisks_mdraid_get_degraded (udisks_mdraid)); { gs_free gchar *loc = g_locale_to_utf8 (udisks_mdraid_get_bitmap_location (udisks_mdraid), -1, NULL, NULL, NULL); cockpit_storage_mdraid_set_bitmap_location (iface, loc); } cockpit_storage_mdraid_set_chunk_size (iface, udisks_mdraid_get_chunk_size (udisks_mdraid)); GVariantBuilder devices; g_variant_builder_init (&devices, G_VARIANT_TYPE("a(oiast)")); GVariantIter iter; gint disk_slot; const gchar *disk_block_objpath; gs_unref_variant GVariant *disk_states = NULL; guint64 disk_num_errors; g_variant_iter_init (&iter, udisks_mdraid_get_active_devices (udisks_mdraid)); while (g_variant_iter_next (&iter, "(&oi@asta{sv})", &disk_block_objpath, &disk_slot, &disk_states, &disk_num_errors, NULL)) { UDisksObject *udisks_object; UDisksBlock *udisks_block; StorageObject *object; if ((udisks_object = udisks_client_peek_object (udisks_client, disk_block_objpath)) && (udisks_block = udisks_object_peek_block (udisks_object)) && (object = storage_provider_lookup_for_udisks_block (provider, udisks_block))) { g_variant_builder_add (&devices, "(oi@ast)", g_dbus_object_get_object_path (G_DBUS_OBJECT(object)), disk_slot, disk_states, disk_num_errors); } } cockpit_storage_mdraid_set_active_devices (iface, g_variant_builder_end (&devices)); }
MMLocationGpsRaw * mm_location_gps_raw_new_from_dictionary (GVariant *dictionary, GError **error) { GError *inner_error = NULL; MMLocationGpsRaw *self; GVariantIter iter; gchar *key; GVariant *value; self = mm_location_gps_raw_new (); if (!dictionary) return self; if (!g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{sv}"))) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Cannot create GPS RAW location from dictionary: " "invalid variant type received"); g_object_unref (self); return NULL; } g_variant_iter_init (&iter, dictionary); while (!inner_error && g_variant_iter_next (&iter, "{sv}", &key, &value)) { if (g_str_equal (key, PROPERTY_UTC_TIME)) self->priv->utc_time = g_variant_dup_string (value, NULL); else if (g_str_equal (key, PROPERTY_LONGITUDE)) self->priv->longitude = g_variant_get_double (value); else if (g_str_equal (key, PROPERTY_LATITUDE)) self->priv->latitude = g_variant_get_double (value); else if (g_str_equal (key, PROPERTY_ALTITUDE)) self->priv->altitude = g_variant_get_double (value); g_free (key); g_variant_unref (value); } /* If any of the mandatory parameters is missing, cleanup */ if (!self->priv->utc_time || self->priv->longitude == MM_LOCATION_LONGITUDE_UNKNOWN || self->priv->latitude == MM_LOCATION_LATITUDE_UNKNOWN) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Cannot create GPS RAW location from dictionary: " "mandatory parameters missing " "(utc-time: %s, longitude: %s, latitude: %s)", self->priv->utc_time ? "yes" : "missing", (self->priv->longitude != MM_LOCATION_LONGITUDE_UNKNOWN) ? "yes" : "missing", (self->priv->latitude != MM_LOCATION_LATITUDE_UNKNOWN) ? "yes" : "missing"); g_clear_object (&self); } return self; }
static void g_dbus_menu_group_changed (GDBusMenuGroup *group, guint menu_id, gint position, gint removed, GVariant *added) { GSequenceIter *point; GVariantIter iter; GDBusMenuModel *proxy; GSequence *items; GVariant *item; gint n_added; /* We could have signals coming to us when we're not active (due to * some other process having subscribed to this group) or when we're * pending. In both of those cases, we want to ignore the signal * since we'll get our own information when we call "Start" for * ourselves. */ if (group->state != GROUP_ONLINE) return; items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id)); if (items == NULL) { items = g_sequence_new (g_dbus_menu_model_item_free); g_hash_table_insert (group->menus, GINT_TO_POINTER (menu_id), items); } point = g_sequence_get_iter_at_pos (items, position + removed); g_return_if_fail (point != NULL); if (removed) { GSequenceIter *start; start = g_sequence_get_iter_at_pos (items, position); g_sequence_remove_range (start, point); } n_added = g_variant_iter_init (&iter, added); while (g_variant_iter_loop (&iter, "@a{sv}", &item)) g_sequence_insert_before (point, g_dbus_menu_group_create_item (item)); if (g_sequence_get_length (items) == 0) { g_hash_table_remove (group->menus, GINT_TO_POINTER (menu_id)); items = NULL; } if ((proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id)))) g_dbus_menu_model_changed (proxy, items, position, removed, n_added); }
static void add_interface (JsonBuilder *builder, GDBusInterface *interface, GVariant *changed_properties) { gchar *s; json_builder_set_member_name (builder, g_dbus_proxy_get_interface_name (G_DBUS_PROXY (interface))); json_builder_begin_object (builder); if (changed_properties == NULL) { gchar **properties; guint n; properties = g_dbus_proxy_get_cached_property_names (G_DBUS_PROXY (interface)); for (n = 0; properties != NULL && properties[n] != NULL; n++) { const gchar *property_name = properties[n]; GVariant *value; value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (interface), property_name); if (value != NULL) { s = g_strconcat ("dbus_prop_", property_name, NULL); json_builder_set_member_name (builder, s); g_free (s); _json_builder_add_gvariant (builder, value); g_variant_unref (value); } } g_strfreev (properties); if (properties == NULL) { json_builder_set_member_name (builder, "HackEmpty"); json_builder_add_string_value (builder, "HackEmpty"); } } else { GVariantIter iter; const gchar *property_name; GVariant *value; g_variant_iter_init (&iter, changed_properties); while (g_variant_iter_next (&iter, "{&sv}", &property_name, &value)) { s = g_strconcat ("dbus_prop_", property_name, NULL); json_builder_set_member_name (builder, property_name); g_free (s); _json_builder_add_gvariant (builder, value); g_variant_unref (value); } } json_builder_end_object (builder); }
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 void change_passphrase_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { ChangePassphraseData *data = user_data; GError *error; error = NULL; if (!udisks_encrypted_call_change_passphrase_finish (UDISKS_ENCRYPTED (source_object), res, &error)) { gdu_utils_show_error (GTK_WINDOW (data->window), _("Error changing passphrase"), error); g_error_free (error); } /* Update the system-level configuration, if applicable */ if (data->has_passphrase_in_configuration) { GVariantBuilder builder; GVariantIter iter; const gchar *key; GVariant *value; g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); g_variant_iter_init (&iter, data->crypttab_details); while (g_variant_iter_next (&iter, "{sv}", &key, &value)) { if (g_strcmp0 (key, "passphrase-contents") == 0) { g_variant_builder_add (&builder, "{sv}", "passphrase-contents", g_variant_new_bytestring (gtk_entry_get_text (GTK_ENTRY (data->passphrase_entry)))); } else { g_variant_builder_add (&builder, "{sv}", key, value); } g_variant_unref (value); } udisks_block_call_update_configuration_item (data->block, g_variant_new ("(s@a{sv})", "crypttab", data->crypttab_details), g_variant_new ("(sa{sv})", "crypttab", &builder), g_variant_new ("a{sv}", NULL), /* options */ NULL, /* cancellable */ update_configuration_item_cb, data); } else { change_passphrase_data_free (data); } }
GList * systemd_unit_listall(void) { int lpc = 0; GList *units = NULL; GError *error = NULL; GVariant *out_units = NULL; GVariantIter iter; struct unit_info u; GVariant *_ret = NULL; if (systemd_init() == FALSE) { return NULL; } /* " <method name=\"ListUnits\">\n" \ " <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \ " </method>\n" \ */ _ret = g_dbus_proxy_call_sync(systemd_proxy, "ListUnits", g_variant_new("()"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error || _ret == NULL) { crm_info("Call to ListUnits failed: %s", error ? error->message : "unknown"); g_error_free(error); return NULL; } g_variant_get(_ret, "(@a(ssssssouso))", &out_units); g_variant_iter_init(&iter, out_units); while (g_variant_iter_loop(&iter, "(ssssssouso)", &u.id, &u.description, &u.load_state, &u.active_state, &u.sub_state, &u.following, &u.unit_path, &u.job_id, &u.job_type, &u.job_path)) { char *match = strstr(u.id, ".service"); if (match) { lpc++; match[0] = 0; crm_trace("Got %s[%s] = %s", u.id, u.active_state, u.description); units = g_list_append(units, strdup(u.id)); } } crm_info("Call to ListUnits passed: type '%s' count %d", g_variant_get_type_string(out_units), lpc); g_variant_unref(_ret); return units; }
static void dump_record (neardal_record *record) { GVariantIter iter; char *s = NULL; GVariant *v = NULL; GVariant *data; data = (neardal_record_to_g_variant(record)); g_variant_iter_init(&iter, data); while (g_variant_iter_loop(&iter, "{sv}", &s, &v)) printf("\t---- %s = %s\n", s, g_variant_print(v, 0)); }
static void handle_get_properties_result(struct ofono_base *base, GVariant *properties) { gchar *property_name = NULL; GVariant *property_value = NULL; GVariantIter iter; g_variant_iter_init(&iter, properties); while (g_variant_iter_loop(&iter, "{sv}", &property_name, &property_value)) { base->funcs->update_property(property_name, property_value, base->user_data); } }
static GHashTable * _variant_to_hash_kv (GVariant *dict) { GHashTable *hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); GVariantIter iter; const gchar *key; const gchar *value; g_variant_iter_init (&iter, dict); while (g_variant_iter_loop (&iter, "{ss}", &key, &value)) g_hash_table_insert (hash, g_strdup (key), g_strdup (value)); return hash; }
/** * dbusmenu_menuitem_property_get_shortcut: * @menuitem: The #DbusmenuMenuitem to get the shortcut off * @key: (out): Location to put the key value * @modifier: (out): Location to put the modifier mask * * This function gets a GTK shortcut as a key and a mask * for use to set the accelerators. */ void dbusmenu_menuitem_property_get_shortcut (DbusmenuMenuitem * menuitem, guint * key, GdkModifierType * modifier) { guint dummykey; GdkModifierType dummymodifier; if (key == NULL) { key = &dummykey; } if (modifier == NULL) { modifier = &dummymodifier; } *key = 0; *modifier = 0; g_return_if_fail(DBUSMENU_IS_MENUITEM(menuitem)); GVariant * wrapper = dbusmenu_menuitem_property_get_variant(menuitem, DBUSMENU_MENUITEM_PROP_SHORTCUT); if (wrapper == NULL) { return; } if (g_variant_n_children(wrapper) != 1) { g_warning("Unable to parse shortcut, too many keys"); return; } GVariantIter iter; GVariant * child = g_variant_get_child_value(wrapper, 0); g_variant_iter_init(&iter, child); gchar * string; while(g_variant_iter_loop(&iter, "s", &string)) { if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_CONTROL) == 0) { *modifier |= GDK_CONTROL_MASK; } else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_ALT) == 0) { *modifier |= GDK_MOD1_MASK; } else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_SHIFT) == 0) { *modifier |= GDK_SHIFT_MASK; } else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_SUPER) == 0) { *modifier |= GDK_SUPER_MASK; } else { GdkModifierType tempmod; gtk_accelerator_parse(string, key, &tempmod); } } g_variant_unref(child); return; }