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