/**
* 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 */
}
/**
* udisks_linux_block_object_trigger_uevent:
* @object: A #UDisksLinuxBlockObject.
*
* Triggers a 'change' uevent in the kernel.
*
* The triggered event will bubble up from the kernel through the udev
* stack and will eventually be received by the udisks daemon process
* itself. This method does not wait for the event to be received.
*/
void
udisks_linux_block_object_trigger_uevent (UDisksLinuxBlockObject *object)
{
gchar* path = NULL;
gint fd = -1;
g_return_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object));
/* TODO: would be nice with a variant to wait until the request uevent has been received by ourselves */
path = g_strconcat (g_udev_device_get_sysfs_path (object->device->udev_device), "/uevent", NULL);
fd = open (path, O_WRONLY);
if (fd < 0)
{
udisks_warning ("Error opening %s: %m", path);
goto out;
}
if (write (fd, "change", sizeof "change" - 1) != sizeof "change" - 1)
{
udisks_warning ("Error writing 'change' to file %s: %m", path);
goto out;
}
out:
if (fd >= 0)
close (fd);
g_free (path);
}
/**
* udisks_linux_block_object_uevent:
* @object: A #UDisksLinuxBlockObject.
* @action: Uevent action or %NULL
* @device: A new #UDisksLinuxDevice device object or %NULL if the device hasn't changed.
*
* Updates all information on interfaces on @object.
*/
void
udisks_linux_block_object_uevent (UDisksLinuxBlockObject *object,
const gchar *action,
UDisksLinuxDevice *device)
{
g_return_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object));
g_return_if_fail (device == NULL || UDISKS_IS_LINUX_DEVICE (device));
if (device != NULL)
{
g_object_unref (object->device);
object->device = g_object_ref (device);
g_object_notify (G_OBJECT (object), "device");
}
update_iface (object, action, block_device_check, block_device_connect, block_device_update,
UDISKS_TYPE_LINUX_BLOCK, &object->iface_block_device);
update_iface (object, action, filesystem_check, filesystem_connect, filesystem_update,
UDISKS_TYPE_LINUX_FILESYSTEM, &object->iface_filesystem);
update_iface (object, action, swapspace_check, swapspace_connect, swapspace_update,
UDISKS_TYPE_LINUX_SWAPSPACE, &object->iface_swapspace);
update_iface (object, action, encrypted_check, encrypted_connect, encrypted_update,
UDISKS_TYPE_LINUX_ENCRYPTED, &object->iface_encrypted);
update_iface (object, action, loop_check, loop_connect, loop_update,
UDISKS_TYPE_LINUX_LOOP, &object->iface_loop);
update_iface (object, action, partition_table_check, partition_table_connect, partition_table_update,
UDISKS_TYPE_LINUX_PARTITION_TABLE, &object->iface_partition_table);
update_iface (object, action, partition_check, partition_connect, partition_update,
UDISKS_TYPE_LINUX_PARTITION, &object->iface_partition);
}
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;
}
/**
* udisks_linux_block_object_reread_partition_table:
* @object: A #UDisksLinuxBlockObject.
*
* Requests the kernel to re-read the partition table for @object.
*
* The events from any change this may cause will bubble up from the
* kernel through the udev stack and will eventually be received by
* the udisks daemon process itself. This method does not wait for the
* event to be received.
*/
void
udisks_linux_block_object_reread_partition_table (UDisksLinuxBlockObject *object)
{
const gchar *device_file;
gint fd;
g_return_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object));
device_file = g_udev_device_get_device_file (object->device->udev_device);
fd = open (device_file, O_RDONLY);
if (fd == -1)
{
udisks_warning ("Error opening %s: %m", device_file);
}
else
{
if (ioctl (fd, BLKRRPART) != 0)
{
udisks_warning ("Error issuing BLKRRPART to %s: %m", device_file);
}
close (fd);
}
}
/**
* udisks_linux_drive_object_is_not_in_use:
* @object: A #UDisksLinuxDriveObject.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: A #GError or %NULL.
*
* Checks if the drive represented by @object is in use and sets
* @error if so.
*
* Returns: %TRUE if @object is not is use, %FALSE if @error is set.
*/
gboolean
udisks_linux_drive_object_is_not_in_use (UDisksLinuxDriveObject *object,
GCancellable *cancellable,
GError **error)
{
GDBusObjectManagerServer *object_manager;
const gchar *drive_object_path;
gboolean ret = TRUE;
GList *objects = NULL;
GList *l;
g_return_val_if_fail (UDISKS_IS_LINUX_DRIVE_OBJECT (object), FALSE);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
drive_object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
object_manager = udisks_daemon_get_object_manager (object->daemon);
objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager));
/* Visit all block devices related to the drive... */
for (l = objects; l != NULL; l = l->next)
{
GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data);
UDisksBlock *block;
UDisksFilesystem *filesystem;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (iter_object))
continue;
block = udisks_object_peek_block (UDISKS_OBJECT (iter_object));
filesystem = udisks_object_peek_filesystem (UDISKS_OBJECT (iter_object));
if (g_strcmp0 (udisks_block_get_drive (block), drive_object_path) != 0)
continue;
/* bail if block device is mounted */
if (filesystem != NULL)
{
if (g_strv_length ((gchar **) udisks_filesystem_get_mount_points (filesystem)) > 0)
{
g_set_error (error,
UDISKS_ERROR,
UDISKS_ERROR_DEVICE_BUSY,
"Device %s is mounted",
udisks_block_get_preferred_device (block));
ret = FALSE;
goto out;
}
}
/* bail if block device is unlocked (LUKS) */
if (is_block_unlocked (objects, g_dbus_object_get_object_path (G_DBUS_OBJECT (iter_object))))
{
g_set_error (error,
UDISKS_ERROR,
UDISKS_ERROR_DEVICE_BUSY,
"Encrypted device %s is unlocked",
udisks_block_get_preferred_device (block));
ret = FALSE;
goto out;
}
}
out:
g_list_free_full (objects, g_object_unref);
return ret;
}
/**
* udisks_linux_block_object_get_device:
* @object: A #UDisksLinuxBlockObject.
*
* Gets the current #UDisksLinuxDevice for @object. Connect to
* #GObject::notify to track changes to the #UDisksLinuxBlockObject:device
* property.
*
* Returns: A #UDisksLinuxDevice. Free with g_object_unref().
*/
UDisksLinuxDevice *
udisks_linux_block_object_get_device (UDisksLinuxBlockObject *object)
{
g_return_val_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object), NULL);
return g_object_ref (object->device);
}
/**
* udisks_linux_block_object_get_daemon:
* @object: A #UDisksLinuxBlockObject.
*
* Gets the daemon used by @object.
*
* Returns: A #UDisksDaemon. Do not free, the object is owned by @object.
*/
UDisksDaemon *
udisks_linux_block_object_get_daemon (UDisksLinuxBlockObject *object)
{
g_return_val_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object), NULL);
return object->daemon;
}
/**
* 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 */
}
