GMountSpec *
g_mount_spec_from_dbus (GVariant *value)
{
GMountSpec *spec;
const gchar *key;
const gchar *mount_prefix;
GVariantIter *iter_mount_spec_items;
GVariant *v;
mount_prefix = NULL;
g_variant_get (value, "(^&aya{sv})",
&mount_prefix,
&iter_mount_spec_items);
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = NULL;
if (mount_prefix && mount_prefix[0])
spec->mount_prefix = g_strdup (mount_prefix);
while (g_variant_iter_loop (iter_mount_spec_items, "{&sv}", &key, &v))
{
add_item (spec, key, g_variant_dup_bytestring (v, NULL));
}
g_variant_iter_free (iter_mount_spec_items);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
static void
grok_platform_data (GApplicationCommandLine *cmdline)
{
GVariantIter iter;
const gchar *key;
GVariant *value;
g_variant_iter_init (&iter, cmdline->priv->platform_data);
while (g_variant_iter_loop (&iter, "{&sv}", &key, &value))
if (strcmp (key, "cwd") == 0)
{
if (!cmdline->priv->cwd)
cmdline->priv->cwd = g_variant_dup_bytestring (value, NULL);
}
else if (strcmp (key, "environ") == 0)
{
if (!cmdline->priv->environ)
cmdline->priv->environ =
g_variant_dup_bytestring_array (value, NULL);
}
}
static char*
get_atk_bridge_path (void)
{
GSettings *atspi_settings = NULL;
GVariant *variant = NULL;
char *value = NULL;
const char * const *schemas = NULL;
gboolean found = FALSE;
int i = 0;
schemas = g_settings_list_schemas ();
for (i = 0; schemas [i]; i++)
{
if (!strcmp (schemas[i], AT_SPI_SCHEMA))
{
found = TRUE;
break;
}
}
if (!found)
{
g_warning ("Accessibility: %s schema not found. Are you sure that at-spi or"
" at-spi2 is installed on your system?", AT_SPI_SCHEMA);
return NULL;
}
atspi_settings = g_settings_new (AT_SPI_SCHEMA);
variant = g_settings_get_value (atspi_settings, ATK_BRIDGE_LOCATION_KEY);
value = g_variant_dup_bytestring (variant, NULL);
g_variant_unref (variant);
g_object_unref (atspi_settings);
return value;
}
struct UD2_enumerations* enum_objects() {
g_type_init();
struct UD2_enumerations* enumerations = g_new(struct UD2_enumerations, 1);
GList* UD2_drives = NULL;
GList* UD2_blocks = NULL;
GDBusProxy* UD2_Proxy = NULL;
GError* error=NULL;
UD2_Proxy = g_dbus_proxy_new_for_bus_sync( G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
UD2_DBUS_NAME,
UD2_PATH,
DBUS_MANAGER_IFACE,
NULL,
&error);
if (!UD2_Proxy) {
g_printerr("%s\n", error->message);
g_error_free(error);
}
/* Use the GetManagedObjects method from the ObjectManager interface to
* enumerate UD2 objects
*/
GVariant* UD2_Objects = g_dbus_proxy_call_sync( UD2_Proxy,
(gchar*) "GetManagedObjects",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (!UD2_Objects) {
g_printerr("%s\n", error->message);
g_error_free(error);
}
/*
As per http://dbus.freedesktop.org/doc/dbus-specification.html
the return type for method GetManagedObjects is
DICT<OBJPATH,DICT<STRING,DICT<STRING,VARIANT>>> or (a{oa{sa{sv}}}) in
DBus parlance.
*/
g_assert_cmpstr("(a{oa{sa{sv}}})", ==, g_variant_get_type_string(UD2_Objects));
/* The tuple contains only one dictionary */
g_assert_cmpint(1, ==, g_variant_n_children(UD2_Objects));
/* Re-parent UD2_Objects to the sole element in the tuple */
UD2_Objects = g_variant_get_child_value(UD2_Objects, 0);
GVariantIter* dict_iter = g_variant_iter_new(UD2_Objects);
GVariant* kv_pair;
while(kv_pair = g_variant_iter_next_value(dict_iter)) {
gchar* dbus_object_path;
GVariant* interface_dict;
g_variant_get(kv_pair, "{o*}", &dbus_object_path, &interface_dict);
if (0 == g_strcmp0("/org/freedesktop/UDisks2/Manager", dbus_object_path))
goto next_object;
/* Store the object's properties in a hash table */
GHashTable* UD2_object_properties = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(UD2_object_properties, "object_path", g_strdup(dbus_object_path));
/* Parse the object's DBus interfaces */
GVariantIter* interface_iterator = g_variant_iter_new(interface_dict);
GVariant* interface_kv_pair;
while(interface_kv_pair = g_variant_iter_next_value(interface_iterator)) {
gchar* UD2_interface;
GVariant* properties_dict;
g_variant_get(interface_kv_pair, "{s*}", &UD2_interface, &properties_dict);
/* Is this a UD2 drive? */
if (0 == g_strcmp0(UD2_DRIVE_IFACE, UD2_interface)) {
GVariant* ejectable = g_variant_lookup_value(
properties_dict,
"Ejectable",
NULL);
g_hash_table_insert(UD2_object_properties,
(gchar*) "ejectable",
GINT_TO_POINTER(g_variant_get_boolean(ejectable)));
g_variant_unref(ejectable);
GVariant* optical = g_variant_lookup_value(
properties_dict,
"Optical",
NULL);
g_hash_table_insert(UD2_object_properties,
(gchar*) "optical",
GINT_TO_POINTER(g_variant_get_boolean(optical)));
g_variant_unref(optical);
UD2_drives = g_list_append(UD2_drives, UD2_object_properties);
}
/* Is this a block device? */
if (0 == g_strcmp0(UD2_BLOCK_IFACE, UD2_interface)) {
GVariant* preferred_path = g_variant_lookup_value(
properties_dict,
"PreferredDevice",
NULL);
g_hash_table_insert(UD2_object_properties,
(gchar*) "dev_path",
g_variant_dup_bytestring(preferred_path, NULL));
g_variant_unref(preferred_path);
/* In addition to the preferred path, there may
* be any number of human-readable symlinks under
* /dev
*/
GVariant* symlinks = g_variant_lookup_value(properties_dict, "Symlinks", NULL);
//g_print("Symlinks has %d elements\n", g_variant_n_children(symlinks));
GVariantIter* symlink_iterator = g_variant_iter_new(symlinks);
GVariant* symlink;
GList* symlink_list = NULL;
while(symlink = g_variant_iter_next_value(symlink_iterator)) {
symlink_list = g_list_append(symlink_list, (gpointer) g_variant_dup_bytestring(symlink, NULL));
g_variant_unref(symlink);
}
g_variant_iter_free(symlink_iterator);
g_variant_unref(symlinks);
g_hash_table_insert(UD2_object_properties, (gchar*) "symlinks", symlink_list);
UD2_blocks = g_list_append(UD2_blocks, UD2_object_properties);
}
/* TODO How shall we handle partition tables? */
if (0 == g_strcmp0(UD2_PTABLE_IFACE, UD2_interface)) {
g_hash_table_insert(UD2_object_properties,
(gchar*) "has_partition_table",
GINT_TO_POINTER((gboolean) TRUE));
}
/* Does this block device have a filesystem? */
if (0 == g_strcmp0(UD2_FS_IFACE, UD2_interface)) {
g_hash_table_insert(UD2_object_properties,
(gchar*) "has_filesystem",
GINT_TO_POINTER((gboolean) TRUE));
/* Is the FS mounted? We don't really care where */
GVariant* mountpoints = g_variant_lookup_value(
properties_dict,
"MountPoints",
NULL);
if (0 < g_variant_n_children(mountpoints)) {
g_hash_table_insert(UD2_object_properties,
(gchar*) "mounted",
GINT_TO_POINTER((gboolean) TRUE));
} else {
g_hash_table_insert(UD2_object_properties,
(gchar*) "mounted",
GINT_TO_POINTER((gboolean) FALSE));
}
g_variant_unref(mountpoints);
}
g_free(UD2_interface);
g_variant_unref(interface_kv_pair);
}
g_variant_iter_free(interface_iterator);
next_object:
g_variant_unref(interface_dict);
g_free(dbus_object_path);
g_variant_unref(kv_pair);
}
g_variant_iter_free(dict_iter);
/* Populate the UD2_enumerations struct */
enumerations->drives = UD2_drives;
enumerations->block_devices = UD2_blocks;
g_variant_unref(UD2_Objects);
g_object_unref(UD2_Proxy);
return enumerations;
}
