gio/gunionvolumemonitor.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2
   3 /* GIO - GLib Input, Output and Streaming Library
   4  *
   5  * Copyright (C) 2006-2007 Red Hat, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  *         David Zeuthen <davidz@redhat.com>
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27
  28 #include <glib.h>
  29 #include "gunionvolumemonitor.h"
  30 #include "gmountprivate.h"
  31 #include "giomodule-priv.h"
  32 #ifdef G_OS_UNIX
  33 #include "gunixvolumemonitor.h"
  34 #endif
  35 #include "gnativevolumemonitor.h"
  36
  37 #include "glibintl.h"
  38
  39
  40 struct _GUnionVolumeMonitor {
  41   GVolumeMonitor parent;
  42
  43   GList *monitors;
  44 };
  45
  46 static void g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
  47                                                    GVolumeMonitor *child_monitor);
  48
  49
  50 #define g_union_volume_monitor_get_type _g_union_volume_monitor_get_type
  51 G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR)
  52
  53 static GRecMutex the_volume_monitor_mutex;
  54
  55 static GUnionVolumeMonitor *the_volume_monitor = NULL;
  56
  57 static void
  58 g_union_volume_monitor_finalize (GObject *object)
  59 {
  60   GUnionVolumeMonitor *monitor;
  61   GVolumeMonitor *child_monitor;
  62
  63   monitor = G_UNION_VOLUME_MONITOR (object);
  64
  65   while (monitor->monitors != NULL)
  66     {
  67       child_monitor = monitor->monitors->data;
  68       g_union_volume_monitor_remove_monitor (monitor,
  69                                              child_monitor);
  70       g_object_unref (child_monitor);
  71     }
  72
  73   G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
  74 }
  75
  76 static void
  77 g_union_volume_monitor_dispose (GObject *object)
  78 {
  79   GUnionVolumeMonitor *monitor;
  80   GVolumeMonitor *child_monitor;
  81   GList *l;
  82
  83   monitor = G_UNION_VOLUME_MONITOR (object);
  84
  85   g_rec_mutex_lock (&the_volume_monitor_mutex);
  86   the_volume_monitor = NULL;
  87
  88   for (l = monitor->monitors; l != NULL; l = l->next)
  89     {
  90       child_monitor = l->data;
  91       g_object_run_dispose (G_OBJECT (child_monitor));
  92     }
  93
  94   g_rec_mutex_unlock (&the_volume_monitor_mutex);
  95
  96   G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object);
  97 }
  98
  99 static GList *
 100 get_mounts (GVolumeMonitor *volume_monitor)
 101 {
 102   GUnionVolumeMonitor *monitor;
 103   GVolumeMonitor *child_monitor;
 104   GList *res;
 105   GList *l;
 106
 107   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 108
 109   res = NULL;
 110
 111   g_rec_mutex_lock (&the_volume_monitor_mutex);
 112
 113   for (l = monitor->monitors; l != NULL; l = l->next)
 114     {
 115       child_monitor = l->data;
 116
 117       res = g_list_concat (res, g_volume_monitor_get_mounts (child_monitor));
 118     }
 119
 120   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 121
 122   return res;
 123 }
 124
 125 static GList *
 126 get_volumes (GVolumeMonitor *volume_monitor)
 127 {
 128   GUnionVolumeMonitor *monitor;
 129   GVolumeMonitor *child_monitor;
 130   GList *res;
 131   GList *l;
 132
 133   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 134
 135   res = NULL;
 136
 137   g_rec_mutex_lock (&the_volume_monitor_mutex);
 138
 139   for (l = monitor->monitors; l != NULL; l = l->next)
 140     {
 141       child_monitor = l->data;
 142
 143       res = g_list_concat (res, g_volume_monitor_get_volumes (child_monitor));
 144     }
 145
 146   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 147
 148   return res;
 149 }
 150
 151 static GList *
 152 get_connected_drives (GVolumeMonitor *volume_monitor)
 153 {
 154   GUnionVolumeMonitor *monitor;
 155   GVolumeMonitor *child_monitor;
 156   GList *res;
 157   GList *l;
 158
 159   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 160
 161   res = NULL;
 162
 163   g_rec_mutex_lock (&the_volume_monitor_mutex);
 164
 165   for (l = monitor->monitors; l != NULL; l = l->next)
 166     {
 167       child_monitor = l->data;
 168
 169       res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor));
 170     }
 171
 172   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 173
 174   return res;
 175 }
 176
 177 static GVolume *
 178 get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 179 {
 180   GUnionVolumeMonitor *monitor;
 181   GVolumeMonitor *child_monitor;
 182   GVolume *volume;
 183   GList *l;
 184
 185   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 186
 187   volume = NULL;
 188
 189   g_rec_mutex_lock (&the_volume_monitor_mutex);
 190
 191   for (l = monitor->monitors; l != NULL; l = l->next)
 192     {
 193       child_monitor = l->data;
 194
 195       volume = g_volume_monitor_get_volume_for_uuid (child_monitor, uuid);
 196       if (volume != NULL)
 197         break;
 198
 199     }
 200
 201   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 202
 203   return volume;
 204 }
 205
 206 static GMount *
 207 get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 208 {
 209   GUnionVolumeMonitor *monitor;
 210   GVolumeMonitor *child_monitor;
 211   GMount *mount;
 212   GList *l;
 213
 214   monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
 215
 216   mount = NULL;
 217
 218   g_rec_mutex_lock (&the_volume_monitor_mutex);
 219
 220   for (l = monitor->monitors; l != NULL; l = l->next)
 221     {
 222       child_monitor = l->data;
 223
 224       mount = g_volume_monitor_get_mount_for_uuid (child_monitor, uuid);
 225       if (mount != NULL)
 226         break;
 227
 228     }
 229
 230   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 231
 232   return mount;
 233 }
 234
 235 static void
 236 g_union_volume_monitor_class_init (GUnionVolumeMonitorClass *klass)
 237 {
 238   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 239   GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
 240
 241   gobject_class->finalize = g_union_volume_monitor_finalize;
 242   gobject_class->dispose = g_union_volume_monitor_dispose;
 243
 244   monitor_class->get_connected_drives = get_connected_drives;
 245   monitor_class->get_volumes = get_volumes;
 246   monitor_class->get_mounts = get_mounts;
 247   monitor_class->get_volume_for_uuid = get_volume_for_uuid;
 248   monitor_class->get_mount_for_uuid = get_mount_for_uuid;
 249 }
 250
 251 static void
 252 child_volume_added (GVolumeMonitor      *child_monitor,
 253                     GVolume    *child_volume,
 254                     GUnionVolumeMonitor *union_monitor)
 255 {
 256   g_signal_emit_by_name (union_monitor,
 257                          "volume-added",
 258                          child_volume);
 259 }
 260
 261 static void
 262 child_volume_removed (GVolumeMonitor      *child_monitor,
 263                       GVolume    *child_volume,
 264                       GUnionVolumeMonitor *union_monitor)
 265 {
 266   g_signal_emit_by_name (union_monitor,
 267                          "volume-removed",
 268                          child_volume);
 269 }
 270
 271 static void
 272 child_volume_changed (GVolumeMonitor      *child_monitor,
 273                       GVolume    *child_volume,
 274                       GUnionVolumeMonitor *union_monitor)
 275 {
 276   g_signal_emit_by_name (union_monitor,
 277                          "volume-changed",
 278                          child_volume);
 279 }
 280
 281 static void
 282 child_mount_added (GVolumeMonitor      *child_monitor,
 283                    GMount              *child_mount,
 284                    GUnionVolumeMonitor *union_monitor)
 285 {
 286   g_signal_emit_by_name (union_monitor,
 287                          "mount-added",
 288                          child_mount);
 289 }
 290
 291 static void
 292 child_mount_removed (GVolumeMonitor      *child_monitor,
 293                      GMount              *child_mount,
 294                      GUnionVolumeMonitor *union_monitor)
 295 {
 296   g_signal_emit_by_name (union_monitor,
 297                          "mount-removed",
 298                          child_mount);
 299 }
 300
 301 static void
 302 child_mount_pre_unmount (GVolumeMonitor       *child_monitor,
 303                           GMount              *child_mount,
 304                           GUnionVolumeMonitor *union_monitor)
 305 {
 306   g_signal_emit_by_name (union_monitor,
 307                          "mount-pre-unmount",
 308                          child_mount);
 309 }
 310
 311
 312 static void
 313 child_mount_changed (GVolumeMonitor       *child_monitor,
 314                       GMount              *child_mount,
 315                       GUnionVolumeMonitor *union_monitor)
 316 {
 317   g_signal_emit_by_name (union_monitor,
 318                          "mount-changed",
 319                          child_mount);
 320 }
 321
 322 static void
 323 child_drive_connected (GVolumeMonitor      *child_monitor,
 324                        GDrive              *child_drive,
 325                        GUnionVolumeMonitor *union_monitor)
 326 {
 327   g_signal_emit_by_name (union_monitor,
 328                          "drive-connected",
 329                          child_drive);
 330 }
 331
 332 static void
 333 child_drive_disconnected (GVolumeMonitor      *child_monitor,
 334                           GDrive              *child_drive,
 335                           GUnionVolumeMonitor *union_monitor)
 336 {
 337   g_signal_emit_by_name (union_monitor,
 338                          "drive-disconnected",
 339                          child_drive);
 340 }
 341
 342 static void
 343 child_drive_changed (GVolumeMonitor      *child_monitor,
 344                      GDrive             *child_drive,
 345                      GUnionVolumeMonitor *union_monitor)
 346 {
 347   g_signal_emit_by_name (union_monitor,
 348                          "drive-changed",
 349                          child_drive);
 350 }
 351
 352 static void
 353 child_drive_eject_button (GVolumeMonitor      *child_monitor,
 354                           GDrive             *child_drive,
 355                           GUnionVolumeMonitor *union_monitor)
 356 {
 357   g_signal_emit_by_name (union_monitor,
 358                          "drive-eject-button",
 359                          child_drive);
 360 }
 361
 362 static void
 363 child_drive_stop_button (GVolumeMonitor      *child_monitor,
 364                          GDrive             *child_drive,
 365                          GUnionVolumeMonitor *union_monitor)
 366 {
 367   g_signal_emit_by_name (union_monitor,
 368                          "drive-stop-button",
 369                          child_drive);
 370 }
 371
 372 static void
 373 g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
 374                                     GVolumeMonitor      *volume_monitor)
 375 {
 376   if (g_list_find (union_monitor->monitors, volume_monitor))
 377     return;
 378
 379   union_monitor->monitors =
 380     g_list_prepend (union_monitor->monitors,
 381                     g_object_ref (volume_monitor));
 382
 383   g_signal_connect (volume_monitor, "volume-added", (GCallback)child_volume_added, union_monitor);
 384   g_signal_connect (volume_monitor, "volume-removed", (GCallback)child_volume_removed, union_monitor);
 385   g_signal_connect (volume_monitor, "volume-changed", (GCallback)child_volume_changed, union_monitor);
 386   g_signal_connect (volume_monitor, "mount-added", (GCallback)child_mount_added, union_monitor);
 387   g_signal_connect (volume_monitor, "mount-removed", (GCallback)child_mount_removed, union_monitor);
 388   g_signal_connect (volume_monitor, "mount-pre-unmount", (GCallback)child_mount_pre_unmount, union_monitor);
 389   g_signal_connect (volume_monitor, "mount-changed", (GCallback)child_mount_changed, union_monitor);
 390   g_signal_connect (volume_monitor, "drive-connected", (GCallback)child_drive_connected, union_monitor);
 391   g_signal_connect (volume_monitor, "drive-disconnected", (GCallback)child_drive_disconnected, union_monitor);
 392   g_signal_connect (volume_monitor, "drive-changed", (GCallback)child_drive_changed, union_monitor);
 393   g_signal_connect (volume_monitor, "drive-eject-button", (GCallback)child_drive_eject_button, union_monitor);
 394   g_signal_connect (volume_monitor, "drive-stop-button", (GCallback)child_drive_stop_button, union_monitor);
 395 }
 396
 397 static void
 398 g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
 399                                        GVolumeMonitor      *child_monitor)
 400 {
 401   GList *l;
 402
 403   l = g_list_find (union_monitor->monitors, child_monitor);
 404   if (l == NULL)
 405     return;
 406
 407   union_monitor->monitors = g_list_delete_link (union_monitor->monitors, l);
 408
 409   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_added, union_monitor);
 410   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_removed, union_monitor);
 411   g_signal_handlers_disconnect_by_func (child_monitor, child_volume_changed, union_monitor);
 412   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_added, union_monitor);
 413   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_removed, union_monitor);
 414   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_pre_unmount, union_monitor);
 415   g_signal_handlers_disconnect_by_func (child_monitor, child_mount_changed, union_monitor);
 416   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_connected, union_monitor);
 417   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_disconnected, union_monitor);
 418   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_changed, union_monitor);
 419   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_eject_button, union_monitor);
 420   g_signal_handlers_disconnect_by_func (child_monitor, child_drive_stop_button, union_monitor);
 421 }
 422
 423 static GType
 424 get_default_native_class (gpointer data)
 425 {
 426   return _g_io_module_get_default_type (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME,
 427                                         "GIO_USE_VOLUME_MONITOR",
 428                                         G_STRUCT_OFFSET (GVolumeMonitorClass, is_supported));
 429 }
 430
 431 /* We return the class, with a ref taken.
 432  * This way we avoid unloading the class/module
 433  * between selecting the type and creating the
 434  * instance on the first call.
 435  */
 436 static GNativeVolumeMonitorClass *
 437 get_native_class (void)
 438 {
 439   static GOnce once_init = G_ONCE_INIT;
 440   GTypeClass *type_class;
 441
 442   type_class = NULL;
 443   g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class);
 444
 445   if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID))
 446     type_class = g_type_class_ref ((GType)once_init.retval);
 447
 448   return (GNativeVolumeMonitorClass *)type_class;
 449 }
 450
 451 static void
 452 g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
 453 {
 454 }
 455
 456 static void
 457 populate_union_monitor (GUnionVolumeMonitor *union_monitor)
 458 {
 459   GVolumeMonitor *monitor;
 460   GNativeVolumeMonitorClass *native_class;
 461   GVolumeMonitorClass *klass;
 462   GIOExtensionPoint *ep;
 463   GIOExtension *extension;
 464   GList *l;
 465
 466   native_class = get_native_class ();
 467
 468   if (native_class != NULL)
 469     {
 470       monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL);
 471       g_union_volume_monitor_add_monitor (union_monitor, monitor);
 472       g_object_unref (monitor);
 473       g_type_class_unref (native_class);
 474     }
 475
 476   ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
 477   for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
 478     {
 479       extension = l->data;
 480
 481       klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
 482       if (klass->is_supported == NULL || klass->is_supported())
 483         {
 484           monitor = g_object_new (g_io_extension_get_type (extension), NULL);
 485           g_union_volume_monitor_add_monitor (union_monitor, monitor);
 486           g_object_unref (monitor);
 487         }
 488       g_type_class_unref (klass);
 489     }
 490 }
 491
 492 static GUnionVolumeMonitor *
 493 g_union_volume_monitor_new (void)
 494 {
 495   GUnionVolumeMonitor *monitor;
 496
 497   monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL);
 498
 499   return monitor;
 500 }
 501
 502 /**
 503  * g_volume_monitor_get:
 504  *
 505  * Gets the volume monitor used by gio.
 506  *
 507  * Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call
 508  *    g_object_unref() when done with it.
 509  **/
 510 GVolumeMonitor *
 511 g_volume_monitor_get (void)
 512 {
 513   GVolumeMonitor *vm;
 514
 515   g_rec_mutex_lock (&the_volume_monitor_mutex);
 516
 517   if (the_volume_monitor)
 518     vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
 519   else
 520     {
 521       the_volume_monitor = g_union_volume_monitor_new ();
 522       populate_union_monitor (the_volume_monitor);
 523       vm = G_VOLUME_MONITOR (the_volume_monitor);
 524     }
 525
 526   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 527
 528   return vm;
 529 }
 530
 531 GMount *
 532 _g_mount_get_for_mount_path (const gchar  *mount_path,
 533                              GCancellable *cancellable)
 534 {
 535   GNativeVolumeMonitorClass *klass;
 536   GMount *mount;
 537
 538   klass = get_native_class ();
 539   if (klass == NULL)
 540     return NULL;
 541
 542   mount = NULL;
 543
 544   if (klass->get_mount_for_mount_path)
 545     mount = klass->get_mount_for_mount_path (mount_path, cancellable);
 546
 547   /* TODO: How do we know this succeeded? Keep in mind that the native
 548    *       volume monitor may fail (e.g. not being able to connect to
 549    *       udisks). Is the get_mount_for_mount_path() method allowed to
 550    *       return NULL? Seems like it is ... probably the method needs
 551    *       to take a boolean and write if it succeeds or not.. Messy.
 552    *       Very messy.
 553    */
 554
 555   g_type_class_unref (klass);
 556
 557   return mount;
 558 }
 559
 560 /**
 561  * g_volume_monitor_adopt_orphan_mount:
 562  * @mount: a #GMount object to find a parent for
 563  *
 564  * This function should be called by any #GVolumeMonitor
 565  * implementation when a new #GMount object is created that is not
 566  * associated with a #GVolume object. It must be called just before
 567  * emitting the @mount_added signal.
 568  *
 569  * If the return value is not %NULL, the caller must associate the
 570  * returned #GVolume object with the #GMount. This involves returning
 571  * it in its g_mount_get_volume() implementation. The caller must
 572  * also listen for the "removed" signal on the returned object
 573  * and give up its reference when handling that signal
 574  *
 575  * Similarly, if implementing g_volume_monitor_adopt_orphan_mount(),
 576  * the implementor must take a reference to @mount and return it in
 577  * its g_volume_get_mount() implemented. Also, the implementor must
 578  * listen for the "unmounted" signal on @mount and give up its
 579  * reference upon handling that signal.
 580  *
 581  * There are two main use cases for this function.
 582  *
 583  * One is when implementing a user space file system driver that reads
 584  * blocks of a block device that is already represented by the native
 585  * volume monitor (for example a CD Audio file system driver). Such
 586  * a driver will generate its own #GMount object that needs to be
 587  * associated with the #GVolume object that represents the volume.
 588  *
 589  * The other is for implementing a #GVolumeMonitor whose sole purpose
 590  * is to return #GVolume objects representing entries in the users
 591  * "favorite servers" list or similar.
 592  *
 593  * Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL
 594  * if no wants to adopt the #GMount.
 595  *
 596  * Deprecated: 2.20: Instead of using this function, #GVolumeMonitor
 597  * implementations should instead create shadow mounts with the URI of
 598  * the mount they intend to adopt. See the proxy volume monitor in
 599  * gvfs for an example of this. Also see g_mount_is_shadowed(),
 600  * g_mount_shadow() and g_mount_unshadow() functions.
 601  */
 602 GVolume *
 603 g_volume_monitor_adopt_orphan_mount (GMount *mount)
 604 {
 605   GVolumeMonitor *child_monitor;
 606   GVolumeMonitorClass *child_monitor_class;
 607   GVolume *volume;
 608   GList *l;
 609
 610   g_return_val_if_fail (mount != NULL, NULL);
 611
 612   if (the_volume_monitor == NULL)
 613     return NULL;
 614
 615   volume = NULL;
 616
 617   g_rec_mutex_lock (&the_volume_monitor_mutex);
 618
 619   for (l = the_volume_monitor->monitors; l != NULL; l = l->next)
 620     {
 621       child_monitor = l->data;
 622       child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor);
 623
 624       if (child_monitor_class->adopt_orphan_mount != NULL)
 625         {
 626           volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
 627           if (volume != NULL)
 628             break;
 629         }
 630     }
 631
 632   g_rec_mutex_unlock (&the_volume_monitor_mutex);
 633
 634   return volume;
 635 }