1 /* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 *
5 * SPDX-License-Identifier: LGPL-2.1-or-later
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 */
22
23 #include "config.h"
24
25 #include "gioenumtypes.h"
26 #include "glocalfilemonitor.h"
27 #include "giomodule-priv.h"
28 #include "gioerror.h"
29 #include "glibintl.h"
30 #include "glocalfile.h"
31 #include "glib-private.h"
32
33 #include <string.h>
34
35 #define DEFAULT_RATE_LIMIT 800 * G_TIME_SPAN_MILLISECOND
36 #define VIRTUAL_CHANGES_DONE_DELAY 2 * G_TIME_SPAN_SECOND
37
38 /* GFileMonitorSource is a GSource responsible for emitting the changed
39 * signals in the owner-context of the GFileMonitor.
40 *
41 * It contains functionality for cross-thread queuing of events. It
42 * also handles merging of CHANGED events and emission of CHANGES_DONE
43 * events.
44 *
45 * We use the "priv" pointer in the external struct to store it.
46 */
47 struct _GFileMonitorSource {
48 GSource source;
49
50 GMutex lock;
51 GWeakRef instance_ref;
52 GFileMonitorFlags flags;
53 gchar *dirname;
54 gchar *basename;
55 gchar *filename;
56 GSequence *pending_changes; /* sorted by ready time */
57 GHashTable *pending_changes_table;
58 GQueue event_queue;
59 gint64 rate_limit;
60 };
61
62 /* PendingChange is a struct to keep track of a file that needs to have
63 * (at least) a CHANGES_DONE_HINT event sent for it in the near future.
64 *
65 * If 'dirty' is TRUE then a CHANGED event also needs to be sent.
66 *
67 * last_emission is the last time a CHANGED event was emitted. It is
68 * used to calculate the time to send the next event.
69 */
70 typedef struct {
71 gchar *child;
72 guint64 last_emission : 63;
73 guint64 dirty : 1;
74 } PendingChange;
75
76 /* QueuedEvent is a signal that will be sent immediately, as soon as the
77 * source gets a chance to dispatch. The existence of any queued event
78 * implies that the source is ready now.
79 */
80 typedef struct
81 {
82 GFileMonitorEvent event_type;
83 GFile *child;
84 GFile *other;
85 } QueuedEvent;
86
87 static gint64
88 pending_change_get_ready_time (const PendingChange *change,
89 GFileMonitorSource *fms)
90 {
91 if (change->dirty)
92 return change->last_emission + fms->rate_limit;
93 else
94 return change->last_emission + VIRTUAL_CHANGES_DONE_DELAY;
95 }
96
97 static int
98 pending_change_compare_ready_time (gconstpointer a_p,
99 gconstpointer b_p,
100 gpointer user_data)
101 {
102 GFileMonitorSource *fms = user_data;
103 const PendingChange *a = a_p;
104 const PendingChange *b = b_p;
105 gint64 ready_time_a;
106 gint64 ready_time_b;
107
108 ready_time_a = pending_change_get_ready_time (a, fms);
109 ready_time_b = pending_change_get_ready_time (b, fms);
110
111 if (ready_time_a < ready_time_b)
112 return -1;
113 else
114 return ready_time_a > ready_time_b;
115 }
116
117 static void
118 pending_change_free (gpointer data)
119 {
120 PendingChange *change = data;
121
122 g_free (change->child);
123
124 g_slice_free (PendingChange, change);
125 }
126
127 static void
128 queued_event_free (QueuedEvent *event)
129 {
130 g_object_unref (event->child);
131 if (event->other)
132 g_object_unref (event->other);
133
134 g_slice_free (QueuedEvent, event);
135 }
136
137 static gint64
138 g_file_monitor_source_get_ready_time (GFileMonitorSource *fms)
139 {
140 GSequenceIter *iter;
141
142 if (fms->event_queue.length)
143 return 0;
144
145 iter = g_sequence_get_begin_iter (fms->pending_changes);
146 if (g_sequence_iter_is_end (iter))
147 return -1;
148
149 return pending_change_get_ready_time (g_sequence_get (iter), fms);
150 }
151
152 static void
153 g_file_monitor_source_update_ready_time (GFileMonitorSource *fms)
154 {
155 g_source_set_ready_time ((GSource *) fms, g_file_monitor_source_get_ready_time (fms));
156 }
157
158 static GSequenceIter *
159 g_file_monitor_source_find_pending_change (GFileMonitorSource *fms,
160 const gchar *child)
161 {
162 return g_hash_table_lookup (fms->pending_changes_table, child);
163 }
164
165 static void
166 g_file_monitor_source_add_pending_change (GFileMonitorSource *fms,
167 const gchar *child,
168 gint64 now)
169 {
170 PendingChange *change;
171 GSequenceIter *iter;
172
173 change = g_slice_new (PendingChange);
174 change->child = g_strdup (child);
175 change->last_emission = now;
176 change->dirty = FALSE;
177
178 iter = g_sequence_insert_sorted (fms->pending_changes, change, pending_change_compare_ready_time, fms);
179 g_hash_table_insert (fms->pending_changes_table, change->child, iter);
180 }
181
182 static gboolean
183 g_file_monitor_source_set_pending_change_dirty (GFileMonitorSource *fms,
184 GSequenceIter *iter)
185 {
186 PendingChange *change;
187
188 change = g_sequence_get (iter);
189
190 /* if it was already dirty then this change is 'uninteresting' */
191 if (change->dirty)
192 return FALSE;
193
194 change->dirty = TRUE;
195
196 g_sequence_sort_changed (iter, pending_change_compare_ready_time, fms);
197
198 return TRUE;
199 }
200
201 static gboolean
202 g_file_monitor_source_get_pending_change_dirty (GFileMonitorSource *fms,
203 GSequenceIter *iter)
204 {
205 PendingChange *change;
206
207 change = g_sequence_get (iter);
208
209 return change->dirty;
210 }
211
212 static void
213 g_file_monitor_source_remove_pending_change (GFileMonitorSource *fms,
214 GSequenceIter *iter,
215 const gchar *child)
216 {
217 /* must remove the hash entry first -- its key is owned by the data
218 * which will be freed when removing the sequence iter
219 */
220 g_hash_table_remove (fms->pending_changes_table, child);
221 g_sequence_remove (iter);
222 }
223
224 static void
225 g_file_monitor_source_queue_event (GFileMonitorSource *fms,
226 GFileMonitorEvent event_type,
227 const gchar *child,
228 GFile *other)
229 {
230 QueuedEvent *event;
231
232 event = g_slice_new (QueuedEvent);
233 event->event_type = event_type;
234 if (child != NULL && fms->dirname != NULL)
235 event->child = g_local_file_new_from_dirname_and_basename (fms->dirname, child);
236 else if (child != NULL)
237 {
238 gchar *dirname = g_path_get_dirname (fms->filename);
239 event->child = g_local_file_new_from_dirname_and_basename (dirname, child);
240 g_free (dirname);
241 }
242 else if (fms->dirname)
243 event->child = _g_local_file_new (fms->dirname);
244 else if (fms->filename)
245 event->child = _g_local_file_new (fms->filename);
246 event->other = other;
247 if (other)
248 g_object_ref (other);
249
250 g_queue_push_tail (&fms->event_queue, event);
251 }
252
253 static gboolean
254 g_file_monitor_source_file_changed (GFileMonitorSource *fms,
255 const gchar *child,
256 gint64 now)
257 {
258 GSequenceIter *pending;
259 gboolean interesting;
260
261 pending = g_file_monitor_source_find_pending_change (fms, child);
262
263 /* If there is no pending change, emit one and create a record,
264 * else: just mark the existing record as dirty.
265 */
266 if (!pending)
267 {
268 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGED, child, NULL);
269 g_file_monitor_source_add_pending_change (fms, child, now);
270 interesting = TRUE;
271 }
272 else
273 interesting = g_file_monitor_source_set_pending_change_dirty (fms, pending);
274
275 g_file_monitor_source_update_ready_time (fms);
276
277 return interesting;
278 }
279
280 static void
281 g_file_monitor_source_file_changes_done (GFileMonitorSource *fms,
282 const gchar *child)
283 {
284 GSequenceIter *pending;
285
286 pending = g_file_monitor_source_find_pending_change (fms, child);
287 if (pending)
288 {
289 /* If it is dirty, make sure we push out the last CHANGED event */
290 if (g_file_monitor_source_get_pending_change_dirty (fms, pending))
291 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGED, child, NULL);
292
293 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, child, NULL);
294 g_file_monitor_source_remove_pending_change (fms, pending, child);
295 }
296 }
297
298 static void
299 g_file_monitor_source_file_created (GFileMonitorSource *fms,
300 const gchar *child,
301 gint64 event_time)
302 {
303 /* Unlikely, but if we have pending changes for this filename, make
304 * sure we flush those out first, before creating the new ones.
305 */
306 g_file_monitor_source_file_changes_done (fms, child);
307
308 /* Emit CREATE and add a pending changes record */
309 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CREATED, child, NULL);
310 g_file_monitor_source_add_pending_change (fms, child, event_time);
311 }
312
313 static void
314 g_file_monitor_source_send_event (GFileMonitorSource *fms,
315 GFileMonitorEvent event_type,
316 const gchar *child,
317 GFile *other)
318 {
319 /* always flush any pending changes before we queue a new event */
320 g_file_monitor_source_file_changes_done (fms, child);
321 g_file_monitor_source_queue_event (fms, event_type, child, other);
322 }
323
324 static void
325 g_file_monitor_source_send_synthetic_created (GFileMonitorSource *fms,
326 const gchar *child)
327 {
328 g_file_monitor_source_file_changes_done (fms, child);
329 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CREATED, child, NULL);
330 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, child, NULL);
331 }
332
333 #ifndef G_DISABLE_ASSERT
334 static gboolean
335 is_basename (const gchar *name)
336 {
337 if (name[0] == '.' && ((name[1] == '.' && name[2] == '\0') || name[1] == '\0'))
338 return FALSE;
339
340 return !strchr (name, '/');
341 }
342 #endif /* !G_DISABLE_ASSERT */
343
344 gboolean
345 g_file_monitor_source_handle_event (GFileMonitorSource *fms,
346 GFileMonitorEvent event_type,
347 const gchar *child,
348 const gchar *rename_to,
349 GFile *other,
350 gint64 event_time)
351 {
352 gboolean interesting = TRUE;
353
354 g_assert (!child || is_basename (child));
355 g_assert (!rename_to || is_basename (rename_to));
356
357 if (fms->basename && (!child || !g_str_equal (child, fms->basename))
358 && (!rename_to || !g_str_equal (rename_to, fms->basename)))
359 return TRUE;
360
361 g_mutex_lock (&fms->lock);
362
363 /* NOTE:
364 *
365 * We process events even if the file monitor has already been disposed.
366 * The reason is that we must not take a reference to the instance here as
367 * destroying it from the event handling thread will lead to a deadlock when
368 * taking the lock in _ih_sub_cancel.
369 *
370 * This results in seemingly-unbounded growth of the `event_queue` with the
371 * calls to `g_file_monitor_source_queue_event()`. However, each of those sets
372 * the ready time on the #GSource, which means that it will be dispatched in
373 * a subsequent iteration of the #GMainContext it’s attached to. At that
374 * point, `g_file_monitor_source_dispatch()` will return %FALSE, and this will
375 * trigger finalisation of the source. That will clear the `event_queue`.
376 *
377 * If the source is no longer attached, this will return early to prevent
378 * unbounded queueing.
379 */
380 if (g_source_is_destroyed ((GSource *) fms))
381 {
382 g_mutex_unlock (&fms->lock);
383 return TRUE;
384 }
385
386 switch (event_type)
387 {
388 case G_FILE_MONITOR_EVENT_CREATED:
389 g_assert (!other && !rename_to);
390 g_file_monitor_source_file_created (fms, child, event_time);
391 break;
392
393 case G_FILE_MONITOR_EVENT_CHANGED:
394 g_assert (!other && !rename_to);
395 interesting = g_file_monitor_source_file_changed (fms, child, event_time);
396 break;
397
398 case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
399 g_assert (!other && !rename_to);
400 g_file_monitor_source_file_changes_done (fms, child);
401 break;
402
403 case G_FILE_MONITOR_EVENT_MOVED_IN:
404 g_assert (!rename_to);
405 if (fms->flags & G_FILE_MONITOR_WATCH_MOVES)
406 g_file_monitor_source_send_event (fms, G_FILE_MONITOR_EVENT_MOVED_IN, child, other);
407 else
408 g_file_monitor_source_send_synthetic_created (fms, child);
409 break;
410
411 case G_FILE_MONITOR_EVENT_MOVED_OUT:
412 g_assert (!rename_to);
413 if (fms->flags & G_FILE_MONITOR_WATCH_MOVES)
414 g_file_monitor_source_send_event (fms, G_FILE_MONITOR_EVENT_MOVED_OUT, child, other);
415 else if (other && (fms->flags & G_FILE_MONITOR_SEND_MOVED))
416 g_file_monitor_source_send_event (fms, G_FILE_MONITOR_EVENT_MOVED, child, other);
417 else
418 g_file_monitor_source_send_event (fms, G_FILE_MONITOR_EVENT_DELETED, child, NULL);
419 break;
420
421 case G_FILE_MONITOR_EVENT_RENAMED:
422 g_assert (!other && rename_to);
423 if (fms->flags & (G_FILE_MONITOR_WATCH_MOVES | G_FILE_MONITOR_SEND_MOVED))
424 {
425 GFile *other_file;
426 const gchar *dirname;
427 gchar *allocated_dirname = NULL;
428 GFileMonitorEvent event;
429
430 event = (fms->flags & G_FILE_MONITOR_WATCH_MOVES) ? G_FILE_MONITOR_EVENT_RENAMED : G_FILE_MONITOR_EVENT_MOVED;
431
432 if (fms->dirname != NULL)
433 dirname = fms->dirname;
434 else
435 {
436 allocated_dirname = g_path_get_dirname (fms->filename);
437 dirname = allocated_dirname;
438 }
439
440 other_file = g_local_file_new_from_dirname_and_basename (dirname, rename_to);
441 g_file_monitor_source_file_changes_done (fms, rename_to);
442 g_file_monitor_source_send_event (fms, event, child, other_file);
443
444 g_object_unref (other_file);
445 g_free (allocated_dirname);
446 }
447 else
448 {
449 g_file_monitor_source_send_event (fms, G_FILE_MONITOR_EVENT_DELETED, child, NULL);
450 g_file_monitor_source_send_synthetic_created (fms, rename_to);
451 }
452 break;
453
454 case G_FILE_MONITOR_EVENT_DELETED:
455 case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
456 case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
457 case G_FILE_MONITOR_EVENT_UNMOUNTED:
458 g_assert (!other && !rename_to);
459 g_file_monitor_source_send_event (fms, event_type, child, NULL);
460 break;
461
462 case G_FILE_MONITOR_EVENT_MOVED:
463 /* was never available in this API */
464 default:
465 g_assert_not_reached ();
466 }
467
468 g_file_monitor_source_update_ready_time (fms);
469
470 g_mutex_unlock (&fms->lock);
471
472 return interesting;
473 }
474
475 static gint64
476 g_file_monitor_source_get_rate_limit (GFileMonitorSource *fms)
477 {
478 gint64 rate_limit;
479
480 g_mutex_lock (&fms->lock);
481 rate_limit = fms->rate_limit;
482 g_mutex_unlock (&fms->lock);
483
484 return rate_limit;
485 }
486
487 static gboolean
488 g_file_monitor_source_set_rate_limit (GFileMonitorSource *fms,
489 gint64 rate_limit)
490 {
491 gboolean changed;
492
493 g_mutex_lock (&fms->lock);
494
495 if (rate_limit != fms->rate_limit)
496 {
497 fms->rate_limit = rate_limit;
498
499 g_sequence_sort (fms->pending_changes, pending_change_compare_ready_time, fms);
500 g_file_monitor_source_update_ready_time (fms);
501
502 changed = TRUE;
503 }
504 else
505 changed = FALSE;
506
507 g_mutex_unlock (&fms->lock);
508
509 return changed;
510 }
511
512 static gboolean
513 g_file_monitor_source_dispatch (GSource *source,
514 GSourceFunc callback,
515 gpointer user_data)
516 {
517 GFileMonitorSource *fms = (GFileMonitorSource *) source;
518 QueuedEvent *event;
519 GQueue event_queue;
520 gint64 now;
521 GFileMonitor *instance = NULL;
522
523 /* make sure the monitor still exists */
524 instance = g_weak_ref_get (&fms->instance_ref);
525 if (instance == NULL)
526 return FALSE;
527
528 now = g_source_get_time (source);
529
530 /* Acquire the lock once and grab all events in one go, handling the
531 * queued events first. This avoids strange possibilities in cases of
532 * long delays, such as CHANGED events coming before CREATED events.
533 *
534 * We do this by converting the applicable pending changes into queued
535 * events (after the ones already queued) and then stealing the entire
536 * event queue in one go.
537 */
538 g_mutex_lock (&fms->lock);
539
540 /* Create events for any pending changes that are due to fire */
541 while (!g_sequence_is_empty (fms->pending_changes))
542 {
543 GSequenceIter *iter = g_sequence_get_begin_iter (fms->pending_changes);
544 PendingChange *pending = g_sequence_get (iter);
545
546 /* We've gotten to a pending change that's not ready. Stop. */
547 if (pending_change_get_ready_time (pending, fms) > now)
548 break;
549
550 if (pending->dirty)
551 {
552 /* It's time to send another CHANGED and update the record */
553 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGED, pending->child, NULL);
554 pending->last_emission = now;
555 pending->dirty = FALSE;
556
557 g_sequence_sort_changed (iter, pending_change_compare_ready_time, fms);
558 }
559 else
560 {
561 /* It's time to send CHANGES_DONE and remove the pending record */
562 g_file_monitor_source_queue_event (fms, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, pending->child, NULL);
563 g_file_monitor_source_remove_pending_change (fms, iter, pending->child);
564 }
565 }
566
567 /* Steal the queue */
568 memcpy (&event_queue, &fms->event_queue, sizeof event_queue);
569 memset (&fms->event_queue, 0, sizeof fms->event_queue);
570
571 g_file_monitor_source_update_ready_time (fms);
572
573 g_mutex_unlock (&fms->lock);
574 g_clear_object (&instance);
575
576 /* We now have our list of events to deliver */
577 while ((event = g_queue_pop_head (&event_queue)))
578 {
579 /* an event handler could destroy 'instance', so check each time */
580 instance = g_weak_ref_get (&fms->instance_ref);
581 if (instance != NULL)
582 g_file_monitor_emit_event (instance, event->child, event->other, event->event_type);
583
584 g_clear_object (&instance);
585 queued_event_free (event);
586 }
587
588 return TRUE;
589 }
590
591 static void
592 g_file_monitor_source_dispose (GFileMonitorSource *fms)
593 {
594 GHashTableIter iter;
595 gpointer seqiter;
596 QueuedEvent *event;
597
598 g_mutex_lock (&fms->lock);
599
600 g_hash_table_iter_init (&iter, fms->pending_changes_table);
601 while (g_hash_table_iter_next (&iter, NULL, &seqiter))
602 {
603 g_hash_table_iter_remove (&iter);
604 g_sequence_remove (seqiter);
605 }
606
607 while ((event = g_queue_pop_head (&fms->event_queue)))
608 queued_event_free (event);
609
610 g_assert (g_sequence_is_empty (fms->pending_changes));
611 g_assert (g_hash_table_size (fms->pending_changes_table) == 0);
612 g_assert (fms->event_queue.length == 0);
613 g_weak_ref_set (&fms->instance_ref, NULL);
614
615 g_file_monitor_source_update_ready_time (fms);
616
617 g_source_destroy ((GSource *) fms);
618
619 g_mutex_unlock (&fms->lock);
620 }
621
622 static void
623 g_file_monitor_source_finalize (GSource *source)
624 {
625 GFileMonitorSource *fms = (GFileMonitorSource *) source;
626
627 /* should already have been cleared in dispose of the monitor */
628 g_assert (g_weak_ref_get (&fms->instance_ref) == NULL);
629 g_weak_ref_clear (&fms->instance_ref);
630
631 g_assert (g_sequence_is_empty (fms->pending_changes));
632 g_assert (g_hash_table_size (fms->pending_changes_table) == 0);
633 g_assert (fms->event_queue.length == 0);
634
635 g_hash_table_unref (fms->pending_changes_table);
636 g_sequence_free (fms->pending_changes);
637
638 g_free (fms->dirname);
639 g_free (fms->basename);
640 g_free (fms->filename);
641
642 g_mutex_clear (&fms->lock);
643 }
644
645 static guint
646 str_hash0 (gconstpointer str)
647 {
648 return str ? g_str_hash (str) : 0;
649 }
650
651 static gboolean
652 str_equal0 (gconstpointer a,
653 gconstpointer b)
654 {
655 return g_strcmp0 (a, b) == 0;
656 }
657
658 static GFileMonitorSource *
659 g_file_monitor_source_new (gpointer instance,
660 const gchar *filename,
661 gboolean is_directory,
662 GFileMonitorFlags flags)
663 {
664 static GSourceFuncs source_funcs = {
665 NULL, NULL,
666 g_file_monitor_source_dispatch,
667 g_file_monitor_source_finalize,
668 NULL, NULL
669 };
670 GFileMonitorSource *fms;
671 GSource *source;
672
673 source = g_source_new (&source_funcs, sizeof (GFileMonitorSource));
674 fms = (GFileMonitorSource *) source;
675
676 g_source_set_static_name (source, "GFileMonitorSource");
677
678 g_mutex_init (&fms->lock);
679 g_weak_ref_init (&fms->instance_ref, instance);
680 fms->pending_changes = g_sequence_new (pending_change_free);
681 fms->pending_changes_table = g_hash_table_new (str_hash0, str_equal0);
682 fms->rate_limit = DEFAULT_RATE_LIMIT;
683 fms->flags = flags;
684
685 if (is_directory)
686 {
687 fms->dirname = g_strdup (filename);
688 fms->basename = NULL;
689 fms->filename = NULL;
690 }
691 else if (flags & G_FILE_MONITOR_WATCH_HARD_LINKS)
692 {
693 fms->dirname = NULL;
694 fms->basename = NULL;
695 fms->filename = g_strdup (filename);
696 }
697 else
698 {
699 fms->dirname = g_path_get_dirname (filename);
700 fms->basename = g_path_get_basename (filename);
701 fms->filename = NULL;
702 }
703
704 return fms;
705 }
706
707 G_DEFINE_ABSTRACT_TYPE (GLocalFileMonitor, g_local_file_monitor, G_TYPE_FILE_MONITOR)
708
709 enum {
710 PROP_0,
711 PROP_RATE_LIMIT,
712 };
713
714 static void
715 g_local_file_monitor_get_property (GObject *object, guint prop_id,
716 GValue *value, GParamSpec *pspec)
717 {
718 GLocalFileMonitor *monitor = G_LOCAL_FILE_MONITOR (object);
719 gint64 rate_limit;
720
721 g_assert (prop_id == PROP_RATE_LIMIT);
722
723 rate_limit = g_file_monitor_source_get_rate_limit (monitor->source);
724 rate_limit /= G_TIME_SPAN_MILLISECOND;
725
726 g_value_set_int (value, rate_limit);
727 }
728
729 static void
730 g_local_file_monitor_set_property (GObject *object, guint prop_id,
731 const GValue *value, GParamSpec *pspec)
732 {
733 GLocalFileMonitor *monitor = G_LOCAL_FILE_MONITOR (object);
734 gint64 rate_limit;
735
736 g_assert (prop_id == PROP_RATE_LIMIT);
737
738 rate_limit = g_value_get_int (value);
739 rate_limit *= G_TIME_SPAN_MILLISECOND;
740
741 if (g_file_monitor_source_set_rate_limit (monitor->source, rate_limit))
742 g_object_notify (object, "rate-limit");
743 }
744
745 #ifndef G_OS_WIN32
746 static void
747 g_local_file_monitor_mounts_changed (GUnixMountMonitor *mount_monitor,
748 gpointer user_data)
749 {
750 GLocalFileMonitor *local_monitor = user_data;
751 GUnixMountEntry *mount;
752 gboolean is_mounted;
753 GFile *file;
754
755 /* Emulate unmount detection */
756 mount = g_unix_mount_at (local_monitor->source->dirname, NULL);
757
758 is_mounted = mount != NULL;
759
760 if (mount)
761 g_unix_mount_free (mount);
762
763 if (local_monitor->was_mounted != is_mounted)
764 {
765 if (local_monitor->was_mounted && !is_mounted)
766 {
767 file = g_file_new_for_path (local_monitor->source->dirname);
768 g_file_monitor_emit_event (G_FILE_MONITOR (local_monitor), file, NULL, G_FILE_MONITOR_EVENT_UNMOUNTED);
769 g_object_unref (file);
770 }
771 local_monitor->was_mounted = is_mounted;
772 }
773 }
774 #endif
775
776 static void
777 g_local_file_monitor_start (GLocalFileMonitor *local_monitor,
778 const gchar *filename,
779 gboolean is_directory,
780 GFileMonitorFlags flags,
781 GMainContext *context)
782 {
783 GLocalFileMonitorClass *class = G_LOCAL_FILE_MONITOR_GET_CLASS (local_monitor);
784 GFileMonitorSource *source;
785
786 g_return_if_fail (G_IS_LOCAL_FILE_MONITOR (local_monitor));
787
788 g_assert (!local_monitor->source);
789
790 source = g_file_monitor_source_new (local_monitor, filename, is_directory, flags);
791 local_monitor->source = source; /* owns the ref */
792
793 if (is_directory && !class->mount_notify && (flags & G_FILE_MONITOR_WATCH_MOUNTS))
794 {
795 #ifdef G_OS_WIN32
796 /*claim everything was mounted */
797 local_monitor->was_mounted = TRUE;
798 #else
799 GUnixMountEntry *mount;
800
801 /* Emulate unmount detection */
802
803 mount = g_unix_mount_at (local_monitor->source->dirname, NULL);
804
805 local_monitor->was_mounted = mount != NULL;
806
807 if (mount)
808 g_unix_mount_free (mount);
809
810 local_monitor->mount_monitor = g_unix_mount_monitor_get ();
811 g_signal_connect_object (local_monitor->mount_monitor, "mounts-changed",
812 G_CALLBACK (g_local_file_monitor_mounts_changed), local_monitor,
813 G_CONNECT_DEFAULT);
814 #endif
815 }
816
817 g_source_attach ((GSource *) source, context);
818
819 G_LOCAL_FILE_MONITOR_GET_CLASS (local_monitor)->start (local_monitor,
820 source->dirname, source->basename, source->filename,
821 source);
822 }
823
824 static void
825 g_local_file_monitor_dispose (GObject *object)
826 {
827 GLocalFileMonitor *local_monitor = G_LOCAL_FILE_MONITOR (object);
828
829 g_file_monitor_source_dispose (local_monitor->source);
830
831 G_OBJECT_CLASS (g_local_file_monitor_parent_class)->dispose (object);
832 }
833
834 static void
835 g_local_file_monitor_finalize (GObject *object)
836 {
837 GLocalFileMonitor *local_monitor = G_LOCAL_FILE_MONITOR (object);
838
839 g_source_unref ((GSource *) local_monitor->source);
840
841 G_OBJECT_CLASS (g_local_file_monitor_parent_class)->finalize (object);
842 }
843
844 static void
845 g_local_file_monitor_init (GLocalFileMonitor* local_monitor)
846 {
847 }
848
849 static void g_local_file_monitor_class_init (GLocalFileMonitorClass *class)
850 {
851 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
852
853 gobject_class->get_property = g_local_file_monitor_get_property;
854 gobject_class->set_property = g_local_file_monitor_set_property;
855 gobject_class->dispose = g_local_file_monitor_dispose;
856 gobject_class->finalize = g_local_file_monitor_finalize;
857
858 g_object_class_override_property (gobject_class, PROP_RATE_LIMIT, "rate-limit");
859 }
860
861 static GLocalFileMonitor *
862 g_local_file_monitor_new (gboolean is_remote_fs,
863 gboolean is_directory,
864 GError **error)
865 {
866 GType type = G_TYPE_INVALID;
867
868 if (is_remote_fs)
869 type = _g_io_module_get_default_type (G_NFS_FILE_MONITOR_EXTENSION_POINT_NAME,
870 "GIO_USE_FILE_MONITOR",
871 G_STRUCT_OFFSET (GLocalFileMonitorClass, is_supported));
872
873 /* Fallback rather to poll file monitor for remote files, see gfile.c. */
874 if (type == G_TYPE_INVALID && (!is_remote_fs || is_directory))
875 type = _g_io_module_get_default_type (G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,
876 "GIO_USE_FILE_MONITOR",
877 G_STRUCT_OFFSET (GLocalFileMonitorClass, is_supported));
878
879 if (type == G_TYPE_INVALID)
880 {
881 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
882 _("Unable to find default local file monitor type"));
883 return NULL;
884 }
885
886 return g_object_new (type, NULL);
887 }
888
889 GFileMonitor *
890 g_local_file_monitor_new_for_path (const gchar *pathname,
891 gboolean is_directory,
892 GFileMonitorFlags flags,
893 GError **error)
894 {
895 GLocalFileMonitor *monitor;
896 gboolean is_remote_fs;
897
898 is_remote_fs = g_local_file_is_nfs_home (pathname);
899
900 monitor = g_local_file_monitor_new (is_remote_fs, is_directory, error);
901
902 if (monitor)
903 g_local_file_monitor_start (monitor, pathname, is_directory, flags, g_main_context_get_thread_default ());
904
905 return G_FILE_MONITOR (monitor);
906 }
907
908 GFileMonitor *
909 g_local_file_monitor_new_in_worker (const gchar *pathname,
910 gboolean is_directory,
911 GFileMonitorFlags flags,
912 GFileMonitorCallback callback,
913 gpointer user_data,
914 GClosureNotify destroy_user_data,
915 GError **error)
916 {
917 GLocalFileMonitor *monitor;
918 gboolean is_remote_fs;
919
920 is_remote_fs = g_local_file_is_nfs_home (pathname);
921
922 monitor = g_local_file_monitor_new (is_remote_fs, is_directory, error);
923
924 if (monitor)
925 {
926 if (callback)
927 g_signal_connect_data (monitor, "changed", G_CALLBACK (callback),
928 user_data, destroy_user_data, G_CONNECT_DEFAULT);
929
930 g_local_file_monitor_start (monitor, pathname, is_directory, flags, GLIB_PRIVATE_CALL(g_get_worker_context) ());
931 }
932
933 return G_FILE_MONITOR (monitor);
934 }