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 (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 | |
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 (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 | |
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 (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 | |
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 (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 | |
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 (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 | |
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 (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 | |
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 (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 | |
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 (instance: union_monitor, |
257 | detailed_signal: "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 (instance: union_monitor, |
267 | detailed_signal: "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 (instance: union_monitor, |
277 | detailed_signal: "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 (instance: union_monitor, |
287 | detailed_signal: "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 (instance: union_monitor, |
297 | detailed_signal: "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 (instance: union_monitor, |
307 | detailed_signal: "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 (instance: union_monitor, |
318 | detailed_signal: "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 (instance: union_monitor, |
328 | detailed_signal: "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 (instance: union_monitor, |
338 | detailed_signal: "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 (instance: union_monitor, |
348 | detailed_signal: "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 (instance: union_monitor, |
358 | detailed_signal: "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 (instance: union_monitor, |
368 | detailed_signal: "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 (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 | |
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 (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 | |
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 | 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 | */ |
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 (type: (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, 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 | |
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 (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 | |
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 (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 | */ |
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 (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 | |