static gboolean
handle_set_crypto_options (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
const gchar *arg_passphrase,
const gchar *arg_options)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
if (!(storage_remove_crypto_config (block->udisks_block,
&error)
&& set_crypto_config (block->udisks_block,
arg_passphrase,
arg_options,
&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;
}
cockpit_storage_block_complete_set_crypto_options (object, invocation);
return TRUE;
}
static void
storage_block_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
StorageBlock *self = STORAGE_BLOCK (object);
switch (prop_id)
{
case PROP_REAL_BLOCK:
self->real_block = g_value_dup_object (value);
g_assert (self->real_block != NULL);
break;
case PROP_UDEV_CLIENT:
self->udev_client = g_value_dup_object (value);
g_assert (self->udev_client != NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
handle_format (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
const gchar *arg_type,
const gchar *arg_erase,
const gchar *arg_label,
const gchar *arg_passphrase,
const gchar *arg_mount_point,
const gchar *arg_mount_options,
const gchar *arg_crypto_passphrase,
const gchar *arg_crypto_options)
{
StorageBlock *block = STORAGE_BLOCK(object);
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
start_format_and_configure_block (storage_object_get_provider (block->object),
block->udisks_block,
invocation,
arg_type,
arg_erase,
arg_label,
arg_passphrase,
arg_mount_point,
arg_mount_options,
arg_crypto_passphrase,
arg_crypto_options);
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;
}
static void
on_udisks_block_notify (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
StorageBlock *block = STORAGE_BLOCK (user_data);
storage_block_update (block);
}
static gboolean
handle_create_partition (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
guint64 arg_offset,
guint64 arg_size,
const gchar *arg_type,
const gchar *arg_erase,
const gchar *arg_label,
const gchar *arg_passphrase,
const gchar *arg_mount_point,
const gchar *arg_mount_options,
const gchar *arg_crypto_passphrase,
const gchar *arg_crypto_options)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
gboolean is_extended = (g_strcmp0 (arg_type, "dos-extended") == 0);
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksBlock *partition_block = create_partition (block,
arg_offset,
arg_size,
(is_extended ? "0x05" : ""),
&error);
if (partition_block == NULL)
{
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;
}
if (!is_extended)
{
start_format_and_configure_block (storage_object_get_provider (block->object),
partition_block,
invocation,
arg_type,
arg_erase,
arg_label,
arg_passphrase,
arg_mount_point,
arg_mount_options,
arg_crypto_passphrase,
arg_crypto_options);
}
else
cockpit_storage_block_complete_create_partition (object, invocation);
return TRUE;
}
static gboolean
handle_delete_partition (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation)
{
StorageBlock *block = STORAGE_BLOCK(object);
StorageProvider *provider = storage_object_get_provider (block->object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksPartition *part = udisks_object_peek_partition (udisks_object);
if (part == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not a partition");
g_error_free (error);
return TRUE;
}
if (!storage_cleanup_block (provider,
block->udisks_block,
&error)
|| !udisks_partition_call_delete_sync (part,
g_variant_new ("a{sv}", NULL),
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;
}
cockpit_storage_block_complete_delete_partition (object, invocation);
return TRUE;
}
static void
storage_block_finalize (GObject *object)
{
StorageBlock *self = STORAGE_BLOCK (object);
g_clear_object (&self->real_block);
g_clear_object (&self->udev_client);
g_clear_object (&self->iface_physical_volume);
g_clear_object (&self->iface_logical_volume);
G_OBJECT_CLASS (storage_block_parent_class)->finalize (object);
}
static void
storage_block_finalize (GObject *object)
{
StorageBlock *block = STORAGE_BLOCK (object);
g_signal_handlers_disconnect_by_func (block->udisks_block,
G_CALLBACK (on_udisks_block_notify),
block);
g_object_unref (block->udisks_block);
G_OBJECT_CLASS (storage_block_parent_class)->finalize (object);
}
static gboolean
handle_unlock (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
const gchar *arg_passphrase)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksEncrypted *enc = udisks_object_peek_encrypted (udisks_object);
if (enc == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not encrypted");
g_error_free (error);
return TRUE;
}
if (!udisks_encrypted_call_unlock_sync (enc,
arg_passphrase,
g_variant_new ("a{sv}", NULL),
NULL,
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;
}
cockpit_storage_block_complete_unlock (object, invocation);
return TRUE;
}
static gboolean
handle_mount (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksFilesystem *fsys = udisks_object_peek_filesystem (udisks_object);
if (fsys == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not a filesystem");
g_error_free (error);
return TRUE;
}
if (!udisks_filesystem_call_mount_sync (fsys,
g_variant_new ("a{sv}", NULL),
NULL,
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;
}
cockpit_storage_block_complete_mount (object, invocation);
return TRUE;
}
static void
storage_block_constructed (GObject *object)
{
StorageBlock *block = STORAGE_BLOCK (object);
block->udisks_block = g_object_ref (storage_object_get_udisks_block (block->object));
g_signal_connect (block->udisks_block,
"notify",
G_CALLBACK (on_udisks_block_notify),
block);
storage_block_update (block);
if (G_OBJECT_CLASS (storage_block_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_block_parent_class)->constructed (object);
}
static void
storage_block_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
StorageBlock *block = STORAGE_BLOCK (object);
switch (prop_id)
{
case PROP_OBJECT:
g_value_set_object (value, block->object);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
provider_update_block (StorageProvider *provider,
const gchar *path)
{
UDisksObject *udisks_object = udisks_client_peek_object (provider->udisks_client, path);
if (udisks_object == NULL)
return;
UDisksBlock *udisks_block = udisks_object_peek_block (udisks_object);
if (udisks_block == NULL)
return;
StorageObject *storage_object = storage_provider_lookup_for_udisks_block (provider, udisks_block);
if (storage_object == NULL)
return;
CockpitStorageBlock *storage_block = cockpit_object_peek_storage_block (COCKPIT_OBJECT (storage_object));
if (storage_block == NULL)
return;
storage_block_update (STORAGE_BLOCK (storage_block));
}
static void
storage_block_dispose (GObject *object)
{
StorageBlock *self = STORAGE_BLOCK (object);
StorageDaemon *daemon;
daemon = storage_daemon_get ();
if (self->iface_physical_volume)
{
storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_physical_volume);
g_object_unref (self->iface_physical_volume);
self->iface_physical_volume = NULL;
}
if (self->iface_logical_volume)
{
storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_logical_volume);
g_object_unref (self->iface_logical_volume);
self->iface_logical_volume = NULL;
}
G_OBJECT_CLASS (storage_block_parent_class)->dispose (object);
}
