void
storage_block_update (StorageBlock *block)
{
CockpitStorageBlock *iface = COCKPIT_STORAGE_BLOCK (block);
StorageProvider *provider;
UDisksClient *udisks_client;
UDisksObject *udisks_object;
UDisksBlock *udisks_block;
UDisksPartition *udisks_partition = NULL;
UDisksPartitionTable *udisks_partition_table = NULL;
UDisksFilesystem *udisks_filesystem = NULL;
UDisksPhysicalVolume *udisks_physical_volume = NULL;
provider = storage_object_get_provider (block->object);
udisks_client = storage_provider_get_udisks_client (provider);
udisks_block = block->udisks_block;
udisks_object = (UDisksObject *)g_dbus_interface_get_object (G_DBUS_INTERFACE (udisks_block));
if (udisks_object != NULL)
{
udisks_partition = udisks_object_peek_partition (udisks_object);
udisks_partition_table = udisks_object_peek_partition_table (udisks_object);
udisks_filesystem = udisks_object_peek_filesystem (udisks_object);
udisks_physical_volume = udisks_object_peek_physical_volume (udisks_object);
}
{
gs_free gchar *d =
g_filename_display_name (udisks_block_get_preferred_device (udisks_block));
cockpit_storage_block_set_device (iface, d);
}
cockpit_storage_block_set_size (iface, udisks_block_get_size (udisks_block));
cockpit_storage_block_set_id_usage (iface, udisks_block_get_id_usage (udisks_block));
cockpit_storage_block_set_id_type (iface, udisks_block_get_id_type (udisks_block));
cockpit_storage_block_set_id_version (iface, udisks_block_get_id_version (udisks_block));
cockpit_storage_block_set_id_label (iface, udisks_block_get_id_label (udisks_block));
cockpit_storage_block_set_id_uuid (iface, udisks_block_get_id_uuid (udisks_block));
if (udisks_partition == NULL)
{
cockpit_storage_block_set_partition_number (iface, 0);
cockpit_storage_block_set_partition_table (iface, "/");
}
else
{
UDisksPartitionTable *table_for_partition;
const gchar *objpath = "/";
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
table_for_partition = udisks_client_get_partition_table (udisks_client, udisks_partition);
if (table_for_partition != NULL)
{
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (table_for_partition));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
objpath = g_dbus_object_get_object_path (G_DBUS_OBJECT (so));
}
}
}
}
cockpit_storage_block_set_partition_table (iface, objpath);
cockpit_storage_block_set_partition_number (iface, udisks_partition_get_number (udisks_partition));
}
GVariantBuilder partitions;
g_variant_builder_init (&partitions, G_VARIANT_TYPE ("a(otts)"));
if (udisks_partition_table != NULL)
{
GList *ps, *l;
ps = udisks_client_get_partitions (udisks_client, udisks_partition_table);
for (l = ps; l != NULL; l = l->next)
{
UDisksPartition *p = UDISKS_PARTITION (l->data);
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (p));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
const gchar *type = "p";
if (udisks_partition_get_is_container (p))
type = "x";
else if (udisks_partition_get_is_contained (p))
type = "l";
g_variant_builder_add (&partitions, "(otts)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (so)),
udisks_partition_get_offset (p),
udisks_partition_get_size (p),
type);
}
}
}
}
g_list_free_full (ps, g_object_unref);
const gchar *type = udisks_partition_table_get_type_ (udisks_partition_table);
if (type == NULL || type[0] == '\0')
type = "unknown";
cockpit_storage_block_set_partition_table_type (iface, type);
}
else
cockpit_storage_block_set_partition_table_type (iface, "");
cockpit_storage_block_set_partitions (iface, g_variant_builder_end (&partitions));
cockpit_storage_block_set_drive
(iface, storage_provider_translate_path (provider, udisks_block_get_drive (udisks_block)));
cockpit_storage_block_set_crypto_backing_device
(iface, storage_provider_translate_path (provider, udisks_block_get_crypto_backing_device (udisks_block)));
cockpit_storage_block_set_mdraid
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid (udisks_block)));
cockpit_storage_block_set_mdraid_member
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid_member (udisks_block)));
if (udisks_filesystem)
{
const gchar *const *p = udisks_filesystem_get_mount_points (udisks_filesystem);
gchar *u[g_strv_length ((gchar **)p) + 1];
int i;
for (i = 0; p[i]; i++)
u[i] = g_filename_display_name (p[i]);
u[i] = NULL;
cockpit_storage_block_set_mounted_at (iface, (const gchar *const *)u);
for (i = 0; u[i]; i++)
g_free (u[i]);
}
GVariantIter iter;
g_variant_iter_init (&iter, udisks_block_get_configuration (udisks_block));
const gchar *type;
GVariant *details;
gboolean got_fstab = FALSE, got_crypttab = FALSE;
while (g_variant_iter_next (&iter, "(&s*)", &type, &details))
{
if (strcmp (type, "fstab") == 0 && !got_fstab)
{
got_fstab = TRUE;
const gchar *dir = variant_lookup (details, "dir");
if (dir)
{
gs_free gchar *dir_display = g_filename_display_name (dir);
cockpit_storage_block_set_mount_point (iface, dir_display);
}
const gchar *opts = variant_lookup (details, "opts");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_mount_options (iface, opts_locale);
else
g_warning ("Can't convert fstab options into UTF8");
}
}
else if (strcmp (type, "crypttab") == 0 && !got_crypttab)
{
got_crypttab = TRUE;
const gchar *opts = variant_lookup (details, "options");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_crypto_options (iface, opts_locale);
else
g_warning ("Can't convert crypttab options into UTF8");
}
}
g_variant_unref (details);
}
cockpit_storage_block_set_logical_volume (iface,
storage_provider_translate_path (provider,
udisks_block_get_logical_volume (udisks_block)));
if (udisks_physical_volume)
{
cockpit_storage_block_set_pv_group (iface,
storage_provider_translate_path (provider,
udisks_physical_volume_get_volume_group (udisks_physical_volume)));
cockpit_storage_block_set_pv_size (iface, udisks_physical_volume_get_size (udisks_physical_volume));
cockpit_storage_block_set_pv_free_size (iface, udisks_physical_volume_get_free_size (udisks_physical_volume));
}
else
cockpit_storage_block_set_pv_group (iface, "/");
}
static gboolean
walk_block (UDisksClient *client,
UDisksBlock *block,
BlockWalker *walker,
gpointer user_data,
GError **error)
{
gboolean is_leaf = TRUE;
UDisksObject *object = (UDisksObject *)g_dbus_interface_get_object (G_DBUS_INTERFACE(block));
if (object != NULL)
{
// Recurse for all primary and extended partitions if this is a
// partition table, or for all logical partitions if this is a
// extended partition.
UDisksPartitionTable *table;
gboolean is_container;
UDisksPartition *partition = udisks_object_peek_partition (object);
if (partition && udisks_partition_get_is_container (partition))
{
table = udisks_client_get_partition_table (client, partition);
is_container = TRUE;
}
else
{
table = udisks_object_peek_partition_table (object);
is_container = FALSE;
}
if (table)
{
GList *ps, *l;
ps = udisks_client_get_partitions (client, table);
for (l = ps; l != NULL; l = l->next)
{
UDisksPartition *p = UDISKS_PARTITION (l->data);
UDisksObject *o = (UDisksObject *) g_dbus_interface_get_object (G_DBUS_INTERFACE (p));
UDisksBlock *b = o ? udisks_object_peek_block (o) : NULL;
if (b && !is_container == !udisks_partition_get_is_contained (p))
{
is_leaf = FALSE;
if (!walk_block (client, b, walker, user_data, error))
{
g_list_free_full (ps, g_object_unref);
return FALSE;
}
}
}
g_list_free_full (ps, g_object_unref);
}
}
gs_unref_object UDisksBlock *cleartext = udisks_client_get_cleartext_block (client, block);
if (cleartext)
{
is_leaf = FALSE;
if (!walk_block (client, cleartext, walker, user_data, error))
return FALSE;
}
return walker (client, block, is_leaf, user_data, error);
}
void
gdu_partition_dialog_show (GduWindow *window,
UDisksObject *object)
{
EditPartitionData *data;
gint response;
data = g_new0 (EditPartitionData, 1);
data->window = g_object_ref (window);
data->object = g_object_ref (object);
data->partition = udisks_object_get_partition (object);
g_assert (data->partition != NULL);
data->partition_table = udisks_client_get_partition_table (gdu_window_get_client (window), data->partition);
g_assert (data->partition_table != NULL);
data->partition_table_type = udisks_partition_table_dup_type_ (data->partition_table);
if (g_strcmp0 (data->partition_table_type, "gpt") == 0)
{
data->dialog = GTK_WIDGET (gdu_application_new_widget (gdu_window_get_application (window),
"edit-gpt-partition-dialog.ui",
"edit-gpt-partition-dialog",
&data->builder));
data->name_entry = GTK_WIDGET (gtk_builder_get_object (data->builder, "name-entry"));
data->system_checkbutton = GTK_WIDGET (gtk_builder_get_object (data->builder, "system-checkbutton"));
data->hide_from_firmware_checkbutton = GTK_WIDGET (gtk_builder_get_object (data->builder,
"hide-from-firmware-checkbutton"));
data->bootable_checkbutton = GTK_WIDGET (gtk_builder_get_object (data->builder, "bootable-checkbutton"));
g_signal_connect (data->name_entry,
"notify::text", G_CALLBACK (edit_partition_property_changed), data);
g_signal_connect (data->system_checkbutton,
"notify::active", G_CALLBACK (edit_partition_property_changed), data);
g_signal_connect (data->hide_from_firmware_checkbutton,
"notify::active", G_CALLBACK (edit_partition_property_changed), data);
g_signal_connect (data->bootable_checkbutton,
"notify::active", G_CALLBACK (edit_partition_property_changed), data);
}
else if (g_strcmp0 (data->partition_table_type, "dos") == 0)
{
data->dialog = GTK_WIDGET (gdu_application_new_widget (gdu_window_get_application (window),
"edit-dos-partition-dialog.ui",
"edit-dos-partition-dialog",
&data->builder));
data->bootable_checkbutton = GTK_WIDGET (gtk_builder_get_object (data->builder, "bootable-checkbutton"));
g_signal_connect (data->bootable_checkbutton,
"notify::active", G_CALLBACK (edit_partition_property_changed), data);
}
else
{
data->dialog = GTK_WIDGET (gdu_application_new_widget (gdu_window_get_application (window),
"edit-partition-dialog.ui",
"edit-partition-dialog",
&data->builder));
}
data->type_combobox = GTK_WIDGET (gtk_builder_get_object (data->builder, "type-combobox"));
g_signal_connect (data->type_combobox,
"notify::active", G_CALLBACK (edit_partition_property_changed), data);
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window));
gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
edit_partition_populate (data);
edit_partition_update (data);
gtk_widget_show_all (data->dialog);
gtk_widget_grab_focus (data->type_combobox);
/* TODO: do this async */
response = gtk_dialog_run (GTK_DIALOG (data->dialog));
if (response == GTK_RESPONSE_OK)
{
gchar *type;
gchar *name;
guint64 flags;
GError *error;
edit_partition_get (data, &type, &name, &flags);
if (g_strcmp0 (udisks_partition_get_type_ (data->partition), type) != 0)
{
error = NULL;
if (!udisks_partition_call_set_type_sync (data->partition,
type,
g_variant_new ("a{sv}", NULL), /* options */
NULL, /* GCancellable */
&error))
{
gdu_utils_show_error (GTK_WINDOW (window), _("Error setting partition type"), error);
g_error_free (error);
goto set_out;
}
}
if (g_strcmp0 (udisks_partition_get_name (data->partition), name) != 0)
{
error = NULL;
if (!udisks_partition_call_set_name_sync (data->partition,
name,
g_variant_new ("a{sv}", NULL), /* options */
NULL, /* GCancellable */
&error))
{
gdu_utils_show_error (GTK_WINDOW (window), _("Error setting partition name"), error);
g_error_free (error);
goto set_out;
}
}
if (udisks_partition_get_flags (data->partition) != flags)
{
error = NULL;
if (!udisks_partition_call_set_flags_sync (data->partition,
flags,
g_variant_new ("a{sv}", NULL), /* options */
NULL, /* GCancellable */
&error))
{
gdu_utils_show_error (GTK_WINDOW (window), _("Error setting partition flags"), error);
g_error_free (error);
goto set_out;
}
}
set_out:
g_free (type);
g_free (name);
}
edit_partition_data_free (data);
}
