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
40struct _GUnionVolumeMonitor {
41 GVolumeMonitor parent;
42
43 GList *monitors;
44};
45
46static 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
51G_DEFINE_TYPE (GUnionVolumeMonitor, g_union_volume_monitor, G_TYPE_VOLUME_MONITOR)
52
53static GRecMutex the_volume_monitor_mutex;
54
55static GUnionVolumeMonitor *the_volume_monitor = NULL;
56
57static void
58g_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 (union_monitor: monitor,
69 child_monitor);
70 g_object_unref (object: child_monitor);
71 }
72
73 G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->finalize (object);
74}
75
76static void
77g_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 (rec_mutex: &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 (rec_mutex: &the_volume_monitor_mutex);
95
96 G_OBJECT_CLASS (g_union_volume_monitor_parent_class)->dispose (object);
97}
98
99static GList *
100get_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 (rec_mutex: &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 (list1: res, list2: g_volume_monitor_get_mounts (volume_monitor: child_monitor));
118 }
119
120 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
121
122 return res;
123}
124
125static GList *
126get_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 (rec_mutex: &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 (list1: res, list2: g_volume_monitor_get_volumes (volume_monitor: child_monitor));
144 }
145
146 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
147
148 return res;
149}
150
151static GList *
152get_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 (rec_mutex: &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 (list1: res, list2: g_volume_monitor_get_connected_drives (volume_monitor: child_monitor));
170 }
171
172 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
173
174 return res;
175}
176
177static GVolume *
178get_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 (rec_mutex: &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 (volume_monitor: child_monitor, uuid);
196 if (volume != NULL)
197 break;
198
199 }
200
201 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
202
203 return volume;
204}
205
206static GMount *
207get_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 (rec_mutex: &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 (volume_monitor: child_monitor, uuid);
225 if (mount != NULL)
226 break;
227
228 }
229
230 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
231
232 return mount;
233}
234
235static void
236g_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
251static void
252child_volume_added (GVolumeMonitor *child_monitor,
253 GVolume *child_volume,
254 GUnionVolumeMonitor *union_monitor)
255{
256 g_signal_emit_by_name (instance: union_monitor,
257 detailed_signal: "volume-added",
258 child_volume);
259}
260
261static void
262child_volume_removed (GVolumeMonitor *child_monitor,
263 GVolume *child_volume,
264 GUnionVolumeMonitor *union_monitor)
265{
266 g_signal_emit_by_name (instance: union_monitor,
267 detailed_signal: "volume-removed",
268 child_volume);
269}
270
271static void
272child_volume_changed (GVolumeMonitor *child_monitor,
273 GVolume *child_volume,
274 GUnionVolumeMonitor *union_monitor)
275{
276 g_signal_emit_by_name (instance: union_monitor,
277 detailed_signal: "volume-changed",
278 child_volume);
279}
280
281static void
282child_mount_added (GVolumeMonitor *child_monitor,
283 GMount *child_mount,
284 GUnionVolumeMonitor *union_monitor)
285{
286 g_signal_emit_by_name (instance: union_monitor,
287 detailed_signal: "mount-added",
288 child_mount);
289}
290
291static void
292child_mount_removed (GVolumeMonitor *child_monitor,
293 GMount *child_mount,
294 GUnionVolumeMonitor *union_monitor)
295{
296 g_signal_emit_by_name (instance: union_monitor,
297 detailed_signal: "mount-removed",
298 child_mount);
299}
300
301static void
302child_mount_pre_unmount (GVolumeMonitor *child_monitor,
303 GMount *child_mount,
304 GUnionVolumeMonitor *union_monitor)
305{
306 g_signal_emit_by_name (instance: union_monitor,
307 detailed_signal: "mount-pre-unmount",
308 child_mount);
309}
310
311
312static void
313child_mount_changed (GVolumeMonitor *child_monitor,
314 GMount *child_mount,
315 GUnionVolumeMonitor *union_monitor)
316{
317 g_signal_emit_by_name (instance: union_monitor,
318 detailed_signal: "mount-changed",
319 child_mount);
320}
321
322static void
323child_drive_connected (GVolumeMonitor *child_monitor,
324 GDrive *child_drive,
325 GUnionVolumeMonitor *union_monitor)
326{
327 g_signal_emit_by_name (instance: union_monitor,
328 detailed_signal: "drive-connected",
329 child_drive);
330}
331
332static void
333child_drive_disconnected (GVolumeMonitor *child_monitor,
334 GDrive *child_drive,
335 GUnionVolumeMonitor *union_monitor)
336{
337 g_signal_emit_by_name (instance: union_monitor,
338 detailed_signal: "drive-disconnected",
339 child_drive);
340}
341
342static void
343child_drive_changed (GVolumeMonitor *child_monitor,
344 GDrive *child_drive,
345 GUnionVolumeMonitor *union_monitor)
346{
347 g_signal_emit_by_name (instance: union_monitor,
348 detailed_signal: "drive-changed",
349 child_drive);
350}
351
352static void
353child_drive_eject_button (GVolumeMonitor *child_monitor,
354 GDrive *child_drive,
355 GUnionVolumeMonitor *union_monitor)
356{
357 g_signal_emit_by_name (instance: union_monitor,
358 detailed_signal: "drive-eject-button",
359 child_drive);
360}
361
362static void
363child_drive_stop_button (GVolumeMonitor *child_monitor,
364 GDrive *child_drive,
365 GUnionVolumeMonitor *union_monitor)
366{
367 g_signal_emit_by_name (instance: union_monitor,
368 detailed_signal: "drive-stop-button",
369 child_drive);
370}
371
372static void
373g_union_volume_monitor_add_monitor (GUnionVolumeMonitor *union_monitor,
374 GVolumeMonitor *volume_monitor)
375{
376 if (g_list_find (list: union_monitor->monitors, data: volume_monitor))
377 return;
378
379 union_monitor->monitors =
380 g_list_prepend (list: 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
397static void
398g_union_volume_monitor_remove_monitor (GUnionVolumeMonitor *union_monitor,
399 GVolumeMonitor *child_monitor)
400{
401 GList *l;
402
403 l = g_list_find (list: union_monitor->monitors, data: child_monitor);
404 if (l == NULL)
405 return;
406
407 union_monitor->monitors = g_list_delete_link (list: union_monitor->monitors, link_: 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
423static GType
424get_default_native_class (gpointer data)
425{
426 return _g_io_module_get_default_type (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME,
427 envvar: "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 */
436static GNativeVolumeMonitorClass *
437get_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 (type: (GType)once_init.retval);
447
448 return (GNativeVolumeMonitorClass *)type_class;
449}
450
451static void
452g_union_volume_monitor_init (GUnionVolumeMonitor *union_monitor)
453{
454}
455
456static void
457populate_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, volume_monitor: monitor);
472 g_object_unref (object: monitor);
473 g_type_class_unref (g_class: 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 (extension_point: 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 (object_type: g_io_extension_get_type (extension), NULL);
485 g_union_volume_monitor_add_monitor (union_monitor, volume_monitor: monitor);
486 g_object_unref (object: monitor);
487 }
488 g_type_class_unref (g_class: klass);
489 }
490}
491
492static GUnionVolumeMonitor *
493g_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 **/
510GVolumeMonitor *
511g_volume_monitor_get (void)
512{
513 GVolumeMonitor *vm;
514
515 g_rec_mutex_lock (rec_mutex: &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 (union_monitor: the_volume_monitor);
523 vm = G_VOLUME_MONITOR (the_volume_monitor);
524 }
525
526 g_rec_mutex_unlock (rec_mutex: &the_volume_monitor_mutex);
527
528 return vm;
529}
530
531GMount *
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 (g_class: 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 */
602GVolume *
603g_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 (rec_mutex: &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 (rec_mutex: &the_volume_monitor_mutex);
633
634 return volume;
635}
636

source code of gtk/subprojects/glib/gio/gunionvolumemonitor.c