2011-04-25 10:04:46 -07:00
|
|
|
/* EIO - EFL data type library
|
|
|
|
* Copyright (C) 2011 Enlightenment Developers:
|
|
|
|
* Cedric Bail <cedric.bail@free.fr>
|
|
|
|
*
|
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "eio_private.h"
|
|
|
|
#include "Eio.h"
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
/*============================================================================*
|
|
|
|
* Local *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
2011-04-25 10:04:46 -07:00
|
|
|
|
|
|
|
static Eina_Hash *_eio_monitors = NULL;
|
|
|
|
|
|
|
|
static void
|
2011-04-29 09:24:14 -07:00
|
|
|
_eio_monitor_free(Eio_Monitor *monitor)
|
2011-04-25 10:04:46 -07:00
|
|
|
{
|
2012-05-08 23:54:09 -07:00
|
|
|
if (!monitor->delete_me)
|
|
|
|
eina_hash_del(_eio_monitors, monitor->path, monitor);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2014-01-13 20:33:16 -08:00
|
|
|
if (monitor->exist)
|
|
|
|
{
|
|
|
|
eio_file_cancel(monitor->exist);
|
|
|
|
monitor->exist = NULL;
|
|
|
|
}
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-04-27 03:27:07 -07:00
|
|
|
if (monitor->backend)
|
|
|
|
{
|
|
|
|
if (!monitor->fallback)
|
|
|
|
eio_monitor_backend_del(monitor);
|
|
|
|
else
|
|
|
|
eio_monitor_fallback_del(monitor);
|
|
|
|
}
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2014-03-21 11:20:06 -07:00
|
|
|
if (_eio_log_dom_global != -1)
|
|
|
|
INF("Stopping monitor on '%s'.", monitor->path);
|
2014-03-04 17:40:55 -08:00
|
|
|
|
2011-04-25 10:04:46 -07:00
|
|
|
eina_stringshare_del(monitor->path);
|
|
|
|
free(monitor);
|
|
|
|
}
|
|
|
|
|
2011-04-27 03:27:07 -07:00
|
|
|
static void
|
2012-12-04 09:40:58 -08:00
|
|
|
_eio_monitor_error_cleanup_cb(EINA_UNUSED void *user_data, void *func_data)
|
2011-04-25 10:04:46 -07:00
|
|
|
{
|
2011-09-01 03:22:00 -07:00
|
|
|
Eio_Monitor_Error *ev = func_data;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-06-22 09:09:14 -07:00
|
|
|
EINA_REFCOUNT_UNREF(ev->monitor)
|
|
|
|
_eio_monitor_free(ev->monitor);
|
2011-04-27 03:27:07 -07:00
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-12-04 09:40:58 -08:00
|
|
|
_eio_monitor_event_cleanup_cb(EINA_UNUSED void *user_data, void *func_data)
|
2011-04-27 03:27:07 -07:00
|
|
|
{
|
2011-09-01 03:22:00 -07:00
|
|
|
Eio_Monitor_Event *ev = func_data;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-06-22 09:09:14 -07:00
|
|
|
EINA_REFCOUNT_UNREF(ev->monitor)
|
|
|
|
_eio_monitor_free(ev->monitor);
|
2011-04-27 03:27:07 -07:00
|
|
|
eina_stringshare_del(ev->filename);
|
2011-04-25 10:04:46 -07:00
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-12-04 09:40:58 -08:00
|
|
|
_eio_monitor_stat_cb(void *data, EINA_UNUSED Eio_File *handler, EINA_UNUSED const Eina_Stat *st)
|
2011-04-25 10:04:46 -07:00
|
|
|
{
|
|
|
|
Eio_Monitor *monitor = data;
|
|
|
|
|
|
|
|
monitor->exist = NULL;
|
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
if (EINA_REFCOUNT_GET(monitor) > 1)
|
|
|
|
eio_monitor_backend_add(monitor);
|
|
|
|
|
2011-06-22 09:09:14 -07:00
|
|
|
EINA_REFCOUNT_UNREF(monitor)
|
|
|
|
_eio_monitor_free(monitor);
|
2011-04-25 10:04:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-27 03:27:07 -07:00
|
|
|
_eio_monitor_error(Eio_Monitor *monitor, int error)
|
2011-04-25 10:04:46 -07:00
|
|
|
{
|
|
|
|
Eio_Monitor_Error *ev;
|
2011-04-27 03:27:07 -07:00
|
|
|
|
|
|
|
ev = calloc(1, sizeof (Eio_Monitor_Error));
|
2013-06-20 04:28:18 -07:00
|
|
|
if (!ev) return;
|
2011-04-27 03:27:07 -07:00
|
|
|
|
|
|
|
ev->monitor = monitor;
|
2011-04-29 09:24:14 -07:00
|
|
|
EINA_REFCOUNT_REF(ev->monitor);
|
2011-04-27 03:27:07 -07:00
|
|
|
ev->error = error;
|
|
|
|
|
|
|
|
ecore_event_add(EIO_MONITOR_ERROR, ev, _eio_monitor_error_cleanup_cb, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-12-04 09:40:58 -08:00
|
|
|
_eio_monitor_error_cb(void *data, Eio_File *handler EINA_UNUSED, int error)
|
2011-04-27 03:27:07 -07:00
|
|
|
{
|
2011-04-25 10:04:46 -07:00
|
|
|
Eio_Monitor *monitor = data;
|
|
|
|
|
|
|
|
monitor->error = error;
|
|
|
|
monitor->exist = NULL;
|
|
|
|
|
2012-01-24 08:00:57 -08:00
|
|
|
if (EINA_REFCOUNT_GET(monitor) >= 1)
|
2011-04-29 09:24:14 -07:00
|
|
|
_eio_monitor_error(monitor, error);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-06-22 09:09:14 -07:00
|
|
|
EINA_REFCOUNT_UNREF(monitor)
|
|
|
|
_eio_monitor_free(monitor);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2013-06-20 04:28:18 -07:00
|
|
|
return;
|
2011-04-25 10:04:46 -07:00
|
|
|
}
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* Global *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
2011-04-25 10:04:46 -07:00
|
|
|
void
|
|
|
|
eio_monitor_init(void)
|
|
|
|
{
|
2017-12-18 18:14:37 -08:00
|
|
|
EIO_MONITOR_ERROR = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_SELF_RENAME = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_SELF_DELETED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_CREATED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_DELETED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_MODIFIED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_CLOSED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_CREATED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_DELETED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_MODIFIED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_CLOSED = ecore_event_type_new();
|
2011-04-25 10:04:46 -07:00
|
|
|
|
|
|
|
eio_monitor_backend_init();
|
|
|
|
eio_monitor_fallback_init();
|
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
_eio_monitors = eina_hash_stringshared_new(NULL);
|
2012-03-01 19:09:47 -08:00
|
|
|
/* FIXME: this check is optional, but if it is kept then failure should be handled more gracefully */
|
|
|
|
if (!_eio_monitors) abort();
|
2011-04-25 10:04:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
eio_monitor_shutdown(void)
|
|
|
|
{
|
2012-09-09 18:52:39 -07:00
|
|
|
Eina_Iterator *it;
|
|
|
|
Eio_Monitor *monitor;
|
|
|
|
|
2017-03-09 16:16:45 -08:00
|
|
|
ecore_event_type_flush(EIO_MONITOR_ERROR,
|
|
|
|
EIO_MONITOR_SELF_RENAME,
|
|
|
|
EIO_MONITOR_SELF_DELETED,
|
|
|
|
EIO_MONITOR_FILE_CREATED,
|
|
|
|
EIO_MONITOR_FILE_DELETED,
|
|
|
|
EIO_MONITOR_FILE_MODIFIED,
|
|
|
|
EIO_MONITOR_FILE_CLOSED,
|
|
|
|
EIO_MONITOR_DIRECTORY_CREATED,
|
|
|
|
EIO_MONITOR_DIRECTORY_DELETED,
|
|
|
|
EIO_MONITOR_DIRECTORY_MODIFIED,
|
|
|
|
EIO_MONITOR_DIRECTORY_CLOSED);
|
|
|
|
|
2012-09-09 18:52:39 -07:00
|
|
|
it = eina_hash_iterator_data_new(_eio_monitors);
|
|
|
|
EINA_ITERATOR_FOREACH(it, monitor)
|
|
|
|
{
|
|
|
|
if (monitor->exist)
|
|
|
|
{
|
|
|
|
eio_file_cancel(monitor->exist);
|
|
|
|
monitor->exist = NULL;
|
|
|
|
}
|
|
|
|
monitor->delete_me = EINA_TRUE;
|
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
2011-04-25 10:04:46 -07:00
|
|
|
eina_hash_free(_eio_monitors);
|
2018-02-07 08:55:40 -08:00
|
|
|
_eio_monitors = NULL;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
|
|
|
eio_monitor_backend_shutdown();
|
|
|
|
eio_monitor_fallback_shutdown();
|
|
|
|
}
|
|
|
|
|
2014-03-04 17:40:55 -08:00
|
|
|
static const char *
|
|
|
|
_eio_naming_event(int event_code)
|
|
|
|
{
|
|
|
|
#define EVENT_CHECK(Code, Ev) if (Code == Ev) return #Ev;
|
|
|
|
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_ERROR);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_FILE_CREATED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_FILE_DELETED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_FILE_MODIFIED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_FILE_CLOSED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_DIRECTORY_CREATED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_DIRECTORY_DELETED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_DIRECTORY_MODIFIED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_DIRECTORY_CLOSED);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_SELF_RENAME);
|
|
|
|
EVENT_CHECK(event_code, EIO_MONITOR_SELF_DELETED);
|
|
|
|
return "Unknown";
|
|
|
|
}
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
void
|
|
|
|
_eio_monitor_send(Eio_Monitor *monitor, const char *filename, int event_code)
|
|
|
|
{
|
|
|
|
Eio_Monitor_Event *ev;
|
|
|
|
|
2014-01-13 20:33:16 -08:00
|
|
|
if (monitor->delete_me)
|
|
|
|
return;
|
|
|
|
|
2014-03-04 17:40:55 -08:00
|
|
|
INF("Event '%s' for monitored path '%s'.",
|
|
|
|
_eio_naming_event(event_code), filename);
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
ev = calloc(1, sizeof (Eio_Monitor_Event));
|
2013-06-20 04:28:18 -07:00
|
|
|
if (!ev) return;
|
2012-03-31 00:01:24 -07:00
|
|
|
|
|
|
|
ev->monitor = monitor;
|
|
|
|
EINA_REFCOUNT_REF(ev->monitor);
|
|
|
|
ev->filename = eina_stringshare_add(filename);
|
|
|
|
|
|
|
|
ecore_event_add(event_code, ev, _eio_monitor_event_cleanup_cb, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_eio_monitor_rename(Eio_Monitor *monitor, const char *newpath)
|
|
|
|
{
|
|
|
|
const char *tmp;
|
|
|
|
|
2014-01-13 20:33:16 -08:00
|
|
|
if (monitor->delete_me)
|
|
|
|
return;
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
/* destroy old state */
|
2014-01-07 00:49:29 -08:00
|
|
|
if (monitor->exist)
|
|
|
|
{
|
|
|
|
eio_file_cancel(monitor->exist);
|
|
|
|
monitor->exist = NULL;
|
|
|
|
}
|
2012-03-31 00:01:24 -07:00
|
|
|
|
|
|
|
if (monitor->backend)
|
|
|
|
{
|
|
|
|
if (!monitor->fallback)
|
|
|
|
eio_monitor_backend_del(monitor);
|
|
|
|
else
|
|
|
|
eio_monitor_fallback_del(monitor);
|
|
|
|
}
|
|
|
|
|
2014-03-04 17:40:55 -08:00
|
|
|
INF("Renaming path '%s' to '%s'.",
|
|
|
|
monitor->path, newpath);
|
|
|
|
|
2012-03-31 00:01:24 -07:00
|
|
|
/* rename */
|
|
|
|
tmp = monitor->path;
|
|
|
|
monitor->path = eina_stringshare_add(newpath);
|
|
|
|
eina_hash_move(_eio_monitors, tmp, monitor->path);
|
|
|
|
eina_stringshare_del(tmp);
|
|
|
|
|
|
|
|
/* That means death (cmp pointer and not content) */
|
2014-01-07 00:49:29 -08:00
|
|
|
/* this - i think, is wrong. if the paths are the same, we should just
|
|
|
|
* re-stat anyway. imagine the file was renamed and then replaced?
|
|
|
|
* disable this as this was part of a possible crash due to eio.
|
2012-03-31 00:01:24 -07:00
|
|
|
if (tmp == monitor->path)
|
|
|
|
{
|
|
|
|
_eio_monitor_error(monitor, -1);
|
2013-06-20 04:28:18 -07:00
|
|
|
return;
|
2012-03-31 00:01:24 -07:00
|
|
|
}
|
2014-01-07 00:49:29 -08:00
|
|
|
*/
|
2012-03-31 00:01:24 -07:00
|
|
|
|
|
|
|
EINA_REFCOUNT_REF(monitor); /* as we spawn a thread for this monitor, we need to refcount specifically for it */
|
|
|
|
|
|
|
|
/* restart */
|
|
|
|
monitor->rename = EINA_TRUE;
|
|
|
|
monitor->exist = eio_file_direct_stat(monitor->path,
|
|
|
|
_eio_monitor_stat_cb,
|
|
|
|
_eio_monitor_error_cb,
|
|
|
|
monitor);
|
|
|
|
|
|
|
|
/* FIXME: probably should handle this more gracefully */
|
|
|
|
if (!monitor->exist) abort();
|
|
|
|
/* and notify the app */
|
|
|
|
_eio_monitor_send(monitor, newpath, EIO_MONITOR_SELF_RENAME);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
EAPI int EIO_MONITOR_ERROR;
|
|
|
|
EAPI int EIO_MONITOR_FILE_CREATED;
|
|
|
|
EAPI int EIO_MONITOR_FILE_DELETED;
|
|
|
|
EAPI int EIO_MONITOR_FILE_MODIFIED;
|
|
|
|
EAPI int EIO_MONITOR_FILE_CLOSED;
|
|
|
|
EAPI int EIO_MONITOR_DIRECTORY_CREATED;
|
|
|
|
EAPI int EIO_MONITOR_DIRECTORY_DELETED;
|
|
|
|
EAPI int EIO_MONITOR_DIRECTORY_MODIFIED;
|
|
|
|
EAPI int EIO_MONITOR_DIRECTORY_CLOSED;
|
|
|
|
EAPI int EIO_MONITOR_SELF_RENAME;
|
|
|
|
EAPI int EIO_MONITOR_SELF_DELETED;
|
|
|
|
|
2011-04-25 10:04:46 -07:00
|
|
|
EAPI Eio_Monitor *
|
|
|
|
eio_monitor_add(const char *path)
|
|
|
|
{
|
|
|
|
const char *tmp;
|
2012-03-01 19:00:59 -08:00
|
|
|
Eio_Monitor *ret;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2012-12-24 01:44:21 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
|
2011-04-25 10:04:46 -07:00
|
|
|
tmp = eina_stringshare_add(path);
|
2012-03-01 19:00:59 -08:00
|
|
|
ret = eio_monitor_stringshared_add(tmp);
|
|
|
|
eina_stringshare_del(tmp);
|
2012-03-01 19:01:10 -08:00
|
|
|
return ret;
|
2011-04-25 10:04:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eio_Monitor *
|
|
|
|
eio_monitor_stringshared_add(const char *path)
|
|
|
|
{
|
|
|
|
Eio_Monitor *monitor;
|
2012-05-08 23:54:09 -07:00
|
|
|
struct stat st;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2012-12-24 01:44:21 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
|
2018-02-07 08:55:40 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(_eio_monitors, NULL);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2012-09-05 23:30:29 -07:00
|
|
|
if (stat(path, &st) != 0)
|
|
|
|
{
|
2014-03-04 18:46:12 -08:00
|
|
|
ERR("monitored path '%s' not found.", path);
|
2012-09-05 23:30:29 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-05-08 23:54:09 -07:00
|
|
|
|
2011-04-25 10:04:46 -07:00
|
|
|
monitor = eina_hash_find(_eio_monitors, path);
|
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
if (monitor)
|
2011-04-25 10:04:46 -07:00
|
|
|
{
|
2012-05-08 23:54:09 -07:00
|
|
|
if (st.st_mtime != monitor->mtime)
|
|
|
|
{
|
|
|
|
monitor->delete_me = EINA_TRUE;
|
|
|
|
eina_hash_del(_eio_monitors, monitor->path, monitor);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_REFCOUNT_REF(monitor);
|
|
|
|
return monitor;
|
|
|
|
}
|
2011-04-29 09:24:14 -07:00
|
|
|
}
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
monitor = malloc(sizeof (Eio_Monitor));
|
|
|
|
if (!monitor) return NULL;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2012-05-08 23:54:09 -07:00
|
|
|
monitor->mtime = st.st_mtime;
|
2011-04-29 09:24:14 -07:00
|
|
|
monitor->backend = NULL; // This is needed to avoid race condition
|
|
|
|
monitor->path = eina_stringshare_ref(path);
|
|
|
|
monitor->fallback = EINA_FALSE;
|
|
|
|
monitor->rename = EINA_FALSE;
|
2012-05-09 00:46:12 -07:00
|
|
|
monitor->delete_me = EINA_FALSE;
|
2015-04-10 13:11:41 -07:00
|
|
|
monitor->exist = NULL;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
EINA_REFCOUNT_INIT(monitor);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2019-08-08 15:55:40 -07:00
|
|
|
static signed char monpoll = -1;
|
|
|
|
|
|
|
|
if (monpoll == -1)
|
|
|
|
{
|
|
|
|
if (getenv("EIO_MONITOR_POLL")) monpoll = 1;
|
|
|
|
else monpoll = 0;
|
|
|
|
}
|
|
|
|
if (monpoll)
|
2016-07-15 17:03:53 -07:00
|
|
|
eio_monitor_fallback_add(monitor);
|
|
|
|
else
|
|
|
|
eio_monitor_backend_add(monitor);
|
|
|
|
|
2016-07-15 17:04:21 -07:00
|
|
|
if (!monitor->backend)
|
|
|
|
{
|
|
|
|
WRN("Impossible to create a monitor for '%s'.", monitor->path);
|
|
|
|
eina_stringshare_del(monitor->path);
|
|
|
|
free(monitor);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
eina_hash_direct_add(_eio_monitors, path, monitor);
|
2014-03-04 17:40:55 -08:00
|
|
|
INF("New monitor on '%s'.", path);
|
2011-04-25 10:04:46 -07:00
|
|
|
|
|
|
|
return monitor;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eio_monitor_del(Eio_Monitor *monitor)
|
|
|
|
{
|
2012-12-21 17:56:10 -08:00
|
|
|
if (!monitor) return;
|
2011-06-22 09:09:14 -07:00
|
|
|
EINA_REFCOUNT_UNREF(monitor)
|
|
|
|
_eio_monitor_free(monitor);
|
2011-04-25 10:04:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
eio_monitor_path_get(Eio_Monitor *monitor)
|
|
|
|
{
|
2012-03-01 19:04:57 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(monitor, NULL);
|
2011-04-25 10:04:46 -07:00
|
|
|
return monitor->path;
|
|
|
|
}
|
efl_io_model: next try to fix this race condition
what is happening is that a file gets announced through eio_model
listing code, at this point of time, the monitor does not yet know about
the file. If the file now gets deleted between the annoncing and the
learning of the file from the monitor, then the file got an ADD event,
but no DEL event. Which is a bug.
With this commit there is a new API which asks the monitor if the file
already has the knowledge about the files existance, or not. A few
monitors like win32 inotify or cocoa do not have context about the file
directly, if the OS is now having the same bug, then we are again in
trouble, however, we canot do anything about that. In the case of kevent
or poll, this asks the context of the monitor if the file is already
there.
Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Differential Revision: https://phab.enlightenment.org/D10006
2019-09-18 02:32:08 -07:00
|
|
|
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eio_monitor_has_context(const Eio_Monitor *monitor, const char *path)
|
|
|
|
{
|
|
|
|
if (monitor->fallback)
|
|
|
|
{
|
|
|
|
return eio_monitor_fallback_context_check(monitor, path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return eio_monitor_context_check(monitor, path);
|
|
|
|
}
|
|
|
|
}
|