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