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