static gboolean
walk_logical_volume (GDBusObjectManager *objman,
LvmLogicalVolume *vol,
LogicalVolumeWalker *walker,
gpointer user_data,
GError **error)
{
if (!walker (objman, vol, user_data, error))
return FALSE;
const gchar *vol_objpath = g_dbus_object_get_object_path (g_dbus_interface_get_object (G_DBUS_INTERFACE (vol)));
LvmVolumeGroup *group = lvm_util_get_volume_group_for_logical_volume (objman, vol);
GList *siblings = group ? lvm_util_get_logical_volumes_for_volume_group (objman, group) : NULL;
gboolean ret = TRUE;
for (GList *l = siblings; l; l = l->next)
{
LvmLogicalVolume *s = l->data;
if ((g_strcmp0 (lvm_logical_volume_get_type_ (s), "snapshot") == 0
&& g_strcmp0 (lvm_logical_volume_get_origin (s), vol_objpath) == 0)
|| (g_strcmp0 (lvm_logical_volume_get_type_ (s), "thin") == 0
&& g_strcmp0 (lvm_logical_volume_get_thin_pool (s), vol_objpath) == 0))
{
if (!walk_logical_volume (objman, s, walker, user_data, error))
{
ret = FALSE;
break;
}
}
}
g_list_free_full (siblings, g_object_unref);
return ret;
}
static void hev_dbus_interface_test_method_call(GDBusConnection *connection,
const gchar *sender, const gchar *object_path,
const gchar *interface_name, const gchar *method_name,
GVariant *parameters, GDBusMethodInvocation *invocation,
gpointer user_data)
{
HevDBusInterfaceTest *self = HEV_DBUS_INTERFACE_TEST(user_data);
HevDBusObjectTest *obj = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
obj = HEV_DBUS_OBJECT_TEST(g_dbus_interface_get_object(G_DBUS_INTERFACE(self)));
if(0 == g_strcmp0(method_name, "Set"))
{
const gchar *value = NULL;
GVariant *variant = NULL;
g_variant_get(parameters, "(&s)", &value);
value = hev_dbus_object_test_set(obj, value);
variant = g_variant_new("(s)", value);
g_dbus_method_invocation_return_value(invocation, variant);
g_variant_unref(variant);
}
else if(0 == g_strcmp0(method_name, "Get"))
{
const gchar *value = NULL;
GVariant *variant = NULL;
value = hev_dbus_object_test_get(obj);
variant = g_variant_new("(s)", value);
g_dbus_method_invocation_return_value(invocation, variant);
g_variant_unref(variant);
}
}
static gboolean
cleanup_logical_volume_walker (GDBusObjectManager *objman,
LvmLogicalVolume *logical_volume,
gpointer user_data,
GError **error)
{
StorageProvider *provider = user_data;
UDisksBlock *block = lvm_util_peek_block_for_logical_volume (storage_provider_get_lvm_object_manager (provider),
storage_provider_get_udisks_client (provider),
logical_volume);
if (block)
{
/* The logical volume is active, let's clean it up by walking
the tree of block devices hanging off of it.
*/
return cleanup_block (provider, block, error);
}
else
{
/* The logical volume is inactive, let's clean it up by removing
the remembered configs from its children.
*/
LvmObject *object = LVM_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (logical_volume)));
GList *remembered_configs = storage_provider_get_and_forget_remembered_configs
(provider, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
for (GList *l = remembered_configs; l; l = l->next)
{
GVariant *config = l->data;
storage_remove_config (provider, NULL, config);
}
g_list_free_full (remembered_configs, (GDestroyNotify)g_variant_unref);
return TRUE;
}
}
static void
on_job_completed (UDisksJob *job,
gboolean success,
const gchar *message,
gpointer user_data)
{
StorageDaemon *self = STORAGE_DAEMON (user_data);
GDBusObject *object;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (job));
g_assert (object != NULL);
/* Unexport job */
g_dbus_object_manager_server_unexport (self->object_manager,
g_dbus_object_get_object_path (object));
/* free the allocated job object */
g_object_unref (job);
/* returns the reference we took when connecting to the
* UDisksJob::completed signal in storage_daemon_launch_{spawned,threaded}_job()
* below
*/
g_object_unref (self);
g_assert (self->num_jobs > 0);
self->num_jobs--;
maybe_finished (self);
}
static gboolean
handle_add (CockpitMachines *object,
GDBusMethodInvocation *invocation,
const gchar *arg_address,
const gchar *arg_host_key)
{
GError *error = NULL;
Machines *machines = MACHINES (object);
Machine *machine;
if (g_strcmp0 (arg_address, "") == 0)
{
error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"IP address or host name cannot be empty.");
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
machine = machines_add (machines, arg_address, arg_host_key, &error);
if (machine)
{
GDBusObject *obj = g_dbus_interface_get_object (G_DBUS_INTERFACE (machine));
cockpit_machines_complete_add (object, invocation, g_dbus_object_get_object_path (obj));
}
else
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
static gboolean
on_account_handle_ensure_credentials (GoaAccount *account,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GoaDaemon *daemon = GOA_DAEMON (user_data);
GoaProvider *provider;
GoaObject *object;
object = GOA_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (account)));
provider = goa_provider_get_for_provider_type (goa_account_get_provider_type (account));
if (provider == NULL)
{
g_dbus_method_invocation_return_error (invocation,
GOA_ERROR,
GOA_ERROR_FAILED,
"Unsupported account type %s for id %s (no provider)",
goa_account_get_provider_type (account),
goa_account_get_id (account));
goto out;
}
goa_provider_ensure_credentials (provider,
object,
NULL, /* GCancellable */
(GAsyncReadyCallback) ensure_credentials_cb,
ensure_data_new (daemon, object, invocation));
out:
return TRUE; /* invocation was handled */
}
static UDisksBlock *
peek_block_for_logical_volume (UDisksLogicalVolume *volume,
UDisksDaemon *daemon)
{
UDisksBlock *ret = NULL;
GDBusObject *object;
GList *l, *objects = NULL;
UDisksBlockLVM2 *block_lvm2;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (volume));
if (object == NULL)
goto out;
objects = udisks_daemon_get_objects (daemon);
for (l = objects; l != NULL; l = l->next)
{
block_lvm2 = udisks_object_peek_block_lvm2 (UDISKS_OBJECT(l->data));
if (block_lvm2 &&
g_strcmp0 (udisks_block_lvm2_get_logical_volume (block_lvm2),
g_dbus_object_get_object_path (object)) == 0)
{
ret = udisks_object_peek_block (UDISKS_OBJECT(l->data));
goto out;
}
}
out:
g_list_free_full (objects, g_object_unref);
return ret;
}
const gchar *
setting_get_object_path (Setting *setting)
{
g_return_val_if_fail (IS_SETTING (setting), NULL);
GDBusObject *object = NULL;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (setting));
return g_dbus_object_get_object_path (object);
}
static gboolean
teardown_logical_volume (UDisksLogicalVolume *volume,
UDisksDaemon *daemon,
GDBusMethodInvocation *invocation,
GVariant *options,
GError **error)
{
GDBusObject *volume_object;
UDisksObject *group_object;
UDisksVolumeGroup *group;
UDisksLogicalVolume *sibling_volume;
GList *siblings;
GList *l;
if (!udisks_linux_logical_volume_teardown_block (volume,
daemon,
invocation,
options,
error))
return FALSE;
/* Recurse for pool members and snapshots.
*/
volume_object = g_dbus_interface_get_object (G_DBUS_INTERFACE (volume));
group_object = udisks_daemon_find_object (daemon, udisks_logical_volume_get_volume_group (volume));
if (volume_object && group_object)
{
group = udisks_object_peek_volume_group (group_object);
if (group)
{
siblings = udisks_linux_volume_group_get_logical_volumes (group, daemon);
for (l = siblings; l; l = l->next)
{
sibling_volume = UDISKS_LOGICAL_VOLUME (l->data);
if (g_strcmp0 (udisks_logical_volume_get_thin_pool (sibling_volume),
g_dbus_object_get_object_path (volume_object)) == 0 ||
g_strcmp0 (udisks_logical_volume_get_origin (sibling_volume),
g_dbus_object_get_object_path (volume_object)) == 0)
{
if (!teardown_logical_volume (sibling_volume,
daemon,
invocation,
options,
error))
{
g_list_free_full (siblings, g_object_unref);
return FALSE;
}
}
}
g_list_free_full (siblings, g_object_unref);
}
}
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 gboolean
on_handle_remove_alpha (TestFrobber *frobber,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
TestObjectSkeleton *enclosing;
enclosing = TEST_OBJECT_SKELETON (g_dbus_interface_get_object (G_DBUS_INTERFACE (frobber)));
if (test_object_peek_alpha (TEST_OBJECT (enclosing)) != NULL)
test_object_skeleton_set_alpha (enclosing, NULL);
test_frobber_complete_add_alpha (frobber, invocation);
return TRUE;
}
static UDisksBlock *
create_partition (StorageBlock *block,
guint64 offset,
guint64 size,
const gchar *type,
GError **error)
{
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object (G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_set_error (error, COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"No object!?");
return NULL;
}
UDisksPartitionTable *table = udisks_object_peek_partition_table (udisks_object);
if (table == NULL)
{
g_set_error (error, COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"Block device has no partition table");
return NULL;
}
gs_free gchar *part_object_path = NULL;
if (!udisks_partition_table_call_create_partition_sync (table,
offset,
size,
type,
"",
g_variant_new ("a{sv}", NULL),
&part_object_path,
NULL,
error))
return NULL;
StorageProvider *provider = storage_object_get_provider (block->object);
UDisksClient *client = storage_provider_get_udisks_client (provider);
udisks_client_settle (client);
gs_unref_object UDisksObject *partition_object =
udisks_client_get_object (client, part_object_path);
UDisksBlock *partition_block = udisks_object_peek_block (partition_object);
if (partition_block == NULL)
{
g_set_error (error, COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"Partition has no associated block device");
return NULL;
}
return partition_block;
}
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
on_handle_get_password (GoaPasswordBased *interface,
GDBusMethodInvocation *invocation,
const gchar *id,
gpointer user_data)
{
GoaObject *object;
GoaAccount *account;
GoaProvider *provider;
GError *error;
GVariant *credentials;
gchar *password;
/* TODO: maybe log what app is requesting access */
password = NULL;
credentials = NULL;
object = GOA_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (interface)));
account = goa_object_peek_account (object);
provider = goa_provider_get_for_provider_type (goa_account_get_provider_type (account));
error = NULL;
credentials = goa_utils_lookup_credentials_sync (provider,
object,
NULL, /* GCancellable* */
&error);
if (credentials == NULL)
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
if (!g_variant_lookup (credentials, "password", "s", &password))
{
g_dbus_method_invocation_return_error (invocation,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("Did not find password with username `%s' in credentials"),
id);
goto out;
}
goa_password_based_complete_get_password (interface, invocation, password);
out:
g_free (password);
if (credentials != NULL)
g_variant_unref (credentials);
g_object_unref (provider);
return TRUE; /* invocation was handled */
}
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;
}
void
setting_unexport (Setting *setting)
{
g_return_if_fail (IS_SETTING (setting));
GDBusObjectManagerServer *object_manager;
GDBusObject *object;
object_manager = daemon_get_object_manager (setting->daemon);
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (setting));
if (object != NULL)
g_dbus_object_manager_server_unexport (object_manager,
g_dbus_object_get_object_path (object));
}
static void hev_dbus_interface_test_constructed(GObject *obj)
{
GDBusObject *dbus_obj = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
G_OBJECT_CLASS(hev_dbus_interface_test_parent_class)->constructed(obj);
dbus_obj = g_dbus_interface_get_object(G_DBUS_INTERFACE(obj));
/* Connect object signals */
g_signal_connect(G_OBJECT(dbus_obj), "notify::value",
G_CALLBACK(hev_dbus_object_test_notify_value_handler), obj);
g_signal_connect(G_OBJECT(dbus_obj), "changed",
G_CALLBACK(hev_dbus_object_test_changed_handler), obj);
}
static void
user_removed (ActUserManager *um,
ActUser *user,
Accounts *accounts)
{
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon_get ());
Account *acc = g_hash_table_lookup (accounts->act_user_to_account, user);
if (acc)
{
account_update (acc, NULL);
g_dbus_object_manager_server_unexport (object_manager_server,
g_dbus_object_get_object_path (g_dbus_interface_get_object (G_DBUS_INTERFACE (acc))));
g_hash_table_remove (accounts->act_user_to_account, user);
}
}
static gboolean
cleanup_block_walker (UDisksClient *client,
UDisksBlock *block,
gboolean is_leaf,
gpointer user_data,
GError **error)
{
StorageProvider *provider = user_data;
UDisksObject *object = UDISKS_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (block)));
UDisksEncrypted *enc = udisks_object_peek_encrypted (object);
if (enc)
{
UDisksBlock *cleartext = udisks_client_get_cleartext_block (client, block);
if (cleartext)
{
/* The crypto backing device is unlocked and the cleartext
device has been cleaned up. Lock the backing device so
that we can format or wipe it later.
*/
if (enc && !udisks_encrypted_call_lock_sync (enc,
g_variant_new ("a{sv}", NULL),
NULL,
error))
return FALSE;
}
else
{
/* The crypto backing device is locked and the cleartext
device has not been cleaned up (since it doesn't exist).
Remove its remembered configs.
*/
GList *remembered_configs = storage_provider_get_and_forget_remembered_configs
(provider, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
for (GList *l = remembered_configs; l; l = l->next)
{
GVariant *config = l->data;
storage_remove_config (provider, block, config);
}
g_list_free_full (remembered_configs, (GDestroyNotify)g_variant_unref);
}
}
storage_remove_config (provider, block, udisks_block_get_configuration (block));
return TRUE;
}
void
storage_remember_block_configs (StorageProvider *provider,
UDisksBlock *block)
{
GVariant *config = udisks_block_get_configuration (block);
if (g_variant_n_children (config) > 0)
{
UDisksClient *client = storage_provider_get_udisks_client (provider);
GDBusObjectManager *objman = storage_provider_get_lvm_object_manager (provider);
GDBusObject *object = g_dbus_interface_get_object (G_DBUS_INTERFACE (block));
struct RememberData data;
data.provider = provider;
data.child_path = g_dbus_object_get_object_path (object);
data.config = config;
walk_block_parents (client, objman, block, remember_configs, &data, NULL);
}
}
static gboolean hev_dbus_interface_test_set_property(GDBusConnection *connection,
const gchar *sender, const gchar *object_path,
const gchar *interface_name, const gchar *property_name,
GVariant *value, GError **error, gpointer user_data)
{
GDBusObject *obj = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
obj = g_dbus_interface_get_object(G_DBUS_INTERFACE(user_data));
if(0 == g_strcmp0(property_name, "Value"))
g_object_set(G_OBJECT(obj), "value", g_variant_get_string(value, NULL), NULL);
else
return FALSE;
return TRUE;
}
void
setting_export (Setting *setting)
{
g_return_if_fail (IS_SETTING (setting));
GDBusObjectManagerServer *object_manager;
object_manager = daemon_get_object_manager (setting->daemon);
if (g_dbus_interface_get_object (G_DBUS_INTERFACE (setting)) == NULL)
{
LoomObjectSkeleton *object = NULL;
object = loom_object_skeleton_new ("/org/blackox/Loom/Setting");
loom_object_skeleton_set_setting (object, LOOM_SETTING (setting));
g_dbus_object_manager_server_export_uniquely (object_manager,
G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
}
}
static GVariant * hev_dbus_interface_test_get_properties(GDBusInterfaceSkeleton *skeleton)
{
GDBusObject *obj = NULL;
GVariantBuilder *builder = NULL;
GVariant *variant = NULL;
gchar *p = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
obj = g_dbus_interface_get_object(G_DBUS_INTERFACE(skeleton));
g_object_get(G_OBJECT(obj), "value", &p, NULL);
builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(builder, "{sv}", "Value", g_variant_new_string(p));
variant = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
g_free(p);
return variant;
}
static GVariant * hev_dbus_interface_test_get_property(GDBusConnection *connection,
const gchar *sender, const gchar *object_path,
const gchar *interface_name, const gchar *property_name,
GError **error, gpointer user_data)
{
GDBusObject *obj = NULL;
GVariant *variant = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
obj = g_dbus_interface_get_object(G_DBUS_INTERFACE(user_data));
if(0 == g_strcmp0(property_name, "Value"))
{
gchar *p = NULL;
g_object_get(G_OBJECT(obj), "value", &p, NULL);
variant = g_variant_new_string(p);
g_free(p);
}
return variant;
}
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);
}
static void
udisks_client_get_object_info_for_drive (UDisksClient *client,
UDisksDrive *drive,
UDisksPartition *partition,
UDisksObjectInfo *info)
{
const gchar *vendor;
const gchar *model;
const gchar *media;
const gchar *const *media_compat;
gboolean media_available;
gboolean media_removable;
gint rotation_rate;
guint64 size;
gchar *size_str;
guint n;
GString *desc_str;
DriveType desc_type;
gchar *hyphenated_connection_bus;
const gchar *connection_bus;
UDisksBlock *block = NULL;
gchar *s;
const gchar *cs;
UDisksBlock *block_for_partition = NULL;
g_return_if_fail (UDISKS_IS_DRIVE (drive));
size_str = NULL;
vendor = udisks_drive_get_vendor (drive);
model = udisks_drive_get_model (drive);
size = udisks_drive_get_size (drive);
media_removable = udisks_drive_get_media_removable (drive);
media_available = udisks_drive_get_media_available (drive);
rotation_rate = udisks_drive_get_rotation_rate (drive);
if (size > 0)
size_str = udisks_client_get_size_for_display (client, size, FALSE, FALSE);
media = udisks_drive_get_media (drive);
media_compat = udisks_drive_get_media_compatibility (drive);
connection_bus = udisks_drive_get_connection_bus (drive);
if (strlen (connection_bus) > 0)
hyphenated_connection_bus = g_strdup_printf ("-%s", connection_bus);
else
hyphenated_connection_bus = g_strdup ("");
/* Name is easy - that's just "$vendor $model" */
if (strlen (vendor) == 0)
vendor = NULL;
if (strlen (model) == 0)
model = NULL;
info->name = g_strdup_printf ("%s%s%s",
vendor != NULL ? vendor : "",
vendor != NULL ? " " : "",
model != NULL ? model : "");
desc_type = DRIVE_TYPE_UNSET;
desc_str = g_string_new (NULL);
for (n = 0; n < G_N_ELEMENTS (media_data) - 1; n++)
{
/* media_compat */
if (strv_has (media_compat, media_data[n].id))
{
if (info->icon == NULL)
info->icon = g_themed_icon_new_with_default_fallbacks (media_data[n].drive_icon);
if (info->icon_symbolic == NULL)
info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (media_data[n].drive_icon_symbolic);
if (strstr (desc_str->str, media_data[n].media_family) == NULL)
{
if (desc_str->len > 0)
g_string_append (desc_str, "/");
g_string_append (desc_str, g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_family));
}
desc_type = media_data[n].media_type;
}
if (media_removable && media_available)
{
/* media */
if (g_strcmp0 (media, media_data[n].id) == 0)
{
if (info->media_description == NULL)
{
switch (media_data[n].media_type)
{
case DRIVE_TYPE_UNSET:
g_assert_not_reached ();
break;
case DRIVE_TYPE_DRIVE:
/* Translators: Used to describe drive without removable media. The %s is the type, e.g. 'Thumb' */
info->media_description = g_strdup_printf (C_("drive-with-fixed-media", "%s Drive"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name));
break;
case DRIVE_TYPE_DISK:
/* Translators: Used to describe generic media. The %s is the type, e.g. 'Zip' or 'Floppy' */
info->media_description = g_strdup_printf (C_("drive-with-generic-media", "%s Disk"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name));
break;
case DRIVE_TYPE_CARD:
/* Translators: Used to describe flash media. The %s is the type, e.g. 'SD' or 'CompactFlash' */
info->media_description = g_strdup_printf (C_("flash-media", "%s Card"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name));
break;
case DRIVE_TYPE_DISC:
/* Translators: Used to describe optical discs. The %s is the type, e.g. 'CD-R' or 'DVD-ROM' */
info->media_description = g_strdup_printf (C_("optical-media", "%s Disc"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name));
break;
}
}
if (info->media_icon == NULL)
info->media_icon = g_themed_icon_new_with_default_fallbacks (media_data[n].media_icon);
if (info->media_icon_symbolic == NULL)
info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (media_data[n].media_icon_symbolic);
}
}
}
switch (desc_type)
{
case DRIVE_TYPE_UNSET:
if (media_removable)
{
if (size_str != NULL)
{
/* Translators: Used to describe a drive. The %s is the size, e.g. '20 GB' */
info->description = g_strdup_printf (C_("drive-with-size", "%s Drive"), size_str);
}
else
{
/* Translators: Used to describe a drive we know very little about (removable media or size not known) */
info->description = g_strdup (C_("generic-drive", "Drive"));
}
}
else
{
if (rotation_rate == 0)
{
if (size_str != NULL)
{
/* Translators: Used to describe a non-rotating drive (rotation rate either unknown
* or it's a solid-state drive). The %s is the size, e.g. '20 GB'. */
info->description = g_strdup_printf (C_("disk-non-rotational", "%s Disk"), size_str);
}
else
{
/* Translators: Used to describe a non-rotating drive (rotation rate either unknown
* or it's a solid-state drive). The drive is either using removable media or its
* size not known. */
info->description = g_strdup (C_("disk-non-rotational", "Disk"));
}
}
else
{
if (size_str != NULL)
{
/* Translators: Used to describe a hard-disk drive (HDD). The %s is the size, e.g. '20 GB'. */
info->description = g_strdup_printf (C_("disk-hdd", "%s Hard Disk"), size_str);
}
else
{
/* Translators: Used to describe a hard-disk drive (HDD) (removable media or size not known) */
info->description = g_strdup (C_("disk-hdd", "Hard Disk"));
}
}
}
break;
case DRIVE_TYPE_CARD:
/* Translators: Used to describe a card reader. The %s is the card type e.g. 'CompactFlash'. */
info->description = g_strdup_printf (C_("drive-card-reader", "%s Card Reader"), desc_str->str);
break;
case DRIVE_TYPE_DRIVE: /* explicit fall-through */
case DRIVE_TYPE_DISK: /* explicit fall-through */
case DRIVE_TYPE_DISC:
if (!media_removable && size_str != NULL)
{
/* Translators: Used to describe drive. The first %s is the size e.g. '20 GB' and the
* second %s is the drive type e.g. 'Thumb'.
*/
info->description = g_strdup_printf (C_("drive-with-size-and-type", "%s %s Drive"), size_str, desc_str->str);
}
else
{
/* Translators: Used to describe drive. The first %s is the drive type e.g. 'Thumb'.
*/
info->description = g_strdup_printf (C_("drive-with-type", "%s Drive"), desc_str->str);
}
break;
}
g_string_free (desc_str, TRUE);
/* fallback for icon */
if (info->icon == NULL)
{
if (media_removable)
{
s = g_strdup_printf ("drive-removable-media%s", hyphenated_connection_bus);
}
else
{
if (rotation_rate == 0)
s = g_strdup_printf ("drive-harddisk-solidstate%s", hyphenated_connection_bus);
else
s = g_strdup_printf ("drive-harddisk%s", hyphenated_connection_bus);
}
info->icon = g_themed_icon_new_with_default_fallbacks (s);
g_free (s);
}
/* fallback for icon_symbolic */
if (info->icon_symbolic == NULL)
{
if (media_removable)
{
s = g_strdup_printf ("drive-removable-media%s-symbolic", hyphenated_connection_bus);
}
else
{
if (rotation_rate == 0)
s = g_strdup_printf ("drive-harddisk-solidstate%s-symbolic", hyphenated_connection_bus);
else
s = g_strdup_printf ("drive-harddisk%s-symbolic", hyphenated_connection_bus);
}
info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (s);
g_free (s);
}
/* fallback for media_icon */
if (media_removable && media_available && info->media_icon == NULL)
{
if (media_removable)
{
s = g_strdup_printf ("drive-removable-media%s", hyphenated_connection_bus);
}
else
{
if (rotation_rate == 0)
s = g_strdup_printf ("drive-harddisk-solidstate%s", hyphenated_connection_bus);
else
s = g_strdup_printf ("drive-harddisk%s", hyphenated_connection_bus);
}
info->media_icon = g_themed_icon_new_with_default_fallbacks (s);
g_free (s);
}
/* fallback for media_icon_symbolic */
if (media_removable && media_available && info->media_icon_symbolic == NULL)
{
if (media_removable)
{
s = g_strdup_printf ("drive-removable-media%s-symbolic", hyphenated_connection_bus);
}
else
{
if (rotation_rate == 0)
s = g_strdup_printf ("drive-harddisk-solidstate%s-symbolic", hyphenated_connection_bus);
else
s = g_strdup_printf ("drive-harddisk%s-symbolic", hyphenated_connection_bus);
}
info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (s);
g_free (s);
}
/* prepend a qualifier to the media description, based on the disc state */
if (udisks_drive_get_optical_blank (drive))
{
/* Translators: String used for a blank disc. The %s is the disc type e.g. "CD-RW Disc" */
s = g_strdup_printf (C_("optical-media", "Blank %s"), info->media_description);
g_free (info->media_description);
info->media_description = s;
}
else if (udisks_drive_get_optical_num_audio_tracks (drive) > 0 &&
udisks_drive_get_optical_num_data_tracks (drive) > 0)
{
/* Translators: String used for a mixed disc. The %s is the disc type e.g. "CD-ROM Disc" */
s = g_strdup_printf (C_("optical-media", "Mixed %s"), info->media_description);
g_free (info->media_description);
info->media_description = s;
}
else if (udisks_drive_get_optical_num_audio_tracks (drive) > 0 &&
udisks_drive_get_optical_num_data_tracks (drive) == 0)
{
/* Translators: String used for an audio disc. The %s is the disc type e.g. "CD-ROM Disc" */
s = g_strdup_printf (C_("optical-media", "Audio %s"), info->media_description);
g_free (info->media_description);
info->media_description = s;
}
/* Apply UDISKS_NAME, UDISKS_ICON_NAME, UDISKS_SYMBOLIC_ICON_NAME hints, if available */
block = udisks_client_get_block_for_drive (client, drive, TRUE);
if (block != NULL)
{
cs = udisks_block_get_hint_name (block);
if (cs != NULL && strlen (cs) > 0)
{
g_free (info->description);
g_free (info->media_description);
info->description = g_strdup (cs);
info->media_description = g_strdup (cs);
}
cs = udisks_block_get_hint_icon_name (block);
if (cs != NULL && strlen (cs) > 0)
{
g_clear_object (&info->icon);
g_clear_object (&info->media_icon);
info->icon = g_themed_icon_new_with_default_fallbacks (cs);
info->media_icon = g_themed_icon_new_with_default_fallbacks (cs);
}
cs = udisks_block_get_hint_symbolic_icon_name (block);
if (cs != NULL && strlen (cs) > 0)
{
g_clear_object (&info->icon_symbolic);
g_clear_object (&info->media_icon_symbolic);
info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (cs);
info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (cs);
}
}
if (partition != NULL)
{
GDBusObject *object_for_partition;
object_for_partition = g_dbus_interface_get_object (G_DBUS_INTERFACE (partition));
if (object_for_partition != NULL)
block_for_partition = udisks_object_peek_block (UDISKS_OBJECT (object_for_partition));
}
if (block_for_partition == NULL)
block_for_partition = block;
if (partition != NULL)
{
/* Translators: Used to describe a partition of a drive.
* The %d is the partition number.
* The %s is the description for the drive (e.g. "2 GB Thumb Drive").
*/
s = g_strdup_printf (C_("part-drive", "Partition %d of %s"),
udisks_partition_get_number (partition), info->description);
g_free (info->description);
info->description = s;
}
/* calculate and set one-liner */
if (block != NULL)
{
const gchar *drive_revision = udisks_drive_get_revision (drive);
if (strlen (drive_revision) > 0)
{
/* Translators: String used for one-liner description of drive.
* The first %s is the description of the object (e.g. "80 GB Disk" or "Partition 2 of 2 GB Thumb Drive").
* The second %s is the name of the object (e.g. "INTEL SSDSA2MH080G1GC").
* The third %s is the fw revision (e.g "45ABX21").
* The fourth %s is the special device file (e.g. "/dev/sda").
*/
info->one_liner = g_strdup_printf (C_("one-liner-drive", "%s — %s [%s] (%s)"),
info->description,
info->name,
drive_revision,
udisks_block_get_preferred_device (block_for_partition));
}
else
{
/* Translators: String used for one-liner description of drive w/o known fw revision.
* The first %s is the description of the object (e.g. "80 GB Disk").
* The second %s is the name of the object (e.g. "INTEL SSDSA2MH080G1GC").
* The third %s is the special device file (e.g. "/dev/sda").
*/
info->one_liner = g_strdup_printf (C_("one-liner-drive", "%s — %s (%s)"),
info->description,
info->name,
udisks_block_get_preferred_device (block_for_partition));
}
}
g_free (hyphenated_connection_bus);
g_free (size_str);
info->sort_key = g_strdup_printf ("00_drive_%s", udisks_drive_get_sort_key (drive));
g_clear_object (&block);
}
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, "/");
}