diff --git a/monitor/proxy/gproxydrive.c b/monitor/proxy/gproxydrive.c
index 49e9ae1..0d543fc 100644
--- a/monitor/proxy/gproxydrive.c
+++ b/monitor/proxy/gproxydrive.c
@@ -59,6 +59,8 @@ struct _GProxyDrive {
   gboolean can_stop;
   GDriveStartStopType start_stop_type;
 
+  gboolean is_locked;
+
   GHashTable *identifiers;
 };
 
@@ -131,10 +133,11 @@ g_proxy_drive_new (GProxyVolumeMonitor *volume_monitor)
  * boolean              can-start-degraded
  * boolean              can-stop
  * uint32               start-stop-type
+ * gboolean             is-locked
  * array:string         volume-ids
  * dict:string->string  identifiers
  */
-#define DRIVE_STRUCT_TYPE "(sssbbbbbbbbuasa{ss})"
+#define DRIVE_STRUCT_TYPE "(sssbbbbbbbbubasa{ss})"
 
 void
 g_proxy_drive_update (GProxyDrive         *drive,
@@ -154,6 +157,7 @@ g_proxy_drive_update (GProxyDrive         *drive,
   dbus_bool_t can_start_degraded;
   dbus_bool_t can_stop;
   dbus_uint32_t start_stop_type;
+  dbus_bool_t is_locked;
   GPtrArray *volume_ids;
   GHashTable *identifiers;
 
@@ -182,6 +186,8 @@ g_proxy_drive_update (GProxyDrive         *drive,
   dbus_message_iter_next (&iter_struct);
   dbus_message_iter_get_basic (&iter_struct, &start_stop_type);
   dbus_message_iter_next (&iter_struct);
+  dbus_message_iter_get_basic (&iter_struct, &is_locked);
+  dbus_message_iter_next (&iter_struct);
 
   volume_ids = g_ptr_array_new ();
   dbus_message_iter_recurse (&iter_struct, &iter_volume_ids_iter);
@@ -233,6 +239,7 @@ g_proxy_drive_update (GProxyDrive         *drive,
   drive->can_start_degraded = can_start_degraded;
   drive->can_stop = can_stop;
   drive->start_stop_type = start_stop_type;
+  drive->is_locked = is_locked;
   drive->identifiers = identifiers != NULL ? g_hash_table_ref (identifiers) : NULL;
   drive->volume_ids = g_strdupv ((char **) volume_ids->pdata);
 
@@ -423,6 +430,19 @@ g_proxy_drive_get_start_stop_type (GDrive *drive)
   return res;
 }
 
+static gboolean
+g_proxy_drive_get_is_locked (GDrive *drive)
+{
+  GProxyDrive *proxy_drive = G_PROXY_DRIVE (drive);
+  gboolean res;
+
+  G_LOCK (proxy_drive);
+  res = proxy_drive->is_locked;
+  G_UNLOCK (proxy_drive);
+
+  return res;
+}
+
 static char *
 g_proxy_drive_get_identifier (GDrive              *drive,
                               const char          *kind)
@@ -1121,6 +1141,247 @@ g_proxy_drive_poll_for_media_finish (GDrive        *drive,
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+static void
+release_lock_cb (DBusMessage *reply,
+                 GError *error,
+                 DBusOp *data)
+{
+  GSimpleAsyncResult *simple;
+
+  if (!g_cancellable_is_cancelled (data->cancellable))
+    {
+      if (error != NULL)
+        simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive),
+                                                       data->callback,
+                                                       data->user_data,
+                                                       error);
+      else
+        simple = g_simple_async_result_new (G_OBJECT (data->drive),
+                                            data->callback,
+                                            data->user_data,
+                                            NULL);
+    }
+  else
+      simple = g_simple_async_result_new_error (G_OBJECT (data->drive),
+                                                data->callback,
+                                                data->user_data,
+                                                G_IO_ERROR,
+                                                G_IO_ERROR_CANCELLED,
+                                                _("Operation was cancelled"));
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+
+  g_object_unref (data->drive);
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data);
+}
+
+static void
+g_proxy_drive_release_lock (GDrive              *drive,
+                            guint                cookie,
+                            GCancellable        *cancellable,
+                            GAsyncReadyCallback  callback,
+                            gpointer             user_data)
+{
+  GProxyDrive *proxy_drive = G_PROXY_DRIVE (drive);
+  DBusConnection *connection;
+  const char *name;
+  DBusMessage *message;
+  DBusOp *data;
+  dbus_uint32_t _cookie = cookie;
+
+  G_LOCK (proxy_drive);
+
+  if (g_cancellable_is_cancelled (cancellable))
+    {
+      GSimpleAsyncResult *simple;
+      simple = g_simple_async_result_new_error (G_OBJECT (drive),
+                                                callback,
+                                                user_data,
+                                                G_IO_ERROR,
+                                                G_IO_ERROR_CANCELLED,
+                                                _("Operation was cancelled"));
+      g_simple_async_result_complete_in_idle (simple);
+      g_object_unref (simple);
+      G_UNLOCK (proxy_drive);
+      goto out;
+    }
+
+  data = g_new0 (DBusOp, 1);
+  data->drive = g_object_ref (drive);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+
+  connection = g_proxy_volume_monitor_get_dbus_connection (proxy_drive->volume_monitor);
+  name = g_proxy_volume_monitor_get_dbus_name (proxy_drive->volume_monitor);
+
+  message = dbus_message_new_method_call (name,
+                                          "/org/gtk/Private/RemoteVolumeMonitor",
+                                          "org.gtk.Private.RemoteVolumeMonitor",
+                                          "DriveReleaseLock");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING,
+                            &(proxy_drive->id),
+                            DBUS_TYPE_UINT32,
+                            &_cookie,
+                            DBUS_TYPE_INVALID);
+  G_UNLOCK (proxy_drive);
+
+  _g_dbus_connection_call_async (connection,
+                                 message,
+                                 -1,
+                                 (GAsyncDBusCallback) release_lock_cb,
+                                 data);
+  dbus_connection_unref (connection);
+  dbus_message_unref (message);
+ out:
+  ;
+}
+
+static gboolean
+g_proxy_drive_release_lock_finish (GDrive        *drive,
+                                   GAsyncResult  *result,
+                                   GError       **error)
+{
+  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+    return FALSE;
+  return TRUE;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+static void
+obtain_lock_cb (DBusMessage *reply,
+                GError *error,
+                DBusOp *data)
+{
+  GSimpleAsyncResult *simple;
+
+  if (!g_cancellable_is_cancelled (data->cancellable))
+    {
+      if (error == NULL)
+        {
+          DBusMessageIter iter;
+          gboolean res;
+          guint cookie;
+
+          cookie = 0;
+          res = dbus_message_iter_init (reply, &iter);
+          if (res && dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_UINT32)
+            dbus_message_iter_get_basic (&iter, &cookie);
+
+          simple = g_simple_async_result_new (G_OBJECT (data->drive),
+                                              data->callback,
+                                              data->user_data,
+                                              NULL);
+          g_simple_async_result_set_op_res_gssize (simple, cookie);
+        }
+      else
+          simple = g_simple_async_result_new_from_error (G_OBJECT (data->drive),
+                                                         data->callback,
+                                                         data->user_data,
+                                                         error);
+    }
+  else
+      simple = g_simple_async_result_new_error (G_OBJECT (data->drive),
+                                                data->callback,
+                                                data->user_data,
+                                                G_IO_ERROR,
+                                                G_IO_ERROR_CANCELLED,
+                                                _("Operation was cancelled"));
+
+  g_simple_async_result_complete (simple);
+  g_object_unref (simple);
+
+  g_object_unref (data->drive);
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data);
+}
+
+static void
+g_proxy_drive_obtain_lock (GDrive              *drive,
+                           GDriveLockFlags      flags,
+                           const gchar         *reason,
+                           GCancellable        *cancellable,
+                           GAsyncReadyCallback  callback,
+                           gpointer             user_data)
+{
+  GProxyDrive *proxy_drive = G_PROXY_DRIVE (drive);
+  DBusConnection *connection;
+  const char *name;
+  DBusMessage *message;
+  DBusOp *data;
+  dbus_uint32_t _flags = flags;
+
+  G_LOCK (proxy_drive);
+
+  if (g_cancellable_is_cancelled (cancellable))
+    {
+      GSimpleAsyncResult *simple;
+      simple = g_simple_async_result_new_error (G_OBJECT (drive),
+                                                callback,
+                                                user_data,
+                                                G_IO_ERROR,
+                                                G_IO_ERROR_CANCELLED,
+                                                _("Operation was cancelled"));
+      g_simple_async_result_complete_in_idle (simple);
+      g_object_unref (simple);
+      G_UNLOCK (proxy_drive);
+      goto out;
+    }
+
+  data = g_new0 (DBusOp, 1);
+  data->drive = g_object_ref (drive);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+
+  connection = g_proxy_volume_monitor_get_dbus_connection (proxy_drive->volume_monitor);
+  name = g_proxy_volume_monitor_get_dbus_name (proxy_drive->volume_monitor);
+
+  message = dbus_message_new_method_call (name,
+                                          "/org/gtk/Private/RemoteVolumeMonitor",
+                                          "org.gtk.Private.RemoteVolumeMonitor",
+                                          "DriveObtainLock");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING,
+                            &(proxy_drive->id),
+                            DBUS_TYPE_UINT32,
+                            &_flags,
+                            DBUS_TYPE_STRING,
+                            reason,
+                            DBUS_TYPE_INVALID);
+  G_UNLOCK (proxy_drive);
+
+  _g_dbus_connection_call_async (connection,
+                                 message,
+                                 -1,
+                                 (GAsyncDBusCallback) obtain_lock_cb,
+                                 data);
+  dbus_connection_unref (connection);
+  dbus_message_unref (message);
+ out:
+  ;
+}
+
+static guint
+g_proxy_drive_obtain_lock_finish (GDrive        *drive,
+                                  GAsyncResult  *result,
+                                  GError       **error)
+{
+  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+    return 0;
+  return g_simple_async_result_get_op_res_gssize (G_SIMPLE_ASYNC_RESULT (result));
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
 
 static void
 g_proxy_drive_drive_iface_init (GDriveIface *iface)
@@ -1150,6 +1411,11 @@ g_proxy_drive_drive_iface_init (GDriveIface *iface)
   iface->stop = g_proxy_drive_stop;
   iface->stop_finish = g_proxy_drive_stop_finish;
   iface->get_start_stop_type = g_proxy_drive_get_start_stop_type;
+  iface->is_locked = g_proxy_drive_get_is_locked;
+  iface->obtain_lock = g_proxy_drive_obtain_lock;
+  iface->obtain_lock_finish = g_proxy_drive_obtain_lock_finish;
+  iface->release_lock = g_proxy_drive_release_lock;
+  iface->release_lock_finish = g_proxy_drive_release_lock_finish;
 }
 
 void
diff --git a/monitor/proxy/gvfsproxyvolumemonitordaemon.c b/monitor/proxy/gvfsproxyvolumemonitordaemon.c
index 0a7e1da..3280355 100644
--- a/monitor/proxy/gvfsproxyvolumemonitordaemon.c
+++ b/monitor/proxy/gvfsproxyvolumemonitordaemon.c
@@ -410,10 +410,11 @@ static void monitor_try_create (void);
  * boolean              can-start-degraded
  * boolean              can-stop
  * uint32               start-stop-type
+ * boolean              is-locked
  * array:string         volume-ids
  * dict:string->string  identifiers
  */
-#define DRIVE_STRUCT_TYPE "(sssbbbbbbbbuasa{ss})"
+#define DRIVE_STRUCT_TYPE "(sssbbbbbbbbubasa{ss})"
 
 static void
 append_drive (GDrive *drive, DBusMessageIter *iter_array)
@@ -434,6 +435,7 @@ append_drive (GDrive *drive, DBusMessageIter *iter_array)
   gboolean can_start_degraded;
   gboolean can_stop;
   GDriveStartStopType start_stop_type;
+  gboolean is_locked;
   GList *volumes, *l;
   char **identifiers;
   int n;
@@ -456,6 +458,7 @@ append_drive (GDrive *drive, DBusMessageIter *iter_array)
   can_start_degraded = g_drive_can_start_degraded (drive);
   can_stop = g_drive_can_stop (drive);
   start_stop_type = g_drive_get_start_stop_type (drive);
+  is_locked = (g_object_get_data (G_OBJECT (drive), "lock_owner") != NULL);
   volumes = g_drive_get_volumes (drive);
   identifiers = g_drive_enumerate_identifiers (drive);
 
@@ -474,6 +477,7 @@ append_drive (GDrive *drive, DBusMessageIter *iter_array)
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_BOOLEAN, &can_start_degraded);
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_BOOLEAN, &can_stop);
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &start_stop_type);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_BOOLEAN, &is_locked);
 
   dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "s", &iter_volume_array);
   for (l = volumes; l != NULL; l = l->next)
@@ -1682,6 +1686,264 @@ handle_drive_poll_for_media (DBusConnection *connection, DBusMessage *message)
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+static guint
+obtain_drive_lock (DBusMessage     *message,
+                   GDrive          *drive,
+                   GDriveLockFlags  flags,
+                   const gchar     *reason,
+                   GError         **error)
+{
+  guint lock_cookie;
+
+  lock_cookie = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (drive), "lock_cookie"));
+  if (lock_cookie != 0)
+    {
+      const gchar *lock_reason;
+
+      lock_reason = g_object_get_data (G_OBJECT (drive), "lock_reason");
+      g_set_error (error,
+                   G_IO_ERROR,
+                   G_IO_ERROR_LOCKED,
+                   lock_reason? lock_reason:"the drive is locked");
+      return 0;
+    }
+
+  lock_cookie = g_random_int ();
+  g_object_set_data_full (G_OBJECT (drive),
+                          "lock_owner",
+                          g_strdup (dbus_message_get_sender (message)),
+                          g_free);
+  g_object_set_data (G_OBJECT (drive), "lock_cookie", GINT_TO_POINTER (lock_cookie));
+  g_object_set_data_full (G_OBJECT (drive), "lock_reason", g_strdup (reason), g_free);
+
+  g_signal_emit_by_name (drive, "changed");
+
+  return lock_cookie;
+}
+
+static DBusHandlerResult
+handle_drive_obtain_lock (DBusConnection *connection, DBusMessage *message)
+{
+  const char *id;
+  const char *sender;
+  GDriveLockFlags flags;
+  gchar *reason;
+  DBusError dbus_error;
+  GList *drives, *l;
+  GDrive *drive;
+  DBusHandlerResult ret;
+  guint cookie;
+  GError *error;
+  DBusMessage *reply;
+  DBusMessageIter iter;
+
+  drives = NULL;
+  ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  dbus_error_init (&dbus_error);
+  if (!dbus_message_get_args (message, &dbus_error,
+                              DBUS_TYPE_STRING, &id,
+                              DBUS_TYPE_UINT32, &flags,
+                              DBUS_TYPE_STRING, &reason,
+                              DBUS_TYPE_INVALID))
+    {
+      g_warning ("Error parsing args for DriveObtainLock(): %s: %s", dbus_error.name, dbus_error.message);
+      dbus_error_free (&dbus_error);
+      goto out;
+    }
+
+  print_debug ("in handle_drive_obtain_lock");
+
+  ret = DBUS_HANDLER_RESULT_HANDLED;
+
+  sender = dbus_message_get_sender (message);
+
+  drive = NULL;
+  drives = g_volume_monitor_get_connected_drives (monitor);
+  for (l = drives; l != NULL; l = l->next)
+    {
+      char *drive_id;
+
+      drive = G_DRIVE (l->data);
+      drive_id = g_strdup_printf ("%p", drive);
+      if (strcmp (drive_id, id) == 0)
+        break;
+
+      g_free (drive_id);
+    }
+  if (l == NULL)
+    drive = NULL;
+
+  if (drive == NULL)
+    {
+      reply = dbus_message_new_error (message,
+                                      "org.gtk.Private.RemoteVolumeMonitor.NotFound",
+                                      "The given drive was not found");
+      dbus_connection_send (connection, reply, NULL);
+      dbus_message_unref (reply);
+      goto out;
+    }
+
+  error = NULL;
+  cookie = obtain_drive_lock (message,
+                              drive,
+                              flags,
+                              reason,
+                              &error);
+  if (!cookie)
+    {
+      print_debug ("  error: %s", error->message);
+      reply = _dbus_message_new_from_gerror (message, error);
+      g_error_free (error);
+      dbus_connection_send (connection, reply, NULL);
+      dbus_message_unref (reply);
+      goto out;
+    }
+
+  print_debug (" success");
+
+  reply = dbus_message_new_method_return (message);
+  dbus_message_iter_init_append (message, &iter);
+  dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &cookie);
+  dbus_connection_send (connection, reply, NULL);
+  dbus_message_unref (reply);
+
+  g_signal_emit_by_name (drive, "changed");
+
+ out:
+  if (drives != NULL)
+    {
+      g_list_foreach (drives, (GFunc) g_object_unref, NULL);
+      g_list_free (drives);
+    }
+
+  if (reason != NULL)
+    g_free (reason);
+
+  return ret;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+static gboolean
+release_drive_lock (DBusMessage *message,
+                    GDrive *drive,
+                    guint cookie,
+                    GError **error)
+{
+  guint lock_cookie;
+
+  lock_cookie = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (drive), "lock_cookie"));
+
+  if (lock_cookie == 0)
+    return TRUE;
+
+  if (lock_cookie != cookie)
+    {
+      g_set_error (error,
+                   G_IO_ERROR,
+                   G_IO_ERROR_INVALID_ARGUMENT,
+                   "Invalid lock cookie");
+      return FALSE;
+    }
+
+  g_object_set_data (G_OBJECT (drive), "lock_owner", NULL);
+  g_object_set_data (G_OBJECT (drive), "lock_cookie", NULL);
+  g_object_set_data (G_OBJECT (drive), "lock_reason", NULL);
+
+  return TRUE;
+}
+
+static DBusHandlerResult
+handle_drive_release_lock (DBusConnection *connection, DBusMessage *message)
+{
+  const char *id;
+  const char *cancellation_id;
+  const char *sender;
+  guint cookie;
+  DBusError dbus_error;
+  GList *drives, *l;
+  GDrive *drive;
+  DBusHandlerResult ret;
+  GError *error;
+  DBusMessage *reply;
+
+  drives = NULL;
+  ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  dbus_error_init (&dbus_error);
+  if (!dbus_message_get_args (message, &dbus_error,
+                              DBUS_TYPE_STRING, &id,
+                              DBUS_TYPE_STRING, &cancellation_id,
+                              DBUS_TYPE_UINT32, &cookie,
+                              DBUS_TYPE_INVALID))
+    {
+      g_warning ("Error parsing args for DriveReleaseLock(): %s: %s", dbus_error.name, dbus_error.message);
+      dbus_error_free (&dbus_error);
+      goto out;
+    }
+
+  print_debug ("in handle_drive_release_lock");
+
+  ret = DBUS_HANDLER_RESULT_HANDLED;
+
+  sender = dbus_message_get_sender (message);
+
+  drive = NULL;
+  drives = g_volume_monitor_get_connected_drives (monitor);
+  for (l = drives; l != NULL; l = l->next)
+    {
+      char *drive_id;
+
+      drive = G_DRIVE (l->data);
+      drive_id = g_strdup_printf ("%p", drive);
+      if (strcmp (drive_id, id) == 0)
+        break;
+
+      g_free (drive_id);
+    }
+  if (l == NULL)
+    drive = NULL;
+
+  if (drive == NULL)
+    {
+      reply = dbus_message_new_error (message,
+                                      "org.gtk.Private.RemoteVolumeMonitor.NotFound",
+                                      "The given drive was not found");
+      dbus_connection_send (connection, reply, NULL);
+      dbus_message_unref (reply);
+      goto out;
+    }
+
+  error = NULL;
+  if (!release_drive_lock (message, drive, cookie, &error))
+    {
+      print_debug ("  error: %s", error->message);
+      reply = _dbus_message_new_from_gerror (message, error);
+      g_error_free (error);
+      dbus_connection_send (connection, reply, NULL);
+      dbus_message_unref (reply);
+      goto out;
+    }
+
+  print_debug (" success");
+  reply = dbus_message_new_method_return (message);
+  dbus_connection_send (connection, reply, NULL);
+  dbus_message_unref (reply);
+
+  g_signal_emit_by_name (drive, "changed");
+
+ out:
+  if (drives != NULL)
+    {
+      g_list_foreach (drives, (GFunc) g_object_unref, NULL);
+      g_list_free (drives);
+    }
+  return ret;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
 static DBusHandlerResult
 handle_is_supported (DBusConnection *connection, DBusMessage *message)
 {
@@ -1801,7 +2063,7 @@ filter_function (DBusConnection *connection, DBusMessage *message, void *user_da
 
       if (strlen (new_owner) == 0)
         {
-          GList *l;
+          GList *l, *drives;
 
           /* if @name has outstanding mount operation objects; abort them */
           for (l = outstanding_mount_op_objects; l != NULL; l = l->next)
@@ -1836,6 +2098,30 @@ filter_function (DBusConnection *connection, DBusMessage *message, void *user_da
                 }
             }
 
+          /* see if @name owned any locks on any drive; if so, release them */
+          drives = g_volume_monitor_get_connected_drives (monitor);
+          for (l = drives; l != NULL; l = l->next)
+            {
+              const gchar *lock_owner;
+              GDrive *drive;
+
+              drive = G_DRIVE (l->data);
+              lock_owner = g_object_get_data (G_OBJECT (drive), "lock_owner");
+              if (g_strcmp0 (lock_owner, name) == 0)
+                {
+                  print_debug ("****** name `%s' has a lock on a drive, releasing it",
+                               name);
+                  g_object_set_data (G_OBJECT (drive), "lock_owner", NULL);
+                  g_object_set_data (G_OBJECT (drive), "lock_cookie", NULL);
+                  g_object_set_data (G_OBJECT (drive), "lock_reason", NULL);
+
+                  g_signal_emit_by_name (drive, "changed");
+                }
+            }
+
+          g_list_foreach (drives, (GFunc) g_object_unref, NULL);
+          g_list_free (drives);
+
           remove_name_owned_changed_for_unique_name (name);
         }
 
@@ -1882,6 +2168,12 @@ filter_function (DBusConnection *connection, DBusMessage *message, void *user_da
 
               else if (dbus_message_is_method_call (message, "org.gtk.Private.RemoteVolumeMonitor", "MountOpReply"))
                 ret = handle_mount_op_reply (connection, message);
+
+              else if (dbus_message_is_method_call (message, "org.gtk.Private.RemoteVolumeMonitor", "DriveObtainLock"))
+                ret = handle_drive_obtain_lock (connection, message);
+
+              else if (dbus_message_is_method_call (message, "org.gtk.Private.RemoteVolumeMonitor", "DriveReleaseLock"))
+                ret = handle_drive_release_lock (connection, message);
             }
         }
     }
