luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-11-04 01:58:54 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
daf3bd7f0a6ce63f6dc52c4dba6af1b430f9327c
glib/gio/inotify/inotify-helper.c
Philip Withnall 417f6a4bde inotify: Trivially add SPDX-License-Identifier to inotify files 
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
2024-04-17 15:46:11 +01:00

293 lines
8.2 KiB
C
Raw Blame History

/* -*- 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;
}
}
Reference in New Issue View Git Blame Copy Permalink