static void
storage_manager_constructed (GObject *_object)
{
StorageManager *storage_manager = STORAGE_MANAGER (_object);
GError *error = NULL;
storage_manager->udisks = udisks_client_new_sync (NULL, &error);
if (storage_manager->udisks == NULL)
{
g_warning ("Error connecting to udisks: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
storage_manager->lvm_manager =
lvm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
0,
"com.redhat.storaged",
"/org/freedesktop/UDisks2/Manager",
NULL,
&error);
if (storage_manager->lvm_manager == NULL)
{
g_warning ("Error connecting to storaged: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (storage_manager->lvm_manager), G_MAXINT);
if (G_OBJECT_CLASS (storage_manager_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_manager_parent_class)->constructed (_object);
}
static gboolean
set_fstab_config (UDisksBlock *block,
const gchar *mount_point,
const gchar *mount_options,
GError **error)
{
if (mount_point && *mount_point)
{
gs_unref_object UDisksClient *client = udisks_client_new_sync (NULL, error);
if (client == NULL)
return FALSE;
UDisksBlock *cleartext = udisks_client_get_cleartext_block (client, block);
if (cleartext)
return set_fstab_config (cleartext, mount_point, mount_options, error);
GVariantBuilder item;
g_variant_builder_init (&item, G_VARIANT_TYPE("a{sv}"));
gs_free gchar *fsname = NULL;
const gchar *uuid = udisks_block_get_id_uuid (block);
if (uuid && *uuid)
fsname = g_strdup_printf ("UUID=%s", uuid);
else
{
// XXX - find a more stable name among the symlinks.
fsname = udisks_block_dup_device (block);
}
g_variant_builder_add (&item, "{sv}", "fsname", g_variant_new_bytestring (fsname));
gs_free gchar *dir = g_filename_from_utf8 (mount_point, -1, NULL, NULL, error);
if (dir == NULL)
return FALSE;
g_variant_builder_add (&item, "{sv}", "dir", g_variant_new_bytestring (dir));
if (mount_options && *mount_options)
{
gs_free gchar *opts = g_locale_from_utf8 (mount_options, -1, NULL, NULL, error);
if (opts == NULL)
return FALSE;
g_variant_builder_add (&item, "{sv}", "opts", g_variant_new_bytestring (opts));
}
else
g_variant_builder_add (&item, "{sv}", "opts", g_variant_new_bytestring ("defaults"));
g_variant_builder_add (&item, "{sv}", "type", g_variant_new_bytestring ("auto"));
g_variant_builder_add (&item, "{sv}", "freq", g_variant_new_int32 (0));
g_variant_builder_add (&item, "{sv}", "passno", g_variant_new_int32 (0));
if (!udisks_block_call_add_configuration_item_sync (block,
g_variant_new ("(sa{sv})",
"fstab",
&item),
g_variant_new ("a{sv}", NULL),
NULL,
error))
return FALSE;
}
return TRUE;
}
int
main (int argc, char *argv[])
{
gint ret;
dev_t block_device;
UDisksClient *client;
GError *error;
struct stat statbuf;
UDisksObject *object;
UDisksFilesystem *filesystem;
GVariantBuilder builder;
ret = 1;
client = NULL;
object = NULL;
g_type_init ();
if (argc < 2 || strlen (argv[1]) == 0)
{
g_printerr ("%s: this program is only supposed to be invoked by umount(8).\n", argv[0]);
goto out;
}
if (stat (argv[1], &statbuf) < 0)
{
g_printerr ("%s: error calling stat on %s: %m\n", argv[0], argv[1]);
goto out;
}
if (S_ISBLK (statbuf.st_mode))
block_device = statbuf.st_rdev;
else
block_device = statbuf.st_dev;
error = NULL;
client = udisks_client_new_sync (NULL, /* GCancellable */
&error);
if (client == NULL)
{
g_printerr ("Error connecting to the udisks daemon: %s\n", error->message);
g_error_free (error);
goto out;
}
object = lookup_object_for_block (client, block_device);
if (object == NULL)
{
g_printerr ("Error finding object for block device %d:%d\n", major (block_device), minor (block_device));
goto out;
}
filesystem = udisks_object_peek_filesystem (object);
if (filesystem == NULL)
{
g_printerr ("Block device %d:%d is not a mountable filesystem.\n", major (block_device), minor (block_device));
goto out;
}
error = NULL;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
if (!udisks_filesystem_call_unmount_sync (filesystem,
g_variant_builder_end (&builder), /* options */
NULL, /* GCancellable */
&error))
{
g_printerr ("Error unmounting block device %d:%d: %s\n", major (block_device), minor (block_device), error->message);
g_error_free (error);
goto out;
}
ret = 0;
out:
if (object != NULL)
g_object_unref (object);
if (client != NULL)
g_object_unref (client);
return ret;
}
int
main (int argc, char *argv[])
{
gint ret = 1;
GError *error = NULL;
gchar *s = NULL;
GOptionContext *o = NULL;
gint n;
GSList *uris = NULL;
GSList *l;
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
have_gtk = gtk_init_check (&argc, &argv);
main_loop = g_main_loop_new (NULL, FALSE);
udisks_client = udisks_client_new_sync (NULL, &error);
if (udisks_client == NULL)
{
g_printerr (_("Error connecting to udisks daemon: %s (%s, %d)"),
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
goto out;
}
o = g_option_context_new (NULL);
g_option_context_set_help_enabled (o, FALSE);
g_option_context_set_summary (o, _("Attach and mount one or more disk image files."));
g_option_context_add_main_entries (o, opt_entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (o, &argc, &argv, NULL))
{
s = g_option_context_get_help (o, FALSE, NULL);
g_printerr ("%s", s);
g_free (s);
goto out;
}
if (argc > 1)
{
for (n = 1; n < argc; n++)
uris = g_slist_prepend (uris, g_strdup (argv[n]));
uris = g_slist_reverse (uris);
}
else
{
if (!have_gtk)
{
show_error ("No files given and GTK+ not available");
goto out;
}
else
{
uris = do_filechooser ();
}
}
/* Files to attach are positional arguments */
for (l = uris; l != NULL; l = l->next)
{
const gchar *uri;
gchar *filename;
GUnixFDList *fd_list = NULL;
GVariantBuilder options_builder;
gint fd;
gchar *loop_object_path = NULL;
GFile *file;
uri = l->data;
file = g_file_new_for_commandline_arg (uri);
filename = g_file_get_path (file);
g_object_unref (file);
if (filename == NULL)
{
show_error (_("Cannot open “%s” — maybe the volume isn’t mounted?"), uri);
goto done_with_image;
}
fd = open (filename, opt_writable ? O_RDWR : O_RDONLY);
if (fd == -1)
{
show_error (_("Error opening “%s”: %m"), filename);
goto done_with_image;
}
g_variant_builder_init (&options_builder, G_VARIANT_TYPE_VARDICT);
if (!opt_writable)
g_variant_builder_add (&options_builder, "{sv}", "read-only", g_variant_new_boolean (TRUE));
fd_list = g_unix_fd_list_new_from_array (&fd, 1); /* adopts the fd */
/* Set up the disk image... */
error = NULL;
if (!udisks_manager_call_loop_setup_sync (udisks_client_get_manager (udisks_client),
g_variant_new_handle (0),
g_variant_builder_end (&options_builder),
fd_list,
&loop_object_path,
NULL, /* out_fd_list */
NULL, /* GCancellable */
&error))
{
show_error (_("Error attaching disk image: %s (%s, %d)"),
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
goto done_with_image;
}
/* Note that the desktop automounter is responsible for mounting,
* unlocking etc. partitions etc. inside the image...
*/
done_with_image:
g_clear_object (&fd_list);
g_free (filename);
g_free (loop_object_path);
} /* for each image */
ret = 0;
out:
if (main_loop != NULL)
g_main_loop_unref (main_loop);
g_slist_free_full (uris, g_free);
g_clear_object (&udisks_client);
return ret;
}
static void
storage_provider_constructed (GObject *_object)
{
StorageProvider *provider = STORAGE_PROVIDER (_object);
GError *error = NULL;
/* TODO: use GInitable/GAsyncInitable or start() pattern here */
provider->udisks_client = udisks_client_new_sync (NULL, &error);
if (provider->udisks_client == NULL)
{
g_warning ("Error connecting to udisks: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
goto out;
}
provider->lvm_objman =
g_dbus_object_manager_client_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
0,
"com.redhat.storaged",
"/org/freedesktop/UDisks2",
lvm_get_proxy_type,
NULL,
NULL,
NULL,
&error);
if (provider->lvm_objman == NULL)
{
g_warning ("Error connecting to storaged: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
goto out;
}
g_signal_connect (provider->lvm_objman,
"object-added",
G_CALLBACK (on_lvm_object_added),
provider);
g_signal_connect (provider->lvm_objman,
"object-removed",
G_CALLBACK (on_lvm_object_removed),
provider);
g_signal_connect (provider->lvm_objman,
"interface-added",
G_CALLBACK (on_lvm_interface_added),
provider);
g_signal_connect (provider->lvm_objman,
"interface-removed",
G_CALLBACK (on_lvm_interface_removed),
provider);
GDBusConnection *connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
if (connection)
{
g_dbus_connection_signal_subscribe (connection,
"com.redhat.storaged",
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
NULL,
NULL, G_DBUS_SIGNAL_FLAGS_NONE,
on_lvm_properties_changed,
provider,
NULL);
}
/* init */
provider_update (provider);
provider_update_jobs (provider);
g_signal_connect (provider->udisks_client,
"changed",
G_CALLBACK (on_udisks_client_changed),
provider);
/* We don't use the "changed" signal to watch jobs since we might
miss some that only exist for a very short period, but we still
want to report their failures.
*/
GDBusObjectManager *object_manager;
object_manager = udisks_client_get_object_manager (provider->udisks_client);
g_signal_connect (object_manager,
"object-added",
G_CALLBACK (on_object_added),
provider);
g_signal_connect (object_manager,
"object-removed",
G_CALLBACK (on_object_removed),
provider);
out:
if (G_OBJECT_CLASS (storage_provider_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_provider_parent_class)->constructed (_object);
}
