doc: Clarify documentation regarding g_file_replace and etags
[platform/upstream/glib.git] / 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 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   GNativeVolumeMonitorClass *klass, *native_class, **native_class_out;
427   const char *use_this;
428   GIOExtensionPoint *ep;
429   GIOExtension *extension;
430   GList *l;
431
432   native_class_out = data;
433   
434   use_this = g_getenv ("GIO_USE_VOLUME_MONITOR");
435   
436   /* Ensure vfs in modules loaded */
437   _g_io_modules_ensure_loaded ();
438
439   ep = g_io_extension_point_lookup (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME);
440
441   native_class = NULL;
442   if (use_this)
443     {
444       extension = g_io_extension_point_get_extension_by_name (ep, use_this);
445       if (extension)
446         {
447           klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
448           if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
449             native_class = klass;
450           else
451             g_type_class_unref (klass);
452         }
453     }
454
455   if (native_class == NULL)
456     {
457       for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
458         {
459           extension = l->data;
460           klass = G_NATIVE_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
461           if (G_VOLUME_MONITOR_CLASS (klass)->is_supported())
462             {
463               native_class = klass;
464               break;
465             }
466           else
467             g_type_class_unref (klass);
468         }
469     }
470  
471   if (native_class)
472     {
473       *native_class_out = native_class;
474       return G_TYPE_FROM_CLASS (native_class);
475     }
476   else
477     return G_TYPE_INVALID;
478 }
479
480 /* We return the class, with a ref taken.
481  * This way we avoid unloading the class/module
482  * between selecting the type and creating the
483  * instance on the first call.
484  */
485 static GNativeVolumeMonitorClass *
486 get_native_class (void)
487 {
488   static GOnce once_init = G_ONCE_INIT;
489   GTypeClass *type_class;
490
491   type_class = NULL;
492   g_once (&once_init, (GThreadFunc)get_default_native_class, &type_class);
493
494   if (type_class == NULL && once_init.retval != GUINT_TO_POINTER(G_TYPE_INVALID))
495     type_class = g_type_class_ref ((GType)once_init.retval);
496   
497   return (GNativeVolumeMonitorClass *)type_class;
498 }
499
500 static void
501 g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
502 {
503 }
504
505 static void
506 populate_union_monitor (GUnionVolumeMonitor *union_monitor)
507 {
508   GVolumeMonitor *monitor;
509   GNativeVolumeMonitorClass *native_class;
510   GVolumeMonitorClass *klass;
511   GIOExtensionPoint *ep;
512   GIOExtension *extension;
513   GList *l;
514
515   native_class = get_native_class ();
516
517   if (native_class != NULL)
518     {
519       monitor = g_object_new (G_TYPE_FROM_CLASS (native_class), NULL);
520       g_union_volume_monitor_add_monitor (union_monitor, monitor);
521       g_object_unref (monitor);
522       g_type_class_unref (native_class);
523     }
524
525   ep = g_io_extension_point_lookup (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
526   for (l = g_io_extension_point_get_extensions (ep); l != NULL; l = l->next)
527     {
528       extension = l->data;
529       
530       klass = G_VOLUME_MONITOR_CLASS (g_io_extension_ref_class (extension));
531       if (klass->is_supported == NULL || klass->is_supported())
532         {
533           monitor = g_object_new (g_io_extension_get_type (extension), NULL);
534           g_union_volume_monitor_add_monitor (union_monitor, monitor);
535           g_object_unref (monitor);
536         }
537       g_type_class_unref (klass);
538     }
539 }
540
541 static GUnionVolumeMonitor *
542 g_union_volume_monitor_new (void)
543 {
544   GUnionVolumeMonitor *monitor;
545
546   monitor = g_object_new (G_TYPE_UNION_VOLUME_MONITOR, NULL);
547   
548   return monitor;
549 }
550
551 /**
552  * g_volume_monitor_get:
553  * 
554  * Gets the volume monitor used by gio.
555  *
556  * Returns: (transfer full): a reference to the #GVolumeMonitor used by gio. Call
557  *    g_object_unref() when done with it.
558  **/
559 GVolumeMonitor *
560 g_volume_monitor_get (void)
561 {
562   GVolumeMonitor *vm;
563   
564   g_rec_mutex_lock (&the_volume_monitor_mutex);
565
566   if (the_volume_monitor)
567     vm = G_VOLUME_MONITOR (g_object_ref (the_volume_monitor));
568   else
569     {
570       the_volume_monitor = g_union_volume_monitor_new ();
571       populate_union_monitor (the_volume_monitor);
572       vm = G_VOLUME_MONITOR (the_volume_monitor);
573     }
574   
575   g_rec_mutex_unlock (&the_volume_monitor_mutex);
576
577   return vm;
578 }
579
580 GMount *
581 _g_mount_get_for_mount_path (const gchar  *mount_path,
582                              GCancellable *cancellable)
583 {
584   GNativeVolumeMonitorClass *klass;
585   GMount *mount;
586   
587   klass = get_native_class ();
588   if (klass == NULL)
589     return NULL;
590
591   mount = NULL;
592
593   if (klass->get_mount_for_mount_path)
594     {
595       g_rec_mutex_lock (&the_volume_monitor_mutex);
596       mount = klass->get_mount_for_mount_path (mount_path, cancellable);
597       g_rec_mutex_unlock (&the_volume_monitor_mutex);
598     }
599
600   /* TODO: How do we know this succeeded? Keep in mind that the native
601    *       volume monitor may fail (e.g. not being able to connect to
602    *       hald). Is the get_mount_for_mount_path() method allowed to
603    *       return NULL? Seems like it is ... probably the method needs
604    *       to take a boolean and write if it succeeds or not.. Messy.
605    *       Very messy.
606    */
607   
608   g_type_class_unref (klass);
609
610   return mount;
611 }
612
613 /**
614  * g_volume_monitor_adopt_orphan_mount:
615  * @mount: a #GMount object to find a parent for
616  *
617  * This function should be called by any #GVolumeMonitor
618  * implementation when a new #GMount object is created that is not
619  * associated with a #GVolume object. It must be called just before
620  * emitting the @mount_added signal.
621  *
622  * If the return value is not %NULL, the caller must associate the
623  * returned #GVolume object with the #GMount. This involves returning
624  * it in its g_mount_get_volume() implementation. The caller must
625  * also listen for the "removed" signal on the returned object
626  * and give up its reference when handling that signal
627  * 
628  * Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
629  * the implementor must take a reference to @mount and return it in
630  * its g_volume_get_mount() implemented. Also, the implementor must
631  * listen for the "unmounted" signal on @mount and give up its
632  * reference upon handling that signal.
633  *
634  * There are two main use cases for this function.
635  *
636  * One is when implementing a user space file system driver that reads
637  * blocks of a block device that is already represented by the native
638  * volume monitor (for example a CD Audio file system driver). Such
639  * a driver will generate its own #GMount object that needs to be
640  * associated with the #GVolume object that represents the volume.
641  *
642  * The other is for implementing a #GVolumeMonitor whose sole purpose
643  * is to return #GVolume objects representing entries in the users
644  * "favorite servers" list or similar.
645  *
646  * Returns: (transfer full): the #GVolume object that is the parent for @mount or %NULL
647  * if no wants to adopt the #GMount.
648  *
649  * Deprecated: 2.20: Instead of using this function, #GVolumeMonitor
650  * implementations should instead create shadow mounts with the URI of
651  * the mount they intend to adopt. See the proxy volume monitor in
652  * gvfs for an example of this. Also see g_mount_is_shadowed(),
653  * g_mount_shadow() and g_mount_unshadow() functions.
654  */
655 GVolume *
656 g_volume_monitor_adopt_orphan_mount (GMount *mount)
657 {
658   GVolumeMonitor *child_monitor;
659   GVolumeMonitorClass *child_monitor_class;
660   GVolume *volume;
661   GList *l;
662
663   g_return_val_if_fail (mount != NULL, NULL);
664
665   if (the_volume_monitor == NULL)
666     return NULL;
667
668   volume = NULL;
669   
670   g_rec_mutex_lock (&the_volume_monitor_mutex);
671
672   for (l = the_volume_monitor->monitors; l != NULL; l = l->next)
673     {
674       child_monitor = l->data;
675       child_monitor_class = G_VOLUME_MONITOR_GET_CLASS (child_monitor);
676
677       if (child_monitor_class->adopt_orphan_mount != NULL)
678         {
679           volume = child_monitor_class->adopt_orphan_mount (mount, child_monitor);
680           if (volume != NULL)
681             break;
682         }
683     }
684   
685   g_rec_mutex_unlock (&the_volume_monitor_mutex);
686
687   return volume;
688 }