/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* gvfs - extensions for gio
 *
 * Copyright (C) 2006-2009 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Author: David Zeuthen <davidz@redhat.com>
 */

#include <config.h>

#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

#include <glib.h>
#include <glib/gi18n-lib.h>
#include <gio/gio.h>

#include "ggdudrive.h"
#include "ggduvolume.h"
#include "ggdumount.h"

/* for BUFSIZ */
#include <stdio.h>

typedef struct MountOpData MountOpData;

static void cancel_pending_mount_op (MountOpData *data);

static void g_gdu_volume_mount_unix_mount_point (GGduVolume          *volume,
                                                 GMountMountFlags     flags,
                                                 GMountOperation     *mount_operation,
                                                 GCancellable        *cancellable,
                                                 GAsyncReadyCallback  callback,
                                                 gpointer             user_data);

struct _GGduVolume
{
  GObject parent;

  GVolumeMonitor *volume_monitor; /* owned by volume monitor */
  GGduMount      *mount;          /* owned by volume monitor */
  GGduDrive      *drive;          /* owned by volume monitor */

  /* only set if constructed via new() */
  GduVolume *gdu_volume;

  /* only set if constructed via new_for_unix_mount_point() */
  GUnixMountPoint *unix_mount_point;

  /* if the volume is encrypted, this is != NULL when unlocked */
  GduVolume *cleartext_gdu_volume;

  /* If a mount operation is in progress, then pending_mount_op is != NULL. This
   * is used to cancel the operation to make possible authentication dialogs go
   * away.
   */
  MountOpData *pending_mount_op;

  /* the following members need to be set upon construction, see constructors and update_volume() */
  GIcon *icon;
  GFile *activation_root;
  gchar *name;
  gchar *device_file;
  dev_t dev;
  gchar *uuid;
  gboolean can_mount;
  gboolean should_automount;
};

static void g_gdu_volume_volume_iface_init (GVolumeIface *iface);

G_DEFINE_TYPE_EXTENDED (GGduVolume, g_gdu_volume, G_TYPE_OBJECT, 0,
                        G_IMPLEMENT_INTERFACE (G_TYPE_VOLUME,
                                               g_gdu_volume_volume_iface_init))

static void gdu_volume_changed (GduPresentable *presentable,
                                GGduVolume     *volume);
static void gdu_volume_job_changed (GduPresentable *presentable,
                                    GGduVolume     *volume);

static void gdu_cleartext_volume_removed (GduPresentable *presentable,
                                          GGduVolume     *volume);
static void gdu_cleartext_volume_changed (GduPresentable *presentable,
                                          GGduVolume     *volume);
static void gdu_cleartext_volume_job_changed (GduPresentable *presentable,
                                              GGduVolume     *volume);

static void mount_with_mount_operation (MountOpData *data);

static gboolean
g_gdu_drive_device_is_flash(GduDevice *drive_device)
{
  const gchar *drive_media;
  
  if (drive_device == NULL)
    return FALSE;
  
  drive_media = gdu_device_drive_get_media (drive_device);
  return g_str_has_prefix (drive_media, "flash");
}

static void
g_gdu_volume_finalize (GObject *object)
{
  GGduVolume *volume;

  volume = G_GDU_VOLUME (object);

  if (volume->mount != NULL)
    g_gdu_mount_unset_volume (volume->mount, volume);

  if (volume->drive != NULL)
    g_gdu_drive_unset_volume (volume->drive, volume);

  if (volume->gdu_volume != NULL)
    {
      g_signal_handlers_disconnect_by_func (volume->gdu_volume, gdu_volume_changed, volume);
      g_signal_handlers_disconnect_by_func (volume->gdu_volume, gdu_volume_job_changed, volume);
      g_object_unref (volume->gdu_volume);
    }

  if (volume->unix_mount_point != NULL)
    {
      g_unix_mount_point_free (volume->unix_mount_point);
    }

  if (volume->cleartext_gdu_volume != NULL)
    {
      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_removed, volume);
      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_changed, volume);
      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_job_changed, volume);
      g_object_unref (volume->cleartext_gdu_volume);
    }

  if (volume->icon != NULL)
    g_object_unref (volume->icon);
  if (volume->activation_root != NULL)
    g_object_unref (volume->activation_root);

  g_free (volume->name);
  g_free (volume->device_file);
  g_free (volume->uuid);

  if (G_OBJECT_CLASS (g_gdu_volume_parent_class)->finalize)
    (*G_OBJECT_CLASS (g_gdu_volume_parent_class)->finalize) (object);
}

static void
g_gdu_volume_class_init (GGduVolumeClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->finalize = g_gdu_volume_finalize;
}

static void
g_gdu_volume_init (GGduVolume *gdu_volume)
{
}

static void
emit_changed (GGduVolume *volume)
{
  g_signal_emit_by_name (volume, "changed");
  g_signal_emit_by_name (volume->volume_monitor, "volume_changed", volume);
}

static gboolean
update_volume (GGduVolume *volume)
{
  GduDevice *device;
  GduPool *pool = NULL;
  time_t now;
  gboolean changed;
  gboolean old_can_mount;
  gboolean old_should_automount;
  gchar *old_name;
  gchar *old_device_file;
  dev_t old_dev;
  GIcon *old_icon;
  gboolean keep_cleartext_volume;

  /* save old values */
  old_can_mount = volume->can_mount;
  old_should_automount = volume->should_automount;
  old_name = g_strdup (volume->name);
  old_device_file = g_strdup (volume->device_file);
  old_dev = volume->dev;
  old_icon = volume->icon != NULL ? g_object_ref (volume->icon) : NULL;

  /* ---------------------------------------------------------------------------------------------------- */

  /* if the volume is a fstab mount point, get the data from there */
  if (volume->unix_mount_point != NULL)
    {
      struct stat_buf;

      volume->can_mount = TRUE;
      volume->should_automount = FALSE;

      g_free (volume->device_file);
      volume->device_file = g_strdup (g_unix_mount_point_get_device_path (volume->unix_mount_point));
      volume->dev = 0;

      if (volume->icon != NULL)
        g_object_unref (volume->icon);
      if (g_strcmp0 (g_unix_mount_point_get_fs_type (volume->unix_mount_point), "nfs") == 0)
        volume->icon = g_themed_icon_new_with_default_fallbacks ("folder-remote");
      else
        volume->icon = g_unix_mount_point_guess_icon (volume->unix_mount_point);

      g_free (volume->name);
      volume->name = g_unix_mount_point_guess_name (volume->unix_mount_point);

      //volume->can_eject = g_unix_mount_point_guess_can_eject (volume->unix_mount_point);

      goto update_done;
    }

  /* in with the new */
  device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->gdu_volume));
  if (device != NULL)
    pool = gdu_device_get_pool (device);

  keep_cleartext_volume = FALSE;
  if (device != NULL && gdu_device_is_luks (device))
    {
      const gchar *holder_objpath;

      holder_objpath = gdu_device_luks_get_holder (device);
      if (holder_objpath != NULL && g_strcmp0 (holder_objpath, "/") != 0)
        {
          GduDevice *cleartext_device;

          cleartext_device = gdu_pool_get_by_object_path (pool, holder_objpath);
          if (cleartext_device != NULL)
            {
              GduVolume *cleartext_gdu_volume;

              cleartext_gdu_volume = GDU_VOLUME (gdu_pool_get_volume_by_device (pool, cleartext_device));
              if (cleartext_gdu_volume != volume->cleartext_gdu_volume)
                {
                  if (volume->cleartext_gdu_volume != NULL)
                    {
                      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_removed, volume);
                      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_changed, volume);
                      g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_job_changed, volume);
                      g_object_unref (volume->cleartext_gdu_volume);
                    }

                  volume->cleartext_gdu_volume = g_object_ref (cleartext_gdu_volume);
                  g_signal_connect (volume->cleartext_gdu_volume, "removed", G_CALLBACK (gdu_cleartext_volume_removed), volume);
                  g_signal_connect (volume->cleartext_gdu_volume, "changed", G_CALLBACK (gdu_cleartext_volume_changed), volume);
                  g_signal_connect (volume->cleartext_gdu_volume, "job-changed", G_CALLBACK (gdu_cleartext_volume_job_changed), volume);
                }
              g_object_unref (cleartext_gdu_volume);

              g_object_unref (cleartext_device);

              keep_cleartext_volume = TRUE;
            }
        }
    }

  if (!keep_cleartext_volume)
    {
      if (volume->cleartext_gdu_volume != NULL)
        {
          g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_removed, volume);
          g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_changed, volume);
          g_signal_handlers_disconnect_by_func (volume->cleartext_gdu_volume, gdu_cleartext_volume_job_changed, volume);
          g_object_unref (volume->cleartext_gdu_volume);
          volume->cleartext_gdu_volume = NULL;
        }
    }


  /* Use data from cleartext LUKS volume if it is unlocked */
  if (volume->cleartext_gdu_volume != NULL)
    {
      GduDevice *luks_cleartext_volume_device;

      luks_cleartext_volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->cleartext_gdu_volume));

      if (volume->icon != NULL)
        g_object_unref (volume->icon);
      volume->icon = gdu_presentable_get_icon (GDU_PRESENTABLE (volume->cleartext_gdu_volume));

      g_free (volume->name);
      volume->name = gdu_presentable_get_name (GDU_PRESENTABLE (volume->cleartext_gdu_volume));

      g_free (volume->device_file);
      if (luks_cleartext_volume_device != NULL)
        {
          volume->device_file = g_strdup (gdu_device_get_device_file (luks_cleartext_volume_device));
          volume->dev = gdu_device_get_dev (luks_cleartext_volume_device);
        }
      else
        {
          volume->device_file = NULL;
          volume->dev = 0;
        }

      volume->can_mount = TRUE;

      volume->should_automount = FALSE;

      if (luks_cleartext_volume_device != NULL)
        g_object_unref (luks_cleartext_volume_device);
    }
  else
    {
      gchar *activation_uri;

      if (volume->icon != NULL)
        g_object_unref (volume->icon);
      volume->icon = gdu_presentable_get_icon (GDU_PRESENTABLE (volume->gdu_volume));

      g_free (volume->name);
      if (_is_pc_floppy_drive (device))
        volume->name = g_strdup (_("Floppy Disk"));
      else
        volume->name = gdu_presentable_get_name (GDU_PRESENTABLE (volume->gdu_volume));

      /* special case the name and icon for audio discs */
      activation_uri = volume->activation_root != NULL ? g_file_get_uri (volume->activation_root) : NULL;
      if (activation_uri != NULL && g_str_has_prefix (activation_uri, "cdda://"))
        {
          if (volume->icon != NULL)
            g_object_unref (volume->icon);
          volume->icon = g_themed_icon_new_with_default_fallbacks ("media-optical-audio");
          g_free (volume->name);
          volume->name = g_strdup (_("Audio Disc"));
        }

      g_free (volume->device_file);
      if (device != NULL)
        {
          volume->device_file = g_strdup (gdu_device_get_device_file (device));
          volume->dev = gdu_device_get_dev (device);
        }
      else
        {
          volume->device_file = NULL;
          volume->dev = 0;
        }

      volume->can_mount = TRUE;

      /* Only automount filesystems from drives of known types/interconnects:
       *
       *  - USB
       *  - Firewire
       *  - sdio
       *  - optical discs
       *
       * The mantra here is "be careful" - we really don't want to
       * automount fs'es from all devices in a SAN etc - We REALLY
       * need to be CAREFUL here.
       *
       * Sidebar: Actually, a surprisingly large number of admins like
       *          to log into GNOME as root (thus having all polkit
       *          authorizations) and if weren't careful we'd
       *          automount all mountable devices from the box. See
       *          the enterprise distro bug trackers for details.
       */
      volume->should_automount = FALSE;
      if (volume->drive != NULL)
        {
          GduPresentable *drive_presentable;
          drive_presentable = g_gdu_drive_get_presentable (volume->drive);
          if (drive_presentable != NULL)
            {
              GduDevice *drive_device;
              drive_device = gdu_presentable_get_device (drive_presentable);
              if (drive_device != NULL)
                {
                  if (gdu_device_is_drive (drive_device))
                    {
                      const gchar *connection_interface;

                      connection_interface = gdu_device_drive_get_connection_interface (drive_device);

                      if (g_strcmp0 (connection_interface, "usb") == 0 ||
                          g_strcmp0 (connection_interface, "firewire") == 0 ||
                          g_strcmp0 (connection_interface, "sdio") == 0 ||
                          g_gdu_drive_device_is_flash (drive_device) ||
                          gdu_device_is_optical_disc (drive_device))
                        {
                          volume->should_automount = TRUE;
                        }
                    }
                  g_object_unref (drive_device);
                }
            }

          /* If a volume (partition) appear _much later_ than when media was inserted it
           * can only be because the media was repartitioned. We don't want to automount
           * such volumes.
           */
          now = time (NULL);
          if (now - g_gdu_drive_get_time_of_last_media_insertion (volume->drive) > 5)
            volume->should_automount = FALSE;
        }

      /* Respect the presentation hint for whether the volume should be automounted - normally
       * nopolicy is only FALSE for "physical" devices - e.g. only "physical" devices will
       * be set to be automounted.
       */
      if (device != NULL && gdu_device_get_presentation_nopolicy (device))
        volume->should_automount = FALSE;

      g_free (activation_uri);
    }

  /* if there's an automount hint, use it */
  if (device != NULL)
    {
      if (g_strcmp0 (gdu_device_get_automount_hint (device), "always") == 0)
        volume->should_automount = TRUE;
      else if (g_strcmp0 (gdu_device_get_automount_hint (device), "never") == 0)
        volume->should_automount = FALSE;
    }

  if (pool != NULL)
    g_object_unref (pool);
  if (device != NULL)
    g_object_unref (device);

  /* ---------------------------------------------------------------------------------------------------- */

 update_done:

  /* compute whether something changed */
  changed = !((old_can_mount == volume->can_mount) &&
              (old_should_automount == volume->should_automount) &&
              (g_strcmp0 (old_name, volume->name) == 0) &&
              (g_strcmp0 (old_device_file, volume->device_file) == 0) &&
              (old_dev == volume->dev) &&
              g_icon_equal (old_icon, volume->icon)
              );

  /* free old values */
  g_free (old_name);
  g_free (old_device_file);
  if (old_icon != NULL)
    g_object_unref (old_icon);

  /*g_debug ("in update_volume(), changed=%d", changed);*/

  return changed;
}

static void
gdu_volume_changed (GduPresentable *presentable,
                    GGduVolume     *volume)
{
  /*g_debug ("volume: presentable_changed: %p: %s", volume, gdu_presentable_get_id (GDU_PRESENTABLE (presentable)));*/
  if (update_volume (volume))
    emit_changed (volume);
}

static void
gdu_volume_job_changed (GduPresentable *presentable,
                        GGduVolume     *volume)
{
  /*g_debug ("volume: presentable_job_changed %p: %s", volume, gdu_presentable_get_id (GDU_PRESENTABLE (presentable)));*/
  if (update_volume (volume))
    emit_changed (volume);
}

static void
gdu_cleartext_volume_removed (GduPresentable *presentable,
                              GGduVolume     *volume)
{
  /*g_debug ("cleartext volume: presentable_removed: %p: %s", volume, gdu_presentable_get_id (GDU_PRESENTABLE (presentable)));*/
  if (update_volume (volume))
    emit_changed (volume);
}

static void
gdu_cleartext_volume_changed (GduPresentable *presentable,
                              GGduVolume     *volume)
{
  /*g_debug ("cleartext volume: presentable_changed: %p: %s", volume, gdu_presentable_get_id (GDU_PRESENTABLE (presentable)));*/
  if (update_volume (volume))
    emit_changed (volume);
}

static void
gdu_cleartext_volume_job_changed (GduPresentable *presentable,
                                  GGduVolume     *volume)
{
  /*g_debug ("cleartext volume: presentable_job_changed %p: %s", volume, gdu_presentable_get_id (GDU_PRESENTABLE (presentable)));*/
  if (update_volume (volume))
    emit_changed (volume);
}

GGduVolume *
g_gdu_volume_new_for_unix_mount_point (GVolumeMonitor   *volume_monitor,
                                       GUnixMountPoint  *unix_mount_point)
{
  GGduVolume *volume;

  volume = g_object_new (G_TYPE_GDU_VOLUME, NULL);
  volume->volume_monitor = volume_monitor;
  g_object_add_weak_pointer (G_OBJECT (volume_monitor), (gpointer) &(volume->volume_monitor));

  volume->unix_mount_point = unix_mount_point;

  update_volume (volume);

  return volume;
}

GGduVolume *
g_gdu_volume_new (GVolumeMonitor   *volume_monitor,
                  GduVolume        *gdu_volume,
                  GGduDrive        *drive,
                  GFile            *activation_root)
{
  GGduVolume *volume;

  volume = g_object_new (G_TYPE_GDU_VOLUME, NULL);
  volume->volume_monitor = volume_monitor;
  g_object_add_weak_pointer (G_OBJECT (volume_monitor), (gpointer) &(volume->volume_monitor));

  volume->gdu_volume = g_object_ref (gdu_volume);
  volume->activation_root = activation_root != NULL ? g_object_ref (activation_root) : NULL;

  g_signal_connect (volume->gdu_volume, "changed", G_CALLBACK (gdu_volume_changed), volume);
  g_signal_connect (volume->gdu_volume, "job-changed", G_CALLBACK (gdu_volume_job_changed), volume);

  volume->drive = drive;
  if (drive != NULL)
    g_gdu_drive_set_volume (drive, volume);

  update_volume (volume);

  return volume;
}

void
g_gdu_volume_removed (GGduVolume *volume)
{
  if (volume->pending_mount_op != NULL)
    cancel_pending_mount_op (volume->pending_mount_op);

  if (volume->mount != NULL)
    {
      g_gdu_mount_unset_volume (volume->mount, volume);
      volume->mount = NULL;
    }

  if (volume->drive != NULL)
    {
      g_gdu_drive_unset_volume (volume->drive, volume);
      volume->drive = NULL;
    }
}

void
g_gdu_volume_set_mount (GGduVolume  *volume,
                        GGduMount *mount)
{
  if (volume->mount != mount)
    {

      if (volume->mount != NULL)
        g_gdu_mount_unset_volume (volume->mount, volume);

      volume->mount = mount;

      emit_changed (volume);
    }
}

void
g_gdu_volume_unset_mount (GGduVolume  *volume,
                          GGduMount *mount)
{
  if (volume->mount == mount)
    {
      volume->mount = NULL;
      emit_changed (volume);
    }
}

void
g_gdu_volume_set_drive (GGduVolume  *volume,
                        GGduDrive *drive)
{
  if (volume->drive != drive)
    {
      if (volume->drive != NULL)
        g_gdu_drive_unset_volume (volume->drive, volume);

      volume->drive = drive;

      emit_changed (volume);
    }
}

void
g_gdu_volume_unset_drive (GGduVolume  *volume,
                          GGduDrive *drive)
{
  if (volume->drive == drive)
    {
      volume->drive = NULL;
      emit_changed (volume);
    }
}

static GIcon *
g_gdu_volume_get_icon (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return volume->icon != NULL ? g_object_ref (volume->icon) : NULL;
}

static char *
g_gdu_volume_get_name (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return g_strdup (volume->name);
}

static char *
g_gdu_volume_get_uuid (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return g_strdup (volume->uuid);
}

static gboolean
g_gdu_volume_can_mount (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return volume->can_mount;
}

static gboolean
g_gdu_volume_can_eject (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  gboolean can_eject;

  can_eject = FALSE;
  if (volume->drive != NULL)
    can_eject = g_drive_can_eject (G_DRIVE (volume->drive));

  return can_eject;
}

static gboolean
g_gdu_volume_should_automount (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return volume->should_automount;
}

static GDrive *
g_gdu_volume_get_drive (GVolume *volume)
{
  GGduVolume *gdu_volume = G_GDU_VOLUME (volume);
  GDrive *drive;

  drive = NULL;
  if (gdu_volume->drive != NULL)
    drive = g_object_ref (gdu_volume->drive);

  return drive;
}

static GMount *
g_gdu_volume_get_mount (GVolume *volume)
{
  GGduVolume *gdu_volume = G_GDU_VOLUME (volume);
  GMount *mount;

  mount = NULL;
  if (gdu_volume->mount != NULL)
    mount = g_object_ref (gdu_volume->mount);

  return mount;
}

/* ---------------------------------------------------------------------------------------------------- */

static gchar **
get_mount_options (GduDevice *device,
                   gboolean   allow_user_interaction)
{
  GPtrArray *p;

  p = g_ptr_array_new ();

  /* one day we might read this from user settings */
  if (g_strcmp0 (gdu_device_id_get_usage (device), "filesystem") == 0 &&
      g_strcmp0 (gdu_device_id_get_type (device), "vfat") == 0)
    {
      g_ptr_array_add (p, g_strdup ("flush"));
    }

  if (!allow_user_interaction)
    {
      g_ptr_array_add (p, g_strdup ("auth_no_user_interaction"));
    }

  g_ptr_array_add (p, NULL);

  return (gchar **) g_ptr_array_free (p, FALSE);
}

/* ---------------------------------------------------------------------------------------------------- */

struct MountOpData
{
  GGduVolume *volume;
  GduDevice *device_to_mount;
  GSimpleAsyncResult *simple;
  GCancellable *cancellable;
  gulong cancelled_handler_id;

  GMountOperation *mount_operation;
  gulong mount_operation_reply_handler_id;

  gboolean is_cancelled;
};

static void
mount_op_data_unref (MountOpData *data)
{
  g_object_unref (data->volume);
  if (data->device_to_mount != NULL)
    g_object_unref (data->device_to_mount);
  g_object_unref (data->simple);
  if (data->cancelled_handler_id != 0)
    g_signal_handler_disconnect (data->cancellable, data->cancelled_handler_id);
  if (data->cancellable != NULL)
    g_object_unref (data->cancellable);
  if (data->mount_operation_reply_handler_id != 0)
    g_signal_handler_disconnect (data->mount_operation, data->mount_operation_reply_handler_id);
  if (data->mount_operation != NULL)
    g_object_unref (data->mount_operation);
  g_free (data);
}

static void
cancel_pending_mount_op (MountOpData *data)
{
  /* we are no longer pending */
  data->volume->pending_mount_op = NULL;

  data->is_cancelled = TRUE;

  /* send an ::aborted signal to make the dialog go away */
  if (data->mount_operation != NULL)
    g_signal_emit_by_name (data->mount_operation, "aborted");

  /* complete the operation (sends reply to caller) */
  g_simple_async_result_set_error (data->simple,
                                   G_IO_ERROR,
                                   G_IO_ERROR_FAILED_HANDLED,
                                   "Operation was cancelled");
  g_simple_async_result_complete (data->simple);
}

static void
mount_cb (GduDevice *device,
          gchar     *mount_point,
          GError    *error,
          gpointer   user_data)
{
  MountOpData *data = user_data;

  /* if we've already aborted due to device removal / cancellation, just bail out */
  if (data->is_cancelled)
    goto bailout;

  if (error != NULL)
    {
      /* be quiet if the DeviceKit-disks daemon is inhibited */
      if (error->code == GDU_ERROR_INHIBITED)
        {
          error->domain = G_IO_ERROR;
          error->code = G_IO_ERROR_FAILED_HANDLED;
        }
      g_simple_async_result_set_from_error (data->simple, error);
      g_error_free (error);
    }
  else
    {
      g_free (mount_point);
    }

  g_simple_async_result_complete (data->simple);

 bailout:
  data->volume->pending_mount_op = NULL;
  mount_op_data_unref (data);

}

static void
mount_cleartext_device (MountOpData *data,
                        const gchar *object_path_of_cleartext_device)
{
  GduPool *pool;

  /* if we've already aborted due to device removal / cancellation, just bail out */
  if (data->is_cancelled)
    {
      mount_op_data_unref (data);
      goto bailout;
    }

  pool = gdu_presentable_get_pool (GDU_PRESENTABLE (data->volume->gdu_volume));

  data->device_to_mount = gdu_pool_get_by_object_path (pool, object_path_of_cleartext_device);
  if (data->device_to_mount == NULL)
    {
      g_simple_async_result_set_error (data->simple,
                                       G_IO_ERROR,
                                       G_IO_ERROR_FAILED,
                                       "Successfully unlocked encrypted volume but cleartext device does not exist");
      g_simple_async_result_complete (data->simple);
      data->volume->pending_mount_op = NULL;
      mount_op_data_unref (data);
    }
  else
    {
      gchar **mount_options;
      mount_options = get_mount_options (data->device_to_mount, data->mount_operation != NULL);
      gdu_device_op_filesystem_mount (data->device_to_mount, mount_options, mount_cb, data);
      g_strfreev (mount_options);
    }

  g_object_unref (pool);

 bailout:
  ;
}

static void
unlock_from_keyring_cb (GduDevice  *device,
                        char       *object_path_of_cleartext_device,
                        GError     *error,
                        gpointer    user_data)
{
  MountOpData *data = user_data;

  /* if we've already aborted due to device removal / cancellation, just bail out */
  if (data->is_cancelled)
    {
      mount_op_data_unref (data);
      goto bailout;
    }

  if (error != NULL)
    {
      /*g_debug ("keyring password didn't work: %s", error->message);*/

      /* The password we retrieved from the keyring didn't work. So go ahead and prompt
       * the user.
       */
      mount_with_mount_operation (data);

      g_error_free (error);
    }
  else
    {
      mount_cleartext_device (data, object_path_of_cleartext_device);
      g_free (object_path_of_cleartext_device);
    }

 bailout:
  ;
}

static void
unlock_cb (GduDevice  *device,
           gchar      *object_path_of_cleartext_device,
           GError     *error,
           gpointer    user_data)
{
  MountOpData *data = user_data;

  /* if we've already aborted due to device removal / cancellation, just bail out */
  if (data->is_cancelled)
    {
      mount_op_data_unref (data);
      goto bailout;
    }

  if (error != NULL)
    {
      /* be quiet if the daemon is inhibited */
      if (error->code == GDU_ERROR_INHIBITED)
        {
          error->domain = G_IO_ERROR;
          error->code = G_IO_ERROR_FAILED_HANDLED;
        }
      g_simple_async_result_set_from_error (data->simple, error);
      g_error_free (error);
      g_simple_async_result_complete (data->simple);
      data->volume->pending_mount_op = NULL;
      mount_op_data_unref (data);
    }
  else
    {
      GPasswordSave password_save;
      const gchar *password;

      password_save = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (device), "password-save"));
      password = g_object_get_data (G_OBJECT (device), "password");

      if (password != NULL)
        {
          switch (password_save)
            {
            case G_PASSWORD_SAVE_FOR_SESSION:
              gdu_util_save_secret (device, password, TRUE);
              break;

            case G_PASSWORD_SAVE_PERMANENTLY:
              gdu_util_save_secret (device, password, FALSE);
              break;

            default:
              /* do nothing */
              break;
            }
        }

      /* now we have a cleartext device; update the GVolume details to show that */
      if (update_volume (data->volume))
        emit_changed (data->volume);

      mount_cleartext_device (data, object_path_of_cleartext_device);
      g_free (object_path_of_cleartext_device);
    }

 bailout:

  /* scrub the password */
  g_object_set_data (G_OBJECT (device), "password-save", NULL);
  g_object_set_data (G_OBJECT (device), "password", NULL);
}

static void
scrub_n_free_string (char *password)
{
  memset (password, '\0', strlen (password));
  g_free (password);
}

static void
mount_operation_reply (GMountOperation       *mount_operation,
                       GMountOperationResult result,
                       gpointer              user_data)
{
  MountOpData *data = user_data;
  GduDevice *device;
  const gchar *password;

  /* if we've already aborted due to device removal, just bail out */
  if (data->is_cancelled)
    {
      mount_op_data_unref (data);
      goto out;
    }

  /* we got what we wanted; don't listen to any other signals from the mount operation */
  if (data->mount_operation_reply_handler_id != 0)
    {
      g_signal_handler_disconnect (data->mount_operation, data->mount_operation_reply_handler_id);
      data->mount_operation_reply_handler_id = 0;
    }

  if (result != G_MOUNT_OPERATION_HANDLED)
    {
      if (result == G_MOUNT_OPERATION_ABORTED)
        {
          /* The user aborted the operation so consider it "handled" */
          g_simple_async_result_set_error (data->simple,
                                           G_IO_ERROR,
                                           G_IO_ERROR_FAILED_HANDLED,
                                           "Password dialog aborted (user should never see this error since it is G_IO_ERROR_FAILED_HANDLED)");
        }
      else
        {
          g_simple_async_result_set_error (data->simple,
                                           G_IO_ERROR,
                                           G_IO_ERROR_PERMISSION_DENIED,
                                           "Expected G_MOUNT_OPERATION_HANDLED but got %d", result);
        }
      g_simple_async_result_complete (data->simple);
      data->volume->pending_mount_op = NULL;
      mount_op_data_unref (data);
      goto out;
    }

  password = g_mount_operation_get_password (mount_operation);

  device = gdu_presentable_get_device (GDU_PRESENTABLE (data->volume->gdu_volume));

  g_object_set_data (G_OBJECT (device),
                     "password-save",
                     GINT_TO_POINTER (g_mount_operation_get_password_save (mount_operation)));
  g_object_set_data_full (G_OBJECT (device),
                          "password",
                          g_strdup (password),
                          (GDestroyNotify) scrub_n_free_string);

  gdu_device_op_luks_unlock (device, password, unlock_cb, data);

  g_object_unref (device);

 out:
  ;
}

static void
mount_with_mount_operation (MountOpData *data)
{
  gchar *message;
  gchar *drive_name;
  GduPresentable *toplevel;
  GduDevice *device;

  device = NULL;
  drive_name = NULL;
  message = NULL;
  toplevel = NULL;

  /* if we've already aborted due to device removal, just bail out */
  if (data->is_cancelled)
    {
      mount_op_data_unref (data);
      goto out;
    }

  if (data->mount_operation == NULL)
    {
      g_simple_async_result_set_error (data->simple,
                                       G_IO_ERROR,
                                       G_IO_ERROR_FAILED,
                                       "Password required to access the encrypted data");
      g_simple_async_result_complete (data->simple);
      data->volume->pending_mount_op = NULL;
      mount_op_data_unref (data);
      goto out;
    }

  device = gdu_presentable_get_device (GDU_PRESENTABLE (data->volume->gdu_volume));

  toplevel = gdu_presentable_get_enclosing_presentable (GDU_PRESENTABLE (data->volume->gdu_volume));
  /* handle logical partitions enclosed by an extented partition */
  if (GDU_IS_VOLUME (toplevel))
    {
      GduPresentable *temp;
      temp = toplevel;
      toplevel = gdu_presentable_get_enclosing_presentable (toplevel);
      g_object_unref (temp);
      if (!GDU_IS_DRIVE (toplevel))
        {
          g_object_unref (toplevel);
          toplevel = NULL;
        }
    }

  if (toplevel != NULL)
    drive_name = gdu_presentable_get_name (toplevel);

  if (drive_name != NULL)
    {
      if (gdu_device_is_partition (device))
        {
          message = g_strdup_printf (_("Enter a password to unlock the volume\n"
                                       "The device \"%s\" contains encrypted data on partition %d."),
                                     drive_name,
                                     gdu_device_partition_get_number (device));
        }
      else
        {
          message = g_strdup_printf (_("Enter a password to unlock the volume\n"
                                       "The device \"%s\" contains encrypted data."),
                                     drive_name);
        }
    }
  else
    {
      message = g_strdup_printf (_("Enter a password to unlock the volume\n"
                                   "The device %s contains encrypted data."),
                                 gdu_device_get_device_file (device));
    }

  data->mount_operation_reply_handler_id = g_signal_connect (data->mount_operation,
                                                             "reply",
                                                             G_CALLBACK (mount_operation_reply),
                                                             data);

  g_signal_emit_by_name (data->mount_operation,
                         "ask-password",
                         message,
                         NULL,
                         NULL,
                         G_ASK_PASSWORD_NEED_PASSWORD |
                         G_ASK_PASSWORD_SAVING_SUPPORTED);

 out:
  g_free (drive_name);
  g_free (message);
  if (device != NULL)
    g_object_unref (device);
  if (toplevel != NULL)
    g_object_unref (toplevel);
}

static void
cancelled_cb (GCancellable *cancellable,
              GGduVolume   *volume)
{
  if (volume->pending_mount_op != NULL)
    {
      cancel_pending_mount_op (volume->pending_mount_op);
    }
}

static void
g_gdu_volume_mount (GVolume             *_volume,
                    GMountMountFlags     flags,
                    GMountOperation     *mount_operation,
                    GCancellable        *cancellable,
                    GAsyncReadyCallback  callback,
                    gpointer             user_data)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  GSimpleAsyncResult *simple;
  GduDevice *device;
  GduPool *pool;
  const gchar *usage;
  const gchar *type;
  MountOpData *data;

  pool = NULL;
  device = NULL;

  /* for fstab mounts, call the native mount command */
  if (volume->unix_mount_point != NULL)
    {
      g_gdu_volume_mount_unix_mount_point (volume,
                                           flags,
                                           mount_operation,
                                           cancellable,
                                           callback,
                                           user_data);
      goto out;
    }

  if (volume->pending_mount_op != NULL)
    {
      simple = g_simple_async_result_new_error (G_OBJECT (volume),
                                                callback,
                                                user_data,
                                                G_IO_ERROR,
                                                G_IO_ERROR_FAILED,
                                                "A mount operation is already pending");
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
      goto out;
    }

  device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->gdu_volume));

  if (device == NULL)
    {
      simple = g_simple_async_result_new_error (G_OBJECT (volume),
                                                callback,
                                                user_data,
                                                G_IO_ERROR,
                                                G_IO_ERROR_FAILED,
                                                "Underlying device missing");
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
      goto out;
    }

  pool = gdu_device_get_pool (device);

  /* Makes no sense to mount
   *
   *  - blank discs since these already have a burn:/// mount
   *  - other things that are already mounted
   *
   * Unfortunately Nautilus will try to do this anyway. For now, just return success for
   * such requests.
   */
  if (gdu_device_optical_disc_get_is_blank (device) || gdu_device_is_mounted (device))
    {
      simple = g_simple_async_result_new (G_OBJECT (volume),
                                          callback,
                                          user_data,
                                          g_gdu_volume_mount);
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
      goto out;
    }

  data = g_new0 (MountOpData, 1);

  data->volume = g_object_ref (volume);

  data->simple = g_simple_async_result_new (G_OBJECT (volume),
                                            callback,
                                            user_data,
                                            g_gdu_volume_mount);

  data->cancellable = cancellable != NULL ? g_object_ref (cancellable) : NULL;

  data->mount_operation = mount_operation != NULL ? g_object_ref (mount_operation) : NULL;

  if (data->cancellable != NULL)
    data->cancelled_handler_id = g_signal_connect (data->cancellable, "cancelled", G_CALLBACK (cancelled_cb), volume);

  volume->pending_mount_op = data;

  /* if the device is already unlocked, just attempt to mount it */
  if (volume->cleartext_gdu_volume != NULL)
    {
      GduDevice *luks_cleartext_volume_device;
      const gchar *object_path_of_cleartext_device;

      luks_cleartext_volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->cleartext_gdu_volume));

      if (luks_cleartext_volume_device != NULL)
        {
          object_path_of_cleartext_device = gdu_device_get_object_path (luks_cleartext_volume_device);

          mount_cleartext_device (data, object_path_of_cleartext_device);

          g_object_unref (luks_cleartext_volume_device);
        }
      goto out;
    }

  usage = gdu_device_id_get_usage (device);
  type = gdu_device_id_get_type (device);
  if (g_strcmp0 (usage, "crypto") == 0 && g_strcmp0 (type, "crypto_LUKS") == 0)
    {
      gchar *password;

      /* if we have the secret in the keyring, try with that first */
      password = gdu_util_get_secret (device);
      if (password != NULL)
        {
          gdu_device_op_luks_unlock (device, password, unlock_from_keyring_cb, data);

          scrub_n_free_string (password);
          goto out;
        }

      /* don't put up a password dialog if the daemon is inhibited */
      if (gdu_pool_is_daemon_inhibited (pool))
        {
          g_simple_async_result_set_error (data->simple,
                                           G_IO_ERROR,
                                           G_IO_ERROR_FAILED_HANDLED,
                                           "Daemon is currently inhibited");
          g_simple_async_result_complete (data->simple);
          volume->pending_mount_op = NULL;
          mount_op_data_unref (data);
          goto out;
        }

      mount_with_mount_operation (data);
    }
  else
    {
      gchar **mount_options;
      data->device_to_mount = g_object_ref (device);
      mount_options = get_mount_options (data->device_to_mount, data->mount_operation != NULL);
      gdu_device_op_filesystem_mount (data->device_to_mount, mount_options, mount_cb, data);
      g_strfreev (mount_options);
    }

 out:
  if (pool != NULL)
    g_object_unref (pool);
  if (device != NULL)
    g_object_unref (device);
}

static gboolean
g_gdu_volume_mount_finish (GVolume       *volume,
                           GAsyncResult  *result,
                           GError       **error)
{
  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);

  //g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_gdu_volume_mount);

  return !g_simple_async_result_propagate_error (simple, error);
}

/* ---------------------------------------------------------------------------------------------------- */

typedef struct {
  GGduVolume *volume;
  GAsyncReadyCallback callback;
  gpointer user_data;
  GCancellable *cancellable;
  int error_fd;
  GIOChannel *error_channel;
  guint error_channel_source_id;
  GString *error_string;

  guint wait_for_mount_timeout_id;
  gulong wait_for_mount_changed_signal_handler_id;
} MountPointOp;

static void
mount_point_op_free (MountPointOp *data)
{
  if (data->error_channel_source_id > 0)
    g_source_remove (data->error_channel_source_id);
  if (data->error_channel != NULL)
    g_io_channel_unref (data->error_channel);
  if (data->error_string != NULL)
    g_string_free (data->error_string, TRUE);
  if (data->error_fd > 0)
    close (data->error_fd);
  g_free (data);
}

static void
mount_point_op_changed_cb (GVolume *volume,
                           gpointer user_data)
{
  MountPointOp *data = user_data;
  GSimpleAsyncResult *simple;

  /* keep waiting if the mount hasn't appeared */
  if (data->volume->mount == NULL)
    goto out;

  simple = g_simple_async_result_new (G_OBJECT (data->volume),
                                      data->callback,
                                      data->user_data,
                                      NULL);
  /* complete in idle to make sure the mount is added before we return */
  g_simple_async_result_complete_in_idle (simple);
  g_object_unref (simple);

  g_signal_handler_disconnect (data->volume, data->wait_for_mount_changed_signal_handler_id);
  g_source_remove (data->wait_for_mount_timeout_id);

  mount_point_op_free (data);

 out:
  ;
}

static gboolean
mount_point_op_never_appeared_cb (gpointer user_data)
{
  MountPointOp *data = user_data;
  GSimpleAsyncResult *simple;

  simple = g_simple_async_result_new_error (G_OBJECT (data->volume),
                                            data->callback,
                                            data->user_data,
                                            G_IO_ERROR,
                                            G_IO_ERROR_FAILED,
                                            "Timeout waiting for mount to appear");
  g_simple_async_result_complete (simple);
  g_object_unref (simple);

  g_signal_handler_disconnect (data->volume, data->wait_for_mount_changed_signal_handler_id);
  g_source_remove (data->wait_for_mount_timeout_id);

  mount_point_op_free (data);

  return FALSE;
}

static void
mount_point_op_cb (GPid pid, gint status, gpointer user_data)
{
  MountPointOp *data = user_data;
  GSimpleAsyncResult *simple;

  g_spawn_close_pid (pid);

  if (WEXITSTATUS (status) != 0)
    {
      GError *error;
      error = g_error_new_literal (G_IO_ERROR,
                                   G_IO_ERROR_FAILED,
                                   data->error_string->str);
      simple = g_simple_async_result_new_from_error (G_OBJECT (data->volume),
                                                     data->callback,
                                                     data->user_data,
                                                     error);
      g_error_free (error);
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
      mount_point_op_free (data);
    }
  else
    {
      /* wait for the GMount to appear - this is to honor this requirement
       *
       *  "If the mount operation succeeded, g_volume_get_mount() on
       *   volume is guaranteed to return the mount right after calling
       *   this function; there's no need to listen for the
       *   'mount-added' signal on GVolumeMonitor."
       *
       * So we set up a signal handler waiting for it to appear. We also set up
       * a timer for handling the case when it never appears.
       */
      if (data->volume->mount == NULL)
        {
          /* no need to ref, GSimpleAsyncResult has a ref on data->volume */
          data->wait_for_mount_timeout_id = g_timeout_add (5 * 1000,
                                            mount_point_op_never_appeared_cb,
                                            data);
          data->wait_for_mount_changed_signal_handler_id = g_signal_connect (data->volume,
                                                                             "changed",
                                                                             G_CALLBACK (mount_point_op_changed_cb),
                                                                             data);
        }
      else
        {
          /* have the mount already, finish up */
          simple = g_simple_async_result_new (G_OBJECT (data->volume),
                                              data->callback,
                                              data->user_data,
                                              NULL);
          g_simple_async_result_complete (simple);
          g_object_unref (simple);
          mount_point_op_free (data);
        }
    }
}

static gboolean
mount_point_op_read_error (GIOChannel *channel,
                           GIOCondition condition,
                           gpointer user_data)
{
  MountPointOp *data = user_data;
  gchar buf[BUFSIZ];
  gsize bytes_read;
  GError *error;
  GIOStatus status;

  error = NULL;
read:
  status = g_io_channel_read_chars (channel, buf, sizeof (buf), &bytes_read, &error);
  if (status == G_IO_STATUS_NORMAL)
   {
     g_string_append_len (data->error_string, buf, bytes_read);
     if (bytes_read == sizeof (buf))
        goto read;
   }
  else if (status == G_IO_STATUS_EOF)
    {
      g_string_append_len (data->error_string, buf, bytes_read);
    }
  else if (status == G_IO_STATUS_ERROR)
    {
      if (data->error_string->len > 0)
        g_string_append (data->error_string, "\n");

      g_string_append (data->error_string, error->message);
      g_error_free (error);
      return FALSE;
    }

  return TRUE;
}

static void
g_gdu_volume_mount_unix_mount_point (GGduVolume          *volume,
                                     GMountMountFlags     flags,
                                     GMountOperation     *mount_operation,
                                     GCancellable        *cancellable,
                                     GAsyncReadyCallback  callback,
                                     gpointer             user_data)
{
  MountPointOp *data;
  GPid child_pid;
  GError *error;
  const gchar *argv[] = {"mount", NULL, NULL};

  argv[1] = g_unix_mount_point_get_mount_path (volume->unix_mount_point);

  data = g_new0 (MountPointOp, 1);
  data->volume = volume;
  data->callback = callback;
  data->user_data = user_data;
  data->cancellable = cancellable;

  error = NULL;
  if (!g_spawn_async_with_pipes (NULL,         /* working dir */
                                 (gchar **) argv,
                                 NULL,         /* envp */
                                 G_SPAWN_DO_NOT_REAP_CHILD|G_SPAWN_SEARCH_PATH,
                                 NULL,         /* child_setup */
                                 NULL,         /* user_data for child_setup */
                                 &child_pid,
                                 NULL,         /* standard_input */
                                 NULL,         /* standard_output */
                                 &(data->error_fd),
                                 &error))
    {
      g_assert (error != NULL);
      goto handle_error;
    }

  data->error_string = g_string_new ("");

  data->error_channel = g_io_channel_unix_new (data->error_fd);
  g_io_channel_set_flags (data->error_channel, G_IO_FLAG_NONBLOCK, &error);
  if (error != NULL)
    goto handle_error;

  data->error_channel_source_id = g_io_add_watch (data->error_channel, G_IO_IN, mount_point_op_read_error, data);
  g_child_watch_add (child_pid, mount_point_op_cb, data);

handle_error:
  if (error != NULL)
    {
      GSimpleAsyncResult *simple;
      simple = g_simple_async_result_new_from_error (G_OBJECT (data->volume),
                                                     data->callback,
                                                     data->user_data,
                                                     error);
      g_simple_async_result_complete (simple);
      g_object_unref (simple);

      mount_point_op_free (data);
    }
}

/* ---------------------------------------------------------------------------------------------------- */

typedef struct {
  GObject *object;
  GAsyncReadyCallback callback;
  gpointer user_data;
} EjectWrapperOp;

static void
eject_wrapper_callback (GObject *source_object,
                        GAsyncResult *res,
                        gpointer user_data)
{
  EjectWrapperOp *data  = user_data;
  data->callback (data->object, res, data->user_data);
  g_object_unref (data->object);
  g_free (data);
}

static void
g_gdu_volume_eject_with_operation (GVolume              *volume,
                                   GMountUnmountFlags   flags,
                                   GMountOperation     *mount_operation,
                                   GCancellable        *cancellable,
                                   GAsyncReadyCallback  callback,
                                   gpointer             user_data)
{
  GGduVolume *gdu_volume = G_GDU_VOLUME (volume);
  GGduDrive *drive;

  drive = NULL;
  if (gdu_volume->drive != NULL)
    drive = g_object_ref (gdu_volume->drive);

  if (drive != NULL)
    {
      EjectWrapperOp *data;
      data = g_new0 (EjectWrapperOp, 1);
      data->object = g_object_ref (volume);
      data->callback = callback;
      data->user_data = user_data;
      g_drive_eject_with_operation (G_DRIVE (drive), flags, mount_operation, cancellable, eject_wrapper_callback, data);
      g_object_unref (drive);
    }
  else
    {
      GSimpleAsyncResult *simple;
      simple = g_simple_async_result_new_error (G_OBJECT (volume),
                                                callback,
                                                user_data,
                                                G_IO_ERROR,
                                                G_IO_ERROR_FAILED,
                                                _("Operation not supported by backend"));
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
    }
}

static gboolean
g_gdu_volume_eject_with_operation_finish (GVolume        *volume,
                                          GAsyncResult  *result,
                                          GError       **error)
{
  GGduVolume *gdu_volume = G_GDU_VOLUME (volume);
  gboolean res;

  res = TRUE;
  if (gdu_volume->drive != NULL)
    {
      res = g_drive_eject_with_operation_finish (G_DRIVE (gdu_volume->drive), result, error);
    }
  else
    {
      g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error);
      res = FALSE;
    }

  return res;
}

static void
g_gdu_volume_eject (GVolume              *volume,
                    GMountUnmountFlags   flags,
                    GCancellable        *cancellable,
                    GAsyncReadyCallback  callback,
                    gpointer             user_data)
{
  g_gdu_volume_eject_with_operation (volume, flags, NULL, cancellable, callback, user_data);
}

static gboolean
g_gdu_volume_eject_finish (GVolume        *volume,
                           GAsyncResult  *result,
                           GError       **error)
{
  return g_gdu_volume_eject_with_operation_finish (volume, result, error);
}

static char *
g_gdu_volume_get_identifier (GVolume     *_volume,
                             const char  *kind)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  GduDevice *device;
  const gchar *label;
  const gchar *uuid;
  gchar *id;

  id = NULL;

  if (volume->gdu_volume != NULL)
    {
      device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->gdu_volume));

      if (device != NULL)
        {
          label = gdu_device_id_get_label (device);
          uuid = gdu_device_id_get_uuid (device);

          g_object_unref (device);

          if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == 0)
            id = g_strdup (volume->device_file);
          else if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_LABEL) == 0)
            id = strlen (label) > 0 ? g_strdup (label) : NULL;
          else if (strcmp (kind, G_VOLUME_IDENTIFIER_KIND_UUID) == 0)
            id = strlen (uuid) > 0 ? g_strdup (uuid) : NULL;
        }
    }

  return id;
}

static char **
g_gdu_volume_enumerate_identifiers (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  GduDevice *device;
  GPtrArray *p;
  const gchar *label;
  const gchar *uuid;

  p = g_ptr_array_new ();
  label = NULL;

  if (volume->gdu_volume != NULL)
    {
      device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->gdu_volume));

      if (device != NULL)
        {
          label = gdu_device_id_get_label (device);
          uuid = gdu_device_id_get_uuid (device);
          g_object_unref (device);

          g_ptr_array_add (p, g_strdup (G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
          if (strlen (label) > 0)
            g_ptr_array_add (p, g_strdup (G_VOLUME_IDENTIFIER_KIND_LABEL));
          if (strlen (uuid) > 0)
            g_ptr_array_add (p, g_strdup (G_VOLUME_IDENTIFIER_KIND_UUID));
        }
    }

  g_ptr_array_add (p, NULL);

  return (gchar **) g_ptr_array_free (p, FALSE);
}

static GFile *
g_gdu_volume_get_activation_root (GVolume *_volume)
{
  GGduVolume *volume = G_GDU_VOLUME (_volume);
  return volume->activation_root != NULL ? g_object_ref (volume->activation_root) : NULL;
}

static void
g_gdu_volume_volume_iface_init (GVolumeIface *iface)
{
  iface->get_name = g_gdu_volume_get_name;
  iface->get_icon = g_gdu_volume_get_icon;
  iface->get_uuid = g_gdu_volume_get_uuid;
  iface->get_drive = g_gdu_volume_get_drive;
  iface->get_mount = g_gdu_volume_get_mount;
  iface->can_mount = g_gdu_volume_can_mount;
  iface->can_eject = g_gdu_volume_can_eject;
  iface->should_automount = g_gdu_volume_should_automount;
  iface->mount_fn = g_gdu_volume_mount;
  iface->mount_finish = g_gdu_volume_mount_finish;
  iface->eject = g_gdu_volume_eject;
  iface->eject_finish = g_gdu_volume_eject_finish;
  iface->eject_with_operation = g_gdu_volume_eject_with_operation;
  iface->eject_with_operation_finish = g_gdu_volume_eject_with_operation_finish;
  iface->get_identifier = g_gdu_volume_get_identifier;
  iface->enumerate_identifiers = g_gdu_volume_enumerate_identifiers;
  iface->get_activation_root = g_gdu_volume_get_activation_root;
}

gboolean
g_gdu_volume_has_dev (GGduVolume   *volume,
                      dev_t         dev)
{
  dev_t _dev;

  _dev = volume->dev;

  if (volume->cleartext_gdu_volume != NULL)
    {
      GduDevice *luks_cleartext_volume_device;
      luks_cleartext_volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->cleartext_gdu_volume));
      if (luks_cleartext_volume_device != NULL)
        {
          _dev = gdu_device_get_dev (luks_cleartext_volume_device);
          g_object_unref (luks_cleartext_volume_device);
        }
    }

  return _dev == dev;
}

gboolean
g_gdu_volume_has_device_file (GGduVolume   *volume,
                              const gchar  *device_file)
{
  const gchar *_device_file;

  _device_file = volume->device_file;

  if (volume->cleartext_gdu_volume != NULL)
    {
      GduDevice *luks_cleartext_volume_device;
      luks_cleartext_volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->cleartext_gdu_volume));
      if (luks_cleartext_volume_device != NULL)
        {
          _device_file = gdu_device_get_device_file (luks_cleartext_volume_device);
          g_object_unref (luks_cleartext_volume_device);
        }
    }

  return g_strcmp0 (_device_file, device_file) == 0;
}


gboolean
g_gdu_volume_has_mount_path (GGduVolume *volume,
                             const char  *mount_path)
{
  GduDevice *device;
  GduPresentable *presentable;
  gboolean ret;

  ret = FALSE;

  presentable = g_gdu_volume_get_presentable_with_cleartext (volume);
  if (presentable != NULL)
    {
      device = gdu_presentable_get_device (presentable);
      if (device != NULL)
        {
          ret = g_strcmp0 (gdu_device_get_mount_path (device), mount_path) == 0;
          g_object_unref (device);
        }
    }

  return ret;
}

gboolean
g_gdu_volume_has_uuid (GGduVolume  *volume,
                       const char  *uuid)
{
  const gchar *_uuid;

  _uuid = volume->uuid;

  if (volume->cleartext_gdu_volume != NULL)
    {
      GduDevice *luks_cleartext_volume_device;
      luks_cleartext_volume_device = gdu_presentable_get_device (GDU_PRESENTABLE (volume->cleartext_gdu_volume));
      if (luks_cleartext_volume_device != NULL)
        {
          _uuid = gdu_device_id_get_uuid (luks_cleartext_volume_device);
          g_object_unref (luks_cleartext_volume_device);
        }
    }

  return g_strcmp0 (_uuid, uuid) == 0;
}

GduPresentable *
g_gdu_volume_get_presentable (GGduVolume *volume)
{
  return GDU_PRESENTABLE (volume->gdu_volume);
}

GduPresentable *
g_gdu_volume_get_presentable_with_cleartext (GGduVolume *volume)
{
  GduVolume *ret;

  ret = volume->cleartext_gdu_volume;
  if (ret == NULL)
    ret = volume->gdu_volume;

  return GDU_PRESENTABLE (ret);
}

GUnixMountPoint *
g_gdu_volume_get_unix_mount_point (GGduVolume *volume)
{
  return volume->unix_mount_point;
}

gboolean
g_gdu_volume_has_presentable (GGduVolume       *volume,
                              GduPresentable  *presentable)
{
  return volume->gdu_volume != NULL &&
    g_strcmp0 (gdu_presentable_get_id (GDU_PRESENTABLE (volume->gdu_volume)),
               gdu_presentable_get_id (presentable)) == 0;
}
