/**
* udisks_daemon_util_on_user_seat:
* @daemon: A #UDisksDaemon.
* @object: The #GDBusObject that the call is on or %NULL.
* @user: The user to check for.
*
* Checks whether the device represented by @object (if any) is plugged into
* a seat where the caller represented by @user is logged in and active.
*
* This works if @object is a drive or a block object.
*
* Returns: %TRUE if @object is on the same seat as one of @user's
* active sessions, %FALSE otherwise.
*/
gboolean
udisks_daemon_util_on_user_seat (UDisksDaemon *daemon,
UDisksObject *object,
uid_t user)
{
#if !defined(HAVE_LIBSYSTEMD_LOGIN)
/* if we don't have systemd, assume it's always the same seat */
return TRUE;
#else
gboolean ret = FALSE;
char *session = NULL;
char *seat = NULL;
const gchar *drive_seat;
UDisksObject *drive_object = NULL;
UDisksDrive *drive = NULL;
/* if we don't have logind, assume it's always the same seat */
if (!LOGIND_AVAILABLE())
return TRUE;
if (UDISKS_IS_LINUX_BLOCK_OBJECT (object))
{
UDisksLinuxBlockObject *linux_block_object;
UDisksBlock *block;
linux_block_object = UDISKS_LINUX_BLOCK_OBJECT (object);
block = udisks_object_get_block (UDISKS_OBJECT (linux_block_object));
if (block != NULL)
{
drive_object = udisks_daemon_find_object (daemon, udisks_block_get_drive (block));
g_object_unref (block);
}
}
else if (UDISKS_IS_LINUX_DRIVE_OBJECT (object))
{
drive_object = g_object_ref (object);
}
if (drive_object == NULL)
goto out;
drive = udisks_object_get_drive (UDISKS_OBJECT (drive_object));
if (drive == NULL)
goto out;
drive_seat = udisks_drive_get_seat (drive);
if (drive_seat != NULL && sd_uid_is_on_seat (user, TRUE, drive_seat) > 0)
{
ret = TRUE;
goto out;
}
out:
free (seat);
free (session);
g_clear_object (&drive_object);
g_clear_object (&drive);
return ret;
#endif /* HAVE_LIBSYSTEMD_LOGIN */
}
static void
udisks_linux_block_object_constructed (GObject *_object)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (_object);
GString *str;
object->mount_monitor = udisks_daemon_get_mount_monitor (object->daemon);
g_signal_connect (object->mount_monitor,
"mount-added",
G_CALLBACK (on_mount_monitor_mount_added),
object);
g_signal_connect (object->mount_monitor,
"mount-removed",
G_CALLBACK (on_mount_monitor_mount_removed),
object);
/* initial coldplug */
udisks_linux_block_object_uevent (object, "add", NULL);
/* compute the object path */
str = g_string_new ("/org/freedesktop/UDisks2/block_devices/");
udisks_safe_append_to_object_path (str, g_udev_device_get_name (object->device->udev_device));
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), str->str);
g_string_free (str, TRUE);
if (G_OBJECT_CLASS (udisks_linux_block_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (udisks_linux_block_object_parent_class)->constructed (_object);
}
static void
udisks_linux_block_object_set_property (GObject *__object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (__object);
switch (prop_id)
{
case PROP_DAEMON:
g_assert (object->daemon == NULL);
/* we don't take a reference to the daemon */
object->daemon = g_value_get_object (value);
break;
case PROP_DEVICE:
g_assert (object->device == NULL);
object->device = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
udisks_linux_block_object_finalize (GObject *_object)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (_object);
/* note: we don't hold a ref to block->daemon or block->mount_monitor */
g_signal_handlers_disconnect_by_func (object->mount_monitor, on_mount_monitor_mount_added, object);
g_signal_handlers_disconnect_by_func (object->mount_monitor, on_mount_monitor_mount_removed, object);
g_object_unref (object->device);
if (object->iface_block_device != NULL)
g_object_unref (object->iface_block_device);
if (object->iface_partition != NULL)
g_object_unref (object->iface_partition);
if (object->iface_partition_table != NULL)
g_object_unref (object->iface_partition_table);
if (object->iface_filesystem != NULL)
g_object_unref (object->iface_filesystem);
if (object->iface_swapspace != NULL)
g_object_unref (object->iface_swapspace);
if (object->iface_encrypted != NULL)
g_object_unref (object->iface_encrypted);
if (object->iface_loop != NULL)
g_object_unref (object->iface_loop);
if (G_OBJECT_CLASS (udisks_linux_block_object_parent_class)->finalize != NULL)
G_OBJECT_CLASS (udisks_linux_block_object_parent_class)->finalize (_object);
}
static gboolean
bcache_block_update (UDisksObject *object,
const gchar *uevent_action,
GDBusInterface *_iface)
{
return udisks_linux_block_bcache_update (UDISKS_LINUX_BLOCK_BCACHE (_iface),
UDISKS_LINUX_BLOCK_OBJECT (object));
}
static void
on_mount_monitor_mount_removed (UDisksMountMonitor *monitor,
UDisksMount *mount,
gpointer user_data)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (user_data);
if (udisks_mount_get_dev (mount) == g_udev_device_get_device_number (object->device->udev_device))
udisks_linux_block_object_uevent (object, NULL, NULL);
}
/**
* udisks_linux_block_object_new:
* @daemon: A #UDisksDaemon.
* @device: The #UDisksLinuxDevice for the device.
*
* Create a new block object.
*
* Returns: A #UDisksLinuxBlockObject object. Free with g_object_unref().
*/
UDisksLinuxBlockObject *
udisks_linux_block_object_new (UDisksDaemon *daemon,
UDisksLinuxDevice *device)
{
g_return_val_if_fail (UDISKS_IS_DAEMON (daemon), NULL);
return UDISKS_LINUX_BLOCK_OBJECT (g_object_new (UDISKS_TYPE_LINUX_BLOCK_OBJECT,
"daemon", daemon,
"device", device,
NULL));
}
static gboolean
bcache_block_check (UDisksObject *object)
{
UDisksLinuxDevice *device = NULL;
gboolean rval = FALSE;
g_return_val_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object), FALSE);
/* Check device name */
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (object));
rval = g_str_has_prefix (g_udev_device_get_device_file (device->udev_device),
"/dev/bcache");
g_object_unref(device);
return rval;
}
/**
* udisks_linux_drive_object_get_block:
* @object: A #UDisksLinuxDriveObject.
* @get_hw: If the drive is multipath, set to %TRUE to get a path device instead of the multipath device.
*
* Gets a #UDisksLinuxBlockObject representing a block device associated with @object.
*
* Returns: A #UDisksLinuxBlockObject or %NULL. The returned object
* must be freed with g_object_unref().
*/
UDisksLinuxBlockObject *
udisks_linux_drive_object_get_block (UDisksLinuxDriveObject *object,
gboolean get_hw)
{
GDBusObjectManagerServer *object_manager;
UDisksLinuxBlockObject *ret;
GList *objects;
GList *l;
/* TODO: actually look at @get_hw */
ret = NULL;
object_manager = udisks_daemon_get_object_manager (object->daemon);
objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager));
for (l = objects; l != NULL; l = l->next)
{
GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data);
UDisksBlock *block;
UDisksLinuxDevice *device;
gboolean is_disk;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (iter_object))
continue;
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (iter_object));
is_disk = (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0);
g_object_unref (device);
if (!is_disk)
continue;
block = udisks_object_peek_block (UDISKS_OBJECT (iter_object));
if (g_strcmp0 (udisks_block_get_drive (block),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object))) == 0)
{
ret = g_object_ref (iter_object);
goto out;
}
}
out:
g_list_foreach (objects, (GFunc) g_object_unref, NULL);
g_list_free (objects);
return ret;
}
static void
update_all_block_objects (UDisksLinuxProvider *provider)
{
GList *objects;
GList *l;
G_LOCK (provider_lock);
objects = g_hash_table_get_values (provider->sysfs_to_block);
g_list_foreach (objects, (GFunc) g_object_ref, NULL);
G_UNLOCK (provider_lock);
for (l = objects; l != NULL; l = l->next)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (l->data);
udisks_linux_block_object_uevent (object, "change", NULL);
}
g_list_foreach (objects, (GFunc) g_object_unref, NULL);
g_list_free (objects);
}
static void
udisks_linux_block_object_get_property (GObject *__object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (__object);
switch (prop_id)
{
case PROP_DAEMON:
g_value_set_object (value, udisks_linux_block_object_get_daemon (object));
break;
case PROP_DEVICE:
g_value_set_object (value, udisks_linux_block_object_get_device (object));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* udisks_daemon_util_on_same_seat:
* @daemon: A #UDisksDaemon.
* @object: The #GDBusObject that the call is on or %NULL.
* @process: The process to check for.
*
* Checks whether the device represented by @object (if any) is plugged into
* a seat where the caller represented by @process is logged in.
*
* This works if @object is a drive or a block object.
*
* Returns: %TRUE if @object and @process is on the same seat, %FALSE otherwise.
*/
gboolean
udisks_daemon_util_on_same_seat (UDisksDaemon *daemon,
UDisksObject *object,
pid_t process)
{
#if !defined(HAVE_LIBSYSTEMD_LOGIN)
/* if we don't have systemd, assume it's always the same seat */
return TRUE;
#else
gboolean ret = FALSE;
char *session = NULL;
char *seat = NULL;
const gchar *drive_seat;
UDisksObject *drive_object = NULL;
UDisksDrive *drive = NULL;
/* if we don't have logind, assume it's always the same seat */
if (!LOGIND_AVAILABLE())
return TRUE;
if (UDISKS_IS_LINUX_BLOCK_OBJECT (object))
{
UDisksLinuxBlockObject *linux_block_object;
UDisksBlock *block;
linux_block_object = UDISKS_LINUX_BLOCK_OBJECT (object);
block = udisks_object_get_block (UDISKS_OBJECT (linux_block_object));
if (block != NULL)
{
drive_object = udisks_daemon_find_object (daemon, udisks_block_get_drive (block));
g_object_unref (block);
}
}
else if (UDISKS_IS_LINUX_DRIVE_OBJECT (object))
{
drive_object = g_object_ref (object);
}
if (drive_object == NULL)
goto out;
drive = udisks_object_get_drive (UDISKS_OBJECT (drive_object));
if (drive == NULL)
goto out;
/* It's not unexpected to not find a session, nor a seat associated with @process */
if (sd_pid_get_session (process, &session) == 0)
sd_session_get_seat (session, &seat);
/* If we don't know the seat of the caller, we assume the device is always on another seat */
if (seat == NULL)
goto out;
drive_seat = udisks_drive_get_seat (drive);
if (g_strcmp0 (seat, drive_seat) == 0)
{
ret = TRUE;
goto out;
}
out:
free (seat);
free (session);
g_clear_object (&drive_object);
g_clear_object (&drive);
return ret;
#endif /* HAVE_LIBSYSTEMD_LOGIN */
}
