mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2025-10-31 08:22:16 +01:00
417f6a4bde
The license and copyright are already stated in human-readable form in these files, so this should be uncontroversial. Signed-off-by: Philip Withnall <pwithnall@gnome.org> Helps: #1415
293 lines
8.2 KiB
C
293 lines
8.2 KiB
C
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 8 -*- */
|
|
|
|
/* inotify-helper.c - GVFS Monitor based on inotify.
|
|
|
|
Copyright (C) 2007 John McCutchan
|
|
|
|
SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
Authors:
|
|
John McCutchan <john@johnmccutchan.com>
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
/* Just include the local header to stop all the pain */
|
|
#include <sys/inotify.h>
|
|
#include <gio/glocalfilemonitor.h>
|
|
#include <gio/gfile.h>
|
|
#include "inotify-helper.h"
|
|
#include "inotify-missing.h"
|
|
#include "inotify-path.h"
|
|
|
|
static gboolean ih_debug_enabled = FALSE;
|
|
#define IH_W if (ih_debug_enabled) g_warning
|
|
|
|
static gboolean ih_event_callback (ik_event_t *event,
|
|
inotify_sub *sub,
|
|
gboolean file_event);
|
|
static void ih_not_missing_callback (inotify_sub *sub);
|
|
|
|
/* We share this lock with inotify-kernel.c and inotify-missing.c
|
|
*
|
|
* inotify-kernel.c takes the lock when it reads events from
|
|
* the kernel and when it processes those events
|
|
*
|
|
* inotify-missing.c takes the lock when it is scanning the missing
|
|
* list.
|
|
*
|
|
* We take the lock in all public functions
|
|
*/
|
|
G_LOCK_DEFINE (inotify_lock);
|
|
|
|
static GFileMonitorEvent ih_mask_to_EventFlags (guint32 mask);
|
|
|
|
/**
|
|
* _ih_startup:
|
|
*
|
|
* Initializes the inotify backend. This must be called before
|
|
* any other functions in this module.
|
|
*
|
|
* Returns: #TRUE if initialization succeeded, #FALSE otherwise
|
|
*/
|
|
gboolean
|
|
_ih_startup (void)
|
|
{
|
|
static gboolean initialized = FALSE;
|
|
static gboolean result = FALSE;
|
|
|
|
G_LOCK (inotify_lock);
|
|
|
|
if (initialized == TRUE)
|
|
{
|
|
G_UNLOCK (inotify_lock);
|
|
return result;
|
|
}
|
|
|
|
result = _ip_startup (ih_event_callback);
|
|
if (!result)
|
|
{
|
|
G_UNLOCK (inotify_lock);
|
|
return FALSE;
|
|
}
|
|
_im_startup (ih_not_missing_callback);
|
|
|
|
IH_W ("started gvfs inotify backend\n");
|
|
|
|
initialized = TRUE;
|
|
|
|
G_UNLOCK (inotify_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Adds a subscription to be monitored.
|
|
*/
|
|
gboolean
|
|
_ih_sub_add (inotify_sub *sub)
|
|
{
|
|
G_LOCK (inotify_lock);
|
|
|
|
if (!_ip_start_watching (sub))
|
|
_im_add (sub);
|
|
|
|
G_UNLOCK (inotify_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Cancels a subscription which was being monitored.
|
|
*/
|
|
gboolean
|
|
_ih_sub_cancel (inotify_sub *sub)
|
|
{
|
|
G_LOCK (inotify_lock);
|
|
|
|
if (!sub->cancelled)
|
|
{
|
|
IH_W ("cancelling %s\n", sub->dirname);
|
|
sub->cancelled = TRUE;
|
|
_im_rm (sub);
|
|
_ip_stop_watching (sub);
|
|
}
|
|
|
|
G_UNLOCK (inotify_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static char *
|
|
_ih_fullpath_from_event (ik_event_t *event,
|
|
const char *dirname,
|
|
const char *filename)
|
|
{
|
|
char *fullpath;
|
|
|
|
if (filename)
|
|
fullpath = g_strdup_printf ("%s/%s", dirname, filename);
|
|
else if (event->name)
|
|
fullpath = g_strdup_printf ("%s/%s", dirname, event->name);
|
|
else
|
|
fullpath = g_strdup_printf ("%s/", dirname);
|
|
|
|
return fullpath;
|
|
}
|
|
|
|
static gboolean
|
|
ih_event_callback (ik_event_t *event,
|
|
inotify_sub *sub,
|
|
gboolean file_event)
|
|
{
|
|
gboolean interesting;
|
|
GFileMonitorEvent event_flags;
|
|
|
|
event_flags = ih_mask_to_EventFlags (event->mask);
|
|
|
|
if (event->mask & IN_MOVE)
|
|
{
|
|
/* We either have a rename (in the same directory) or a move
|
|
* (between different directories).
|
|
*/
|
|
if (event->pair && event->pair->wd == event->wd)
|
|
{
|
|
/* this is a rename */
|
|
interesting = g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_RENAMED,
|
|
event->name, event->pair->name, NULL, event->timestamp);
|
|
}
|
|
else
|
|
{
|
|
GFile *other;
|
|
|
|
if (event->pair)
|
|
{
|
|
const char *parent_dir;
|
|
gchar *fullpath;
|
|
|
|
parent_dir = _ip_get_path_for_wd (event->pair->wd);
|
|
fullpath = _ih_fullpath_from_event (event->pair, parent_dir, NULL);
|
|
other = g_file_new_for_path (fullpath);
|
|
g_free (fullpath);
|
|
}
|
|
else
|
|
other = NULL;
|
|
|
|
/* This is either an incoming or outgoing move. Since we checked the
|
|
* event->mask above, it should have converted to a #GFileMonitorEvent
|
|
* properly. If not, the assumption we have made about event->mask
|
|
* only ever having a single bit set (apart from IN_ISDIR) is false.
|
|
* The kernel documentation is lacking here. */
|
|
g_assert ((int) event_flags != -1);
|
|
interesting = g_file_monitor_source_handle_event (sub->user_data, event_flags,
|
|
event->name, NULL, other, event->timestamp);
|
|
|
|
if (other)
|
|
g_object_unref (other);
|
|
}
|
|
}
|
|
else if ((int) event_flags != -1)
|
|
/* unpaired event -- no 'other' field */
|
|
interesting = g_file_monitor_source_handle_event (sub->user_data, event_flags,
|
|
event->name, NULL, NULL, event->timestamp);
|
|
else
|
|
interesting = FALSE;
|
|
|
|
if (event->mask & IN_CREATE)
|
|
{
|
|
const gchar *parent_dir;
|
|
gchar *fullname;
|
|
struct stat buf;
|
|
gint s;
|
|
|
|
/* The kernel reports IN_CREATE for two types of events:
|
|
*
|
|
* - creat(), in which case IN_CLOSE_WRITE will come soon; or
|
|
* - link(), mkdir(), mknod(), etc., in which case it won't
|
|
*
|
|
* We can attempt to detect the second case and send the
|
|
* CHANGES_DONE immediately so that the user isn't left waiting.
|
|
*
|
|
* The detection for link() is not 100% reliable since the link
|
|
* count could be 1 if the original link was deleted or if
|
|
* O_TMPFILE was being used, but in that case the virtual
|
|
* CHANGES_DONE will be emitted to close the loop.
|
|
*/
|
|
|
|
parent_dir = _ip_get_path_for_wd (event->wd);
|
|
fullname = _ih_fullpath_from_event (event, parent_dir, NULL);
|
|
s = stat (fullname, &buf);
|
|
g_free (fullname);
|
|
|
|
/* if it doesn't look like the result of creat()... */
|
|
if (s != 0 || !S_ISREG (buf.st_mode) || buf.st_nlink != 1)
|
|
g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
|
|
event->name, NULL, NULL, event->timestamp);
|
|
}
|
|
|
|
return interesting;
|
|
}
|
|
|
|
static void
|
|
ih_not_missing_callback (inotify_sub *sub)
|
|
{
|
|
gint now = g_get_monotonic_time ();
|
|
|
|
g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CREATED,
|
|
sub->filename, NULL, NULL, now);
|
|
g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
|
|
sub->filename, NULL, NULL, now);
|
|
}
|
|
|
|
/* Transforms a inotify event to a GVFS event. */
|
|
static GFileMonitorEvent
|
|
ih_mask_to_EventFlags (guint32 mask)
|
|
{
|
|
mask &= ~IN_ISDIR;
|
|
switch (mask)
|
|
{
|
|
case IN_MODIFY:
|
|
return G_FILE_MONITOR_EVENT_CHANGED;
|
|
case IN_CLOSE_WRITE:
|
|
return G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT;
|
|
case IN_ATTRIB:
|
|
return G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED;
|
|
case IN_MOVE_SELF:
|
|
case IN_DELETE:
|
|
case IN_DELETE_SELF:
|
|
return G_FILE_MONITOR_EVENT_DELETED;
|
|
case IN_CREATE:
|
|
return G_FILE_MONITOR_EVENT_CREATED;
|
|
case IN_MOVED_FROM:
|
|
return G_FILE_MONITOR_EVENT_MOVED_OUT;
|
|
case IN_MOVED_TO:
|
|
return G_FILE_MONITOR_EVENT_MOVED_IN;
|
|
case IN_UNMOUNT:
|
|
return G_FILE_MONITOR_EVENT_UNMOUNTED;
|
|
case IN_Q_OVERFLOW:
|
|
case IN_OPEN:
|
|
case IN_CLOSE_NOWRITE:
|
|
case IN_ACCESS:
|
|
case IN_IGNORED:
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|