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 pid_t _monitor_pid = -1;
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
if (monitor->exist) eio_file_cancel(monitor->exist);
|
|
|
|
|
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
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
EIO_MONITOR_ERROR = ecore_event_type_new();
|
2011-04-27 03:27:07 -07:00
|
|
|
EIO_MONITOR_SELF_RENAME = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_SELF_DELETED = ecore_event_type_new();
|
2011-04-25 10:04:46 -07:00
|
|
|
EIO_MONITOR_FILE_CREATED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_DELETED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_FILE_MODIFIED = ecore_event_type_new();
|
2011-04-27 03:27:07 -07:00
|
|
|
EIO_MONITOR_FILE_CLOSED = ecore_event_type_new();
|
2011-04-25 10:04:46 -07:00
|
|
|
EIO_MONITOR_DIRECTORY_CREATED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_DELETED = ecore_event_type_new();
|
|
|
|
EIO_MONITOR_DIRECTORY_MODIFIED = ecore_event_type_new();
|
2011-04-27 03:27:07 -07:00
|
|
|
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
|
|
|
|
|
|
|
_monitor_pid = getpid();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
eio_monitor_shutdown(void)
|
|
|
|
{
|
2012-09-09 18:52:39 -07:00
|
|
|
Eina_Iterator *it;
|
|
|
|
Eio_Monitor *monitor;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
eio_monitor_backend_shutdown();
|
|
|
|
eio_monitor_fallback_shutdown();
|
|
|
|
|
|
|
|
_monitor_pid = -1;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* destroy old state */
|
|
|
|
if (monitor->exist) eio_file_cancel(monitor->exist);
|
|
|
|
|
|
|
|
if (monitor->backend)
|
|
|
|
{
|
|
|
|
if (!monitor->fallback)
|
|
|
|
eio_monitor_backend_del(monitor);
|
|
|
|
else
|
|
|
|
eio_monitor_fallback_del(monitor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) */
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2011-04-25 10:04:46 -07:00
|
|
|
if (_monitor_pid == -1) return NULL;
|
|
|
|
|
|
|
|
if (_monitor_pid != getpid())
|
|
|
|
{
|
|
|
|
eio_monitor_shutdown();
|
|
|
|
eio_monitor_init();
|
|
|
|
}
|
|
|
|
|
2012-09-05 23:30:29 -07:00
|
|
|
if (stat(path, &st) != 0)
|
|
|
|
{
|
|
|
|
INF("monitored path not found");
|
|
|
|
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;
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
EINA_REFCOUNT_INIT(monitor);
|
2012-01-24 08:00:57 -08:00
|
|
|
EINA_REFCOUNT_REF(monitor); /* as we spawn a thread for this monitor, we need to refcount specifically for it */
|
2011-04-29 09:24:14 -07:00
|
|
|
|
|
|
|
monitor->exist = eio_file_direct_stat(monitor->path,
|
|
|
|
_eio_monitor_stat_cb,
|
|
|
|
_eio_monitor_error_cb,
|
|
|
|
monitor);
|
2012-03-01 19:04:33 -08:00
|
|
|
if (!monitor->exist)
|
|
|
|
{
|
|
|
|
_eio_monitor_free(monitor);
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-25 10:04:46 -07:00
|
|
|
|
2011-04-29 09:24:14 -07:00
|
|
|
eina_hash_direct_add(_eio_monitors, path, monitor);
|
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;
|
|
|
|
}
|