| /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ |
| |
| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2006-2007 Red Hat, Inc. |
| * |
| * SPDX-License-Identifier: LGPL-2.1-or-later |
| * |
| * 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.1 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, see <http://www.gnu.org/licenses/>. |
| * |
| * Author: Alexander Larsson <alexl@redhat.com> |
| * David Zeuthen <davidz@redhat.com> |
| */ |
| |
| #include "config.h" |
| |
| #include <string.h> |
| |
| #include <glib.h> |
| #include "gunionvolumemonitor.h" |
| #include "gmountprivate.h" |
| #include "giomodule-priv.h" |
| #ifdef G_OS_UNIX |
| #include "gunixvolumemonitor.h" |
| #endif |
| #include "gnativevolumemonitor.h" |
| |
| #include "glibintl.h" |
| |
| |
| struct _GUnionVolumeMonitor { |
| GVolumeMonitor parent; |
| |
| GList *monitors; |
| }; |
| |
| static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor, |
| GVolumeMonitor *child_monitor); |
| |
| |
| #define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type |
| G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR) |
| |
| static GRecMutex the_volume_monitor_mutex; |
| |
| static GUnionVolumeMonitor *the_volume_monitor = NULL; |
| |
| static void |
| g_union_volume_monitor_finalize (GObject *object) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| |
| monitor = G_UNION_VOLUME_MONITOR (object); |
| |
| while (monitor->monitors != NULL) |
| { |
| child_monitor = monitor->monitors->data; |
| g_union_volume_monitor_remove_monitor (monitor, |
| child_monitor); |
| g_object_unref (child_monitor); |
| } |
| |
| G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object); |
| } |
| |
| static void |
| g_union_volume_monitor_dispose (GObject *object) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (object); |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| the_volume_monitor = NULL; |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| g_object_run_dispose (G_OBJECT (child_monitor)); |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object); |
| } |
| |
| static GList * |
| get_mounts (GVolumeMonitor *volume_monitor) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GList *res; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (volume_monitor); |
| |
| res = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| |
| res = g_list_concat (res, g_volume_monitor_get_mounts (child_monitor)); |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return res; |
| } |
| |
| static GList * |
| get_volumes (GVolumeMonitor *volume_monitor) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GList *res; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (volume_monitor); |
| |
| res = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| |
| res = g_list_concat (res, g_volume_monitor_get_volumes (child_monitor)); |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return res; |
| } |
| |
| static GList * |
| get_connected_drives (GVolumeMonitor *volume_monitor) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GList *res; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (volume_monitor); |
| |
| res = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| |
| res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor)); |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return res; |
| } |
| |
| static GVolume * |
| get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GVolume *volume; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (volume_monitor); |
| |
| volume = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| |
| volume = g_volume_monitor_get_volume_for_uuid (child_monitor, uuid); |
| if (volume != NULL) |
| break; |
| |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return volume; |
| } |
| |
| static GMount * |
| get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid) |
| { |
| GUnionVolumeMonitor *monitor; |
| GVolumeMonitor *child_monitor; |
| GMount *mount; |
| GList *l; |
| |
| monitor = G_UNION_VOLUME_MONITOR (volume_monitor); |
| |
| mount = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| |
| mount = g_volume_monitor_get_mount_for_uuid (child_monitor, uuid); |
| if (mount != NULL) |
| break; |
| |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return mount; |
| } |
| |
| static void |
| g_union_volume_monitor_class_init (GUnionVolumeMonitorClass *klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass); |
| |
| gobject_class->finalize = g_union_volume_monitor_finalize; |
| gobject_class->dispose = g_union_volume_monitor_dispose; |
| |
| monitor_class->get_connected_drives = get_connected_drives; |
| monitor_class->get_volumes = get_volumes; |
| monitor_class->get_mounts = get_mounts; |
| monitor_class->get_volume_for_uuid = get_volume_for_uuid; |
| monitor_class->get_mount_for_uuid = get_mount_for_uuid; |
| } |
| |
| static void |
| child_volume_added (GVolumeMonitor *child_monitor, |
| GVolume *child_volume, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "volume-added", |
| child_volume); |
| } |
| |
| static void |
| child_volume_removed (GVolumeMonitor *child_monitor, |
| GVolume *child_volume, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "volume-removed", |
| child_volume); |
| } |
| |
| static void |
| child_volume_changed (GVolumeMonitor *child_monitor, |
| GVolume *child_volume, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "volume-changed", |
| child_volume); |
| } |
| |
| static void |
| child_mount_added (GVolumeMonitor *child_monitor, |
| GMount *child_mount, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "mount-added", |
| child_mount); |
| } |
| |
| static void |
| child_mount_removed (GVolumeMonitor *child_monitor, |
| GMount *child_mount, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "mount-removed", |
| child_mount); |
| } |
| |
| static void |
| child_mount_pre_unmount (GVolumeMonitor *child_monitor, |
| GMount *child_mount, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "mount-pre-unmount", |
| child_mount); |
| } |
| |
| |
| static void |
| child_mount_changed (GVolumeMonitor *child_monitor, |
| GMount *child_mount, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "mount-changed", |
| child_mount); |
| } |
| |
| static void |
| child_drive_connected (GVolumeMonitor *child_monitor, |
| GDrive *child_drive, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "drive-connected", |
| child_drive); |
| } |
| |
| static void |
| child_drive_disconnected (GVolumeMonitor *child_monitor, |
| GDrive *child_drive, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "drive-disconnected", |
| child_drive); |
| } |
| |
| static void |
| child_drive_changed (GVolumeMonitor *child_monitor, |
| GDrive *child_drive, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "drive-changed", |
| child_drive); |
| } |
| |
| static void |
| child_drive_eject_button (GVolumeMonitor *child_monitor, |
| GDrive *child_drive, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "drive-eject-button", |
| child_drive); |
| } |
| |
| static void |
| child_drive_stop_button (GVolumeMonitor *child_monitor, |
| GDrive *child_drive, |
| GUnionVolumeMonitor *union_monitor) |
| { |
| g_signal_emit_by_name (union_monitor, |
| "drive-stop-button", |
| child_drive); |
| } |
| |
| static void |
| g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor, |
| GVolumeMonitor *volume_monitor) |
| { |
| if (g_list_find (union_monitor->monitors, volume_monitor)) |
| return; |
| |
| union_monitor->monitors = |
| g_list_prepend (union_monitor->monitors, |
| g_object_ref (volume_monitor)); |
| |
| g_signal_connect (volume_monitor, "volume-added", (GCallback)child_volume_added, union_monitor); |
| g_signal_connect (volume_monitor, "volume-removed", (GCallback)child_volume_removed, union_monitor); |
| g_signal_connect (volume_monitor, "volume-changed", (GCallback)child_volume_changed, union_monitor); |
| g_signal_connect (volume_monitor, "mount-added", (GCallback)child_mount_added, union_monitor); |
| g_signal_connect (volume_monitor, "mount-removed", (GCallback)child_mount_removed, union_monitor); |
| g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback)child_mount_pre_unmount, union_monitor); |
| g_signal_connect (volume_monitor, "mount-changed", (GCallback)child_mount_changed, union_monitor); |
| g_signal_connect (volume_monitor, "drive-connected", (GCallback)child_drive_connected, union_monitor); |
| g_signal_connect (volume_monitor, "drive-disconnected", (GCallback)child_drive_disconnected, union_monitor); |
| g_signal_connect (volume_monitor, "drive-changed", (GCallback)child_drive_changed, union_monitor); |
| g_signal_connect (volume_monitor, "drive-eject-button", (GCallback)child_drive_eject_button, union_monitor); |
| g_signal_connect (volume_monitor, "drive-stop-button", (GCallback)child_drive_stop_button, union_monitor); |
| } |
| |
| static void |
| g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor, |
| GVolumeMonitor *child_monitor) |
| { |
| GList *l; |
| |
| l = g_list_find (union_monitor->monitors, child_monitor); |
| if (l == NULL) |
| return; |
| |
| union_monitor->monitors = g_list_delete_link (union_monitor->monitors, l); |
| |
| g_signal_handlers_disconnect_by_func (child_monitor, child_volume_added, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_volume_removed, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_volume_changed, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_mount_added, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_mount_removed, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_mount_pre_unmount, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_mount_changed, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_drive_connected, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_drive_disconnected, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_drive_changed, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_drive_eject_button, union_monitor); |
| g_signal_handlers_disconnect_by_func (child_monitor, child_drive_stop_button, union_monitor); |
| } |
| |
| static GType |
| get_default_native_class (gpointer data) |
| { |
| return _g_io_module_get_default_type (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME, |
| "GIO_USE_VOLUME_MONITOR", |
| G_STRUCT_OFFSET (GVolumeMonitorClass, is_supported)); |
| } |
| |
| /* We return the class, with a ref taken. |
| * This way we avoid unloading the class/module |
| * between selecting the type and creating the |
| * instance on the first call. |
| */ |
| static GNativeVolumeMonitorClass * |
| get_native_class (void) |
| { |
| static GOnce once_init = G_ONCE_INIT; |
| GTypeClass *type_class; |
| |
| type_class = NULL; |
| g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class); |
| |
| if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID)) |
| type_class = g_type_class_ref ((GType)once_init.retval); |
| |
| return (GNativeVolumeMonitorClass *)type_class; |
| } |
| |
| static void |
| g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor) |
| { |
| } |
| |
| static void |
| populate_union_monitor (GUnionVolumeMonitor *union_monitor) |
| { |
| GVolumeMonitor *monitor; |
| GNativeVolumeMonitorClass *native_class; |
| GVolumeMonitorClass *klass; |
| GIOExtensionPoint *ep; |
| GIOExtension *extension; |
| GList *l; |
| |
| native_class = get_native_class (); |
| |
| if (native_class != NULL) |
| { |
| monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL); |
| g_union_volume_monitor_add_monitor (union_monitor, monitor); |
| g_object_unref (monitor); |
| g_type_class_unref (native_class); |
| } |
| |
| ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME); |
| for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next) |
| { |
| extension = l->data; |
| |
| klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension)); |
| if (klass->is_supported == NULL || klass->is_supported()) |
| { |
| monitor = g_object_new (g_io_extension_get_type (extension), NULL); |
| g_union_volume_monitor_add_monitor (union_monitor, monitor); |
| g_object_unref (monitor); |
| } |
| g_type_class_unref (klass); |
| } |
| } |
| |
| static GUnionVolumeMonitor * |
| g_union_volume_monitor_new (void) |
| { |
| GUnionVolumeMonitor *monitor; |
| |
| monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL); |
| |
| return monitor; |
| } |
| |
| /** |
| * g_volume_monitor_get: |
| * |
| * Gets the volume monitor used by gio. |
| * |
| * Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call |
| * g_object_unref() when done with it. |
| **/ |
| GVolumeMonitor * |
| g_volume_monitor_get (void) |
| { |
| GVolumeMonitor *vm; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| if (the_volume_monitor) |
| vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor)); |
| else |
| { |
| the_volume_monitor = g_union_volume_monitor_new (); |
| populate_union_monitor (the_volume_monitor); |
| vm = G_VOLUME_MONITOR (the_volume_monitor); |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return vm; |
| } |
| |
| GMount * |
| _g_mount_get_for_mount_path (const gchar *mount_path, |
| GCancellable *cancellable) |
| { |
| GNativeVolumeMonitorClass *klass; |
| GMount *mount; |
| |
| klass = get_native_class (); |
| if (klass == NULL) |
| return NULL; |
| |
| mount = NULL; |
| |
| if (klass->get_mount_for_mount_path) |
| mount = klass->get_mount_for_mount_path (mount_path, cancellable); |
| |
| /* TODO: How do we know this succeeded? Keep in mind that the native |
| * volume monitor may fail (e.g. not being able to connect to |
| * udisks). Is the get_mount_for_mount_path() method allowed to |
| * return NULL? Seems like it is ... probably the method needs |
| * to take a boolean and write if it succeeds or not.. Messy. |
| * Very messy. |
| */ |
| |
| g_type_class_unref (klass); |
| |
| return mount; |
| } |
| |
| /** |
| * g_volume_monitor_adopt_orphan_mount: |
| * @mount: a #GMount object to find a parent for |
| * |
| * This function should be called by any #GVolumeMonitor |
| * implementation when a new #GMount object is created that is not |
| * associated with a #GVolume object. It must be called just before |
| * emitting the @mount_added signal. |
| * |
| * If the return value is not %NULL, the caller must associate the |
| * returned #GVolume object with the #GMount. This involves returning |
| * it in its g_mount_get_volume() implementation. The caller must |
| * also listen for the "removed" signal on the returned object |
| * and give up its reference when handling that signal |
| * |
| * Similarly, if implementing g_volume_monitor_adopt_orphan_mount(), |
| * the implementor must take a reference to @mount and return it in |
| * its g_volume_get_mount() implemented. Also, the implementor must |
| * listen for the "unmounted" signal on @mount and give up its |
| * reference upon handling that signal. |
| * |
| * There are two main use cases for this function. |
| * |
| * One is when implementing a user space file system driver that reads |
| * blocks of a block device that is already represented by the native |
| * volume monitor (for example a CD Audio file system driver). Such |
| * a driver will generate its own #GMount object that needs to be |
| * associated with the #GVolume object that represents the volume. |
| * |
| * The other is for implementing a #GVolumeMonitor whose sole purpose |
| * is to return #GVolume objects representing entries in the users |
| * "favorite servers" list or similar. |
| * |
| * Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL |
| * if no wants to adopt the #GMount. |
| * |
| * Deprecated: 2.20: Instead of using this function, #GVolumeMonitor |
| * implementations should instead create shadow mounts with the URI of |
| * the mount they intend to adopt. See the proxy volume monitor in |
| * gvfs for an example of this. Also see g_mount_is_shadowed(), |
| * g_mount_shadow() and g_mount_unshadow() functions. |
| */ |
| GVolume * |
| g_volume_monitor_adopt_orphan_mount (GMount *mount) |
| { |
| GVolumeMonitor *child_monitor; |
| GVolumeMonitorClass *child_monitor_class; |
| GVolume *volume; |
| GList *l; |
| |
| g_return_val_if_fail (mount != NULL, NULL); |
| |
| if (the_volume_monitor == NULL) |
| return NULL; |
| |
| volume = NULL; |
| |
| g_rec_mutex_lock (&the_volume_monitor_mutex); |
| |
| for (l = the_volume_monitor->monitors; l != NULL; l = l->next) |
| { |
| child_monitor = l->data; |
| child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor); |
| |
| if (child_monitor_class->adopt_orphan_mount != NULL) |
| { |
| volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor); |
| if (volume != NULL) |
| break; |
| } |
| } |
| |
| g_rec_mutex_unlock (&the_volume_monitor_mutex); |
| |
| return volume; |
| } |