merge: eio + fix compilation on windows + minor fixes + po files

don't move eio to IN-EFL right now


SVN revision: 80180

17 files changed, 7619 insertions, 2 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 2d2ae9e9c7..73ac3a9048 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -56,6 +56,7 @@ endif
 include Makefile_Ecore_Imf.am
 include Makefile_Ecore_Evas.am
 include Makefile_Embryo.am
+include Makefile_Eio.am
 
 .PHONY: benchmark examples
 
diff --git a/src/Makefile_Ecore_Evas.am b/src/Makefile_Ecore_Evas.am
index f38c31ae84..40036b753d 100644
--- a/src/Makefile_Ecore_Evas.am
+++ b/src/Makefile_Ecore_Evas.am
@@ -107,10 +107,10 @@ if HAVE_WIN32
 lib_ecore_evas_libecore_evas_la_CPPFLAGS += \
 -I$(top_srcdir)/src/lib/ecore_win32 \
 -I$(top_srcdir)/src/modules/evas/engines/software_ddraw \
--I$(top_srcdir)/src/modules/evas/engines/direct3d \
+-I$(top_srcdir)/src/modules/evas/engines/software_gdi \
 -I$(top_builddir)/src/lib/ecore_win32 \
 -I$(top_builddir)/src/modules/evas/engines/software_ddraw \
--I$(top_builddir)/src/modules/evas/engines/direct3d
+-I$(top_builddir)/src/modules/evas/engines/software_gdi
 endif
 
 if HAVE_WINCE
diff --git a/src/Makefile_Eio.am b/src/Makefile_Eio.am
new file mode 100644
index 0000000000..93f4d25f93
--- /dev/null
+++ b/src/Makefile_Eio.am
@@ -0,0 +1,50 @@
+
+### Library
+
+lib_LTLIBRARIES += lib/eio/libeio.la
+
+installed_eiomainheadersdir = $(includedir)/eio-@VMAJ@
+dist_installed_eiomainheaders_DATA = lib/eio/Eio.h lib/eio/eio_inline_helper.x
+
+lib_eio_libeio_la_SOURCES = \
+lib/eio/eio_dir.c \
+lib/eio/eio_eet.c \
+lib/eio/eio_file.c \
+lib/eio/eio_main.c \
+lib/eio/eio_map.c \
+lib/eio/eio_monitor.c \
+lib/eio/eio_monitor_poll.c \
+lib/eio/eio_single.c \
+lib/eio/eio_xattr.c \
+lib/eio/eio_private.h
+
+if EIO_HAVE_INOTIFY
+lib_eio_libeio_la_SOURCES += lib/eio/eio_monitor_inotify.c
+else
+if EIO_HAVE_WINCHANGE
+lib_eio_libeio_la_SOURCES += lib/eio/eio_monitor_win32.c
+endif
+endif
+
+lib_eio_libeio_la_CPPFLAGS = \
+-I$(top_srcdir)/src/lib/eina \
+-I$(top_srcdir)/src/lib/eo \
+-I$(top_srcdir)/src/lib/eet \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/eio \
+-I$(top_builddir)/src/lib/eina \
+-I$(top_builddir)/src/lib/eo \
+-I$(top_builddir)/src/lib/eet \
+-I$(top_builddir)/src/lib/ecore \
+-I$(top_builddir)/src/lib/eio \
+-DEFL_EIO_BUILD \
+@EFL_CFLAGS@
+
+lib_eio_libeio_la_LIBADD = \
+lib/eina/libeina.la \
+lib/eo/libeo.la \
+lib/eet/libeet.la \
+lib/ecore/libecore.la \
+-lm
+
+lib_eio_libeio_la_LDFLAGS = -no-undefined -version-info @version_info@ @release_info@
diff --git a/src/lib/eio/Eio.h b/src/lib/eio/Eio.h
new file mode 100644
index 0000000000..cb791a0ebf
--- /dev/null
+++ b/src/lib/eio/Eio.h
@@ -0,0 +1,1190 @@
+/* EIO - EFL data type library
+ * Copyright (C) 2010 Enlightenment Developers:
+ *           Cedric Bail <cedric.bail@free.fr>
+ *           Vincent "caro" Torri  <vtorri at univ-evry dot fr>
+ *           Stephen "okra" Houston <unixtitan@gmail.com>
+ *
+ * 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/>.
+ */
+
+#ifndef EIO_H__
+# define EIO_H__
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <Eina.h>
+#include <Eet.h>
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EIO_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EIO_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EIO_VERSION_MAJOR 1
+#define EIO_VERSION_MINOR 8
+
+    /**
+    * @typedef Eio_Version
+    * Represents the current version of EIO
+    */
+   typedef struct _Eio_Version
+     {
+        int major; /**< Major version number */
+        int minor; /**< Minor version number */
+        int micro; /**< Micro version number */
+        int revision; /**< Revision number */
+     } Eio_Version;
+
+   EAPI extern Eio_Version *eio_version;
+
+/**
+ * @defgroup Eio_Group Eio Reference API
+ *
+ * @brief This is the core asynchronous input/output operation
+ *
+ * All the functions in this group perform input/output operations
+ * in a separate thread using the infrastructure provided by
+ * Ecore_Thread and Eina, this means that all functions here are non-blocking.
+ *
+ * The functions displayed here are used to make basic file operations, like
+ * listing the content of a directory, creating a new directory, etc.
+ *
+ * @{
+ */
+
+/**
+ * @enum _Eio_File_Op
+ *
+ * @brief Input/Output operations on files.
+ *
+ * This enum represents the operations that can be done.
+ */
+enum _Eio_File_Op
+{
+  EIO_FILE_COPY, /**< I/O operation is about a specific file copy */
+  EIO_FILE_MOVE, /**< I/O operation is about a specific file move */
+  EIO_DIR_COPY, /**< I/O operation is about a specific directory copy */
+  EIO_DIR_MOVE, /**< I/O operation is about a specific directory move */
+  /** I/O operation is about destroying a path:
+   * source will point to base path to be destroyed,
+   * and dest will point to to path destroyed by this I/O
+   */
+  EIO_UNLINK,
+  EIO_FILE_GETPWNAM, /**< I/O operation is trying to get uid from user name */
+  EIO_FILE_GETGRNAM /**< I/O operation is trying to get gid from user name */
+};
+
+/**
+ * @typedef Eio_File_Op
+ * Input/Output operations on files.
+ */
+typedef enum _Eio_File_Op Eio_File_Op;
+
+/**
+ * @typedef Eio_File
+ * Generic asynchronous I/O reference.
+ */
+typedef struct _Eio_File Eio_File;
+
+/**
+ * @typedef Eio_Progress
+ * Progress information on a specific operation.
+ */
+typedef struct _Eio_Progress Eio_Progress;
+
+typedef Eina_Bool (*Eio_Filter_Cb)(void *data, Eio_File *handler, const char *file);
+typedef void      (*Eio_Main_Cb)(void *data, Eio_File *handler, const char *file);
+
+typedef Eina_Bool (*Eio_Filter_Direct_Cb)(void *data, Eio_File *handler, const Eina_File_Direct_Info *info);
+typedef Eina_Bool (*Eio_Filter_Dir_Cb)(void *data, Eio_File *handler, Eina_File_Direct_Info *info);
+typedef void      (*Eio_Main_Direct_Cb)(void *data, Eio_File *handler, const Eina_File_Direct_Info *info);
+
+typedef void (*Eio_Stat_Cb)(void *data, Eio_File *handler, const Eina_Stat *stat);
+typedef void (*Eio_Progress_Cb)(void *data, Eio_File *handler, const Eio_Progress *info);
+
+typedef void      (*Eio_Eet_Open_Cb)(void *data, Eio_File *handler, Eet_File *file);
+typedef void      (*Eio_Open_Cb)(void *data, Eio_File *handler, Eina_File *file);
+typedef Eina_Bool (*Eio_Filter_Map_Cb)(void *data, Eio_File *handler, void *map, size_t length);
+typedef void      (*Eio_Map_Cb)(void *data, Eio_File *handler, void *map, size_t length);
+
+typedef void (*Eio_Done_Data_Cb)(void *data, Eio_File *handler, const char *read_data, unsigned int size);
+typedef void (*Eio_Done_String_Cb)(void *data, Eio_File *handler, const char *xattr_string);
+typedef void (*Eio_Done_Double_Cb)(void *data, Eio_File *handler, double xattr_double);
+typedef void (*Eio_Done_Int_Cb)(void *data, Eio_File *handler, int i);
+
+typedef void (*Eio_Done_ERead_Cb)(void *data, Eio_File *handler, void *decoded);
+typedef void (*Eio_Done_Read_Cb)(void *data, Eio_File *handler, void *read_data, unsigned int size);
+typedef void (*Eio_Done_Cb)(void *data, Eio_File *handler);
+typedef void (*Eio_Error_Cb)(void *data, Eio_File *handler, int error);
+typedef void (*Eio_Eet_Error_Cb)(void *data, Eio_File *handler, Eet_Error err);
+
+/**
+  * @struct _Eio_Progress
+  * @brief Represents the current progress of the operation.
+  */
+struct _Eio_Progress
+{
+   Eio_File_Op op; /**< I/O type */
+
+   long long current; /**< Current step in the I/O operation */
+   long long max; /**< Number of total steps to complete this I/O */
+   float percent; /**< Percent done for the I/O operation */
+
+   const char *source; /**< source of the I/O operation */
+   const char *dest; /**< target of the I/O operation */
+};
+
+/**
+ * @brief List contents of a directory without locking your app.
+ * @param dir The directory to list.
+ * @param filter_cb Callback used to decide if the file will be passed to main_cb
+ * @param main_cb Callback called for each listed file if it was not filtered.
+ * @param done_cb Callback called when the ls operation is done.
+ * @param error_cb Callback called when either the directory could not be opened or the operation has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * This function is responsible for listing the content of a directory without blocking your application.
+ * It's equivalent to the "ls" shell command. Every file will be passed to the
+ * filter_cb, so it's your job to decide if you want to pass the file to the
+ * main_cb or not. Return EINA_TRUE to pass it to the main_cb or EINA_FALSE to
+ * ignore it.
+ */
+EAPI Eio_File *eio_file_ls(const char *dir,
+                           Eio_Filter_Cb filter_cb,
+                           Eio_Main_Cb main_cb,
+                           Eio_Done_Cb done_cb,
+                           Eio_Error_Cb error_cb,
+                           const void *data);
+
+/**
+ * @brief List contents of a directory without locking your app.
+ * @param dir The directory to list.
+ * @param filter_cb Callback used to decide if the file will be passed to main_cb
+ * @param main_cb Callback called from the main loop for each accepted file (not filtered).
+ * @param done_cb Callback called from the main loop after the contents of the directory has been listed.
+ * @param error_cb Callback called from the main loop when either the directory could not be opened or the operation has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_direct_ls runs eina_file_direct_ls in a separate thread using
+ * ecore_thread_feedback_run. This prevents any blocking in your apps.
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ */
+EAPI Eio_File *eio_file_direct_ls(const char *dir,
+                                  Eio_Filter_Direct_Cb filter_cb,
+                                  Eio_Main_Direct_Cb main_cb,
+                                  Eio_Done_Cb done_cb,
+                                  Eio_Error_Cb error_cb,
+                                  const void *data);
+
+/**
+ * @brief List content of a directory without locking your app.
+ * @param dir The directory to list.
+ * @param filter_cb Callback used to decide if the file will be passed to main_cb
+ * @param main_cb Callback called from the main loop for each accepted file (not filtered).
+ * @param done_cb Callback called from the main loop after the contents of the directory has been listed.
+ * @param error_cb Callback called from the main loop when either the directory could not be opened or the operation has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ *
+ */
+EAPI Eio_File *eio_file_stat_ls(const char *dir,
+                                Eio_Filter_Direct_Cb filter_cb,
+                                Eio_Main_Direct_Cb main_cb,
+                                Eio_Done_Cb done_cb,
+                                Eio_Error_Cb error_cb,
+                                const void *data);
+
+/**
+ * @brief List the content of a directory and all it's sub-content asynchronously
+ * @param dir The directory to list.
+ * @param filter_cb Callback used to decide if the file will be passed to main_cb
+ * @param main_cb Callback called from the main loop for each accepted file (not filtered).
+ * @param done_cb Callback called from the main loop after the contents of the directory has been listed.
+ * @param error_cb Callback called from the main loop when either the directory could not be opened or the operation has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_dir_stat_ls() runs eina_file_stat_ls() recursively in a separate thread using
+ * ecore_thread_feedback_run. This prevents any blocking in your apps.
+ * Every file will be passed to the
+ * filter_cb, so it's your job to decide if you want to pass the file to the
+ * main_cb or not. Return EINA_TRUE to pass it to the main_cb or EINA_FALSE to
+ * ignore it.
+ */
+EAPI Eio_File *eio_dir_stat_ls(const char *dir,
+                               Eio_Filter_Direct_Cb filter_cb,
+                               Eio_Main_Direct_Cb main_cb,
+                               Eio_Done_Cb done_cb,
+                               Eio_Error_Cb error_cb,
+                               const void *data);
+
+/**
+ * @brief List the content of a directory and all it's sub-content asynchronously
+ * @param dir The directory to list.
+ * @param filter_cb Callback used to decide if the file will be passed to main_cb
+ * @param main_cb Callback called from the main loop for each accepted file (not filtered).
+ * @param done_cb Callback called from the main loop after the contents of the directory has been listed.
+ * @param error_cb Callback called from the main loop when either the directory could not be opened or the operation has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_dir_direct_ls() runs eina_file_direct_ls() recursively in a separate thread using
+ * ecore_thread_feedback_run. This prevents any blocking in your apps.
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ */
+EAPI Eio_File *eio_dir_direct_ls(const char *dir,
+                                 Eio_Filter_Dir_Cb filter_cb,
+                                 Eio_Main_Direct_Cb main_cb,
+                                 Eio_Done_Cb done_cb,
+                                 Eio_Error_Cb error_cb,
+                                 const void *data);
+
+/**
+ * @brief Stat a file/directory.
+ * @param path The path to stat.
+ * @param done_cb Callback called from the main loop when stat was successfully called.
+ * @param error_cb Callback called from the main loop when stat failed or has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_direct_stat calls stat in another thread. This prevents any blocking in your apps.
+ */
+EAPI Eio_File *eio_file_direct_stat(const char *path,
+                                    Eio_Stat_Cb done_cb,
+                                    Eio_Error_Cb error_cb,
+                                    const void *data);
+
+/**
+ * @brief Change right of a path.
+ * @param path The directory path to change access right.
+ * @param mode The permission to set, follow (mode & ~umask & 0777).
+ * @param done_cb Callback called when the operation is completed.
+ * @param error_cb Callback called from if something goes wrong.
+ * @param data Unmodified user data passed to callbacks.
+ * @return A reference to the I/O operation.
+ *
+ * Set a new permission of a path changing it to the mode passed as argument.
+ * It's equivalent to the chmod command.
+ */
+EAPI Eio_File *eio_file_chmod(const char *path,
+                              mode_t mode,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+
+/**
+ * @brief Change owner of a path.
+ * @param path The directory path to change owner.
+ * @param user The new user to set (can be NULL).
+ * @param group The new group to set (can be NULL).
+ * @param done_cb Callback called when the operation is completed.
+ * @param error_cb Callback called from if something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * This function will change the owner of a path, setting it to the user and
+ * group passed as argument. It's equivalent to the chown shell command.
+ */
+EAPI Eio_File *eio_file_chown(const char *path,
+                              const char *user,
+                              const char *group,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+
+/**
+ * @brief Unlink a file/directory.
+ * @param path The path to unlink.
+ * @param done_cb Callback called when the operation is completed.
+ * @param error_cb Callback called from if something goes wrong.
+ * @param data Unmodified user data passed to callbacks.
+ * @return A reference to the I/O operation.
+ *
+ * This function will erase a file.
+ */
+EAPI Eio_File *eio_file_unlink(const char *path,
+                               Eio_Done_Cb done_cb,
+                               Eio_Error_Cb error_cb,
+                               const void *data);
+
+/**
+ * @brief Create a new directory.
+ * @param path The directory path to create.
+ * @param mode The permission to set, follow (mode & ~umask & 0777).
+ * @param done_cb Callback called when the operation is completed.
+ * @param error_cb Callback called from if something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * Creates a new directory using the mode provided.
+ */
+EAPI Eio_File *eio_file_mkdir(const char *path,
+                              mode_t mode,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+
+/**
+ * @brief Move a file asynchronously
+ * @param source Should be the name of the file to move the data from.
+ * @param dest Should be the name of the file to move the data to.
+ * @param progress_cb Callback called to know the progress of the move.
+ * @param done_cb Callback called when the move is done.
+ * @param error_cb Callback called when something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ *
+ * This function will copy a file from source to dest. It will try to use splice
+ * if possible, if not it will fallback to mmap/write. It will try to preserve
+ * access right, but not user/group identification.
+ */
+EAPI Eio_File *eio_file_move(const char *source,
+                             const char *dest,
+                             Eio_Progress_Cb progress_cb,
+                             Eio_Done_Cb done_cb,
+                             Eio_Error_Cb error_cb,
+                             const void *data);
+
+/**
+ * @brief Copy a file asynchronously
+ * @param source Should be the name of the file to copy the data from.
+ * @param dest Should be the name of the file to copy the data to.
+ * @param progress_cb Callback called to know the progress of the copy.
+ * @param done_cb Callback called when the copy is done.
+ * @param error_cb Callback called when something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ *
+ * This function will copy a file from source to dest. It will try to use splice
+ * if possible, if not it will fallback to mmap/write. It will try to preserve
+ * access right, but not user/group identification.
+ */
+EAPI Eio_File *eio_file_copy(const char *source,
+                             const char *dest,
+                             Eio_Progress_Cb progress_cb,
+                             Eio_Done_Cb done_cb,
+                             Eio_Error_Cb error_cb,
+                             const void *data);
+
+/**
+ * @brief Move a directory and it's content asynchronously
+ * @param source Should be the name of the directory to copy the data from.
+ * @param dest Should be the name of the directory to copy the data to.
+ * @param filter_cb Possible to deny the move of some files/directories.
+ * @param progress_cb Callback called to know the progress of the copy.
+ * @param done_cb Callback called when the copy is done.
+ * @param error_cb Callback called when something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ *
+ * This function will move a directory and all it's content from source to dest.
+ * It will try first to rename the directory, if not it will try to use splice
+ * if possible, if not it will fallback to mmap/write.
+ * It will try to preserve access right, but not user/group identity.
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ *
+ * @note if a rename occur, the filter callback will not be called.
+ */
+EAPI Eio_File *eio_dir_move(const char *source,
+                            const char *dest,
+                            Eio_Filter_Direct_Cb filter_cb,
+                            Eio_Progress_Cb progress_cb,
+                            Eio_Done_Cb done_cb,
+                            Eio_Error_Cb error_cb,
+                            const void *data);
+
+/**
+ * @brief Copy a directory and it's content asynchronously
+ * @param source Should be the name of the directory to copy the data from.
+ * @param dest Should be the name of the directory to copy the data to.
+ * @param filter_cb Possible to deny the move of some files/directories.
+ * @param progress_cb Callback called to know the progress of the copy.
+ * @param done_cb Callback called when the copy is done.
+ * @param error_cb Callback called when something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ *
+ * This function will copy a directory and all it's content from source to dest.
+ * It will try to use splice if possible, if not it will fallback to mmap/write.
+ * It will try to preserve access right, but not user/group identity.
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ */
+EAPI Eio_File *eio_dir_copy(const char *source,
+                            const char *dest,
+                            Eio_Filter_Direct_Cb filter_cb,
+                            Eio_Progress_Cb progress_cb,
+                            Eio_Done_Cb done_cb,
+                            Eio_Error_Cb error_cb,
+                            const void *data);
+
+/**
+ * @brief Remove a directory and it's content asynchronously
+ * @param path Should be the name of the directory to destroy.
+ * @param filter_cb Possible to deny the move of some files/directories.
+ * @param progress_cb Callback called to know the progress of the copy.
+ * @param done_cb Callback called when the copy is done.
+ * @param error_cb Callback called when something goes wrong.
+ * @param data Unmodified user data passed to callbacks
+ *
+ * This function will remove a directory and all it's content.
+ * Every file will be passed to the filter_cb, so it's your job to decide if you
+ * want to pass the file to the main_cb or not. Return EINA_TRUE to pass it to
+ * the main_cb or EINA_FALSE to ignore it.
+ */
+EAPI Eio_File *eio_dir_unlink(const char *path,
+                              Eio_Filter_Direct_Cb filter_cb,
+                              Eio_Progress_Cb progress_cb,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+/**
+ * @}
+ */
+
+
+/**
+ * @defgroup Eio_Xattr Eio manipulation of eXtended attribute.
+ *
+ * @brief A set of function to manipulate data associated with a specific file
+ *
+ * The functions provided by this API are responsible to manage Extended
+ * attribute files. Like file authors, character encoding, checksum, etc.
+ * @{
+ */
+
+/**
+ * @brief Assynchronously list all eXtended attribute
+ * @param path The path to get the eXtended attribute from.
+ * @param filter_cb Callback called in the thread to validate the eXtended attribute.
+ * @param main_cb Callback called in the main loop for each accepted eXtended attribute.
+ * @param done_cb Callback called in the main loop when the all the eXtended attribute have been listed.
+ * @param error_cb Callback called in the main loop when something goes wrong during the listing of the eXtended attribute.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ */
+EAPI Eio_File *eio_file_xattr(const char *path,
+                              Eio_Filter_Cb filter_cb,
+                              Eio_Main_Cb main_cb,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+
+/**
+ * @brief Define an extented attribute on a file/directory.
+ * @param path The path to set the attribute on.
+ * @param attribute The name of the attribute to define.
+ * @param xattr_int The value to link the attribute with.
+ * @param flags Wether to insert, replace or create the attribute.
+ * @param done_cb The callback called from the main loop when setxattr succeeded.
+ * @param error_cb The callback called from the main loop when setxattr failed.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_int_set calls eina_xattr_int_set from another thread. This prevents blocking in your apps. If
+ * the writing succeeded, the done_cb will be called even if a cancel was requested, but came to late.
+ */
+EAPI Eio_File *eio_file_xattr_int_set(const char *path,
+                                      const char *attribute,
+                                      int xattr_int,
+                                      Eina_Xattr_Flags flags,
+                                      Eio_Done_Cb done_cb,
+                                      Eio_Error_Cb error_cb,
+                                      const void *data);
+
+/**
+ * @brief Define an extented attribute on a file/directory.
+ * @param path The path to set the attribute on.
+ * @param attribute The name of the attribute to define.
+ * @param xattr_double The value to link the attribute with.
+ * @param flags Wether to insert, replace or create the attribute.
+ * @param done_cb The callback called from the main loop when setxattr succeeded.
+ * @param error_cb The callback called from the main loop when setxattr failed.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_double_set calls eina_xattr_double_set from another thread. This prevents blocking in your apps. If
+ * the writing succeeded, the done_cb will be called even if a cancel was requested, but came to late.
+ */
+EAPI Eio_File *eio_file_xattr_double_set(const char *path,
+                                         const char *attribute,
+                                         double xattr_double,
+                                         Eina_Xattr_Flags flags,
+                                         Eio_Done_Cb done_cb,
+                                         Eio_Error_Cb error_cb,
+                                         const void *data);
+/**
+ * @brief Define a string extented attribute on a file/directory.
+ * @param path The path to set the attribute on.
+ * @param attribute The name of the attribute to define.
+ * @param xattr_string The string to link the attribute with.
+ * @param flags Wether to insert, replace or create the attribute.
+ * @param done_cb The callback called from the main loop when setxattr succeeded.
+ * @param error_cb The callback called from the main loop when setxattr failed.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_string_set calls eina_xattr_string_set from another thread. This prevents blocking in your apps. If
+ * the writing succeeded, the done_cb will be called even if a cancel was requested, but came to late.
+ */
+EAPI Eio_File *eio_file_xattr_string_set(const char *path,
+                                         const char *attribute,
+                                         const char *xattr_string,
+                                         Eina_Xattr_Flags flags,
+                                         Eio_Done_Cb done_cb,
+                                         Eio_Error_Cb error_cb,
+                                         const void *data);
+/**
+ * @brief Define an extented attribute on a file/directory.
+ * @param path The path to set the attribute on.
+ * @param attribute The name of the attribute to define.
+ * @param xattr_data The data to link the attribute with.
+ * @param xattr_size The size of the data to set.
+ * @param flags Wether to insert, replace or create the attribute.
+ * @param done_cb The callback called from the main loop when setxattr succeeded.
+ * @param error_cb The callback called from the main loop when setxattr failed.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_set calls setxattr from another thread. This prevents blocking in your apps. If
+ * the writing succeeded, the done_cb will be called even if a cancel was requested, but came to late.
+ */
+EAPI Eio_File *eio_file_xattr_set(const char *path,
+                                  const char *attribute,
+                                  const char *xattr_data,
+                                  unsigned int xattr_size,
+                                  Eina_Xattr_Flags flags,
+                                  Eio_Done_Cb done_cb,
+                                  Eio_Error_Cb error_cb,
+                                  const void *data);
+
+/**
+ * @brief Retrieve the extended attribute of a file/directory.
+ * @param path The path to retrieve the extended attribute from.
+ * @param attribute The name of the attribute to retrieve.
+ * @param done_cb Callback called from the main loop when getxattr succeeded.
+ * @param error_cb Callback called from the main loop when getxattr failed or has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_get calls getxattr from another thread. This prevents blocking in your apps.
+ */
+EAPI Eio_File *eio_file_xattr_get(const char *path,
+                                  const char *attribute,
+                                  Eio_Done_Data_Cb done_cb,
+                                  Eio_Error_Cb error_cb,
+                                  const void *data);
+/**
+ * @brief Retrieve a extended attribute of a file/directory.
+ * @param path The path to retrieve the extended attribute from.
+ * @param attribute The name of the attribute to retrieve.
+ * @param done_cb Callback called from the main loop when getxattr succeeded.
+ * @param error_cb Callback called from the main loop when getxattr failed or has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_int_get calls eina_xattr_int_get from another thread. This prevents blocking in your apps.
+ */
+EAPI Eio_File *eio_file_xattr_int_get(const char *path,
+                                      const char *attribute,
+                                      Eio_Done_Int_Cb done_cb,
+                                      Eio_Error_Cb error_cb,
+                                      const void *data);
+/**
+ * @brief Retrieve a extended attribute of a file/directory.
+ * @param path The path to retrieve the extended attribute from.
+ * @param attribute The name of the attribute to retrieve.
+ * @param done_cb Callback called from the main loop when getxattr succeeded.
+ * @param error_cb Callback called from the main loop when getxattr failed or has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_double_get calls eina_xattr_double_get from another thread. This prevents blocking in your apps.
+ */
+EAPI Eio_File *eio_file_xattr_double_get(const char *path,
+                                         const char *attribute,
+                                         Eio_Done_Double_Cb done_cb,
+                                         Eio_Error_Cb error_cb,
+                                         const void *data);
+/**
+ * @brief Retrieve a string extended attribute of a file/directory.
+ * @param path The path to retrieve the extended attribute from.
+ * @param attribute The name of the attribute to retrieve.
+ * @param done_cb Callback called from the main loop when getxattr succeeded.
+ * @param error_cb Callback called from the main loop when getxattr failed or has been canceled.
+ * @param data Unmodified user data passed to callbacks
+ * @return A reference to the I/O operation.
+ *
+ * eio_file_xattr_string_get calls eina_xattr_string_get from another thread. This prevents blocking in your apps.
+ */
+EAPI Eio_File *eio_file_xattr_string_get(const char *path,
+                                         const char *attribute,
+                                         Eio_Done_String_Cb done_cb,
+                                         Eio_Error_Cb error_cb,
+                                         const void *data);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Eio_Helper Eio Reference helper API
+ *
+ * @brief This are helper provided around core Eio API.
+ *
+ * This set of functions do provide helper to work around data
+ * provided by Eio without the need to look at system header.
+ *
+ * @{
+ */
+
+
+/**
+ * @brief Initialize eio and all it's required submodule.
+ * @return the current number of eio users.
+ */
+EAPI int eio_init(void);
+
+/**
+ * @brief Shutdown eio and all it's submodule if possible.
+ * @return the number of pending users of eio.
+ */
+EAPI int eio_shutdown(void);
+
+/**
+ * @brief Return the container during EIO operation
+ * @param ls The asynchronous I/O operation to retrieve container from.
+ * @return NULL if not available, a DIRP if it is.
+ *
+ * This is only available and make sense in the thread callback, not in
+ * the mainloop.
+ */
+EAPI void *eio_file_container_get(Eio_File *ls);
+
+/**
+ * @brief Cancel any Eio_File.
+ * @param ls The asynchronous I/O operation to cancel.
+ * @return EINA_FALSE if the destruction is delayed, EINA_TRUE if it's done.
+ *
+ * This will cancel any kind of I/O operation and cleanup the mess. This means
+ * that it could take time to cancel an I/O.
+ */
+EAPI Eina_Bool eio_file_cancel(Eio_File *ls);
+
+/**
+ * @brief Check if an Eio_File operation has been cancelled.
+ * @param ls The asynchronous I/O operation to check.
+ * @return EINA_TRUE if it was canceled, EINA_FALSE other wise.
+ *
+ * In case of an error it also return EINA_TRUE.
+ */
+EAPI Eina_Bool eio_file_check(Eio_File *ls);
+
+/**
+ * @brief Associate data with the current filtered file.
+ * @param ls The Eio_File ls request currently calling the filter callback.
+ * @param key The key to associate data to.
+ * @param data The data to associate the data to.
+ * @param free_cb Optionally a function to call to free the associated data,
+ * @p data is passed as the callback data parameter. If no @free_cb is provided
+ * the user @p data remains untouched.
+ * @return EINA_TRUE if insertion was fine.
+ *
+ * This function can only be safely called from within the filter callback.
+ * If you don't need to copy the key around you can use @ref eio_file_associate_direct_add
+ */
+EAPI Eina_Bool eio_file_associate_add(Eio_File *ls,
+                                      const char *key,
+                                      const void *data, Eina_Free_Cb free_cb);
+
+/**
+ * @brief Associate data with the current filtered file.
+ * @param ls The Eio_File ls request currently calling the filter callback.
+ * @param key The key to associate data to (will not be copied, and the pointer will not be used as long as the file is not notified).
+ * @param data The data to associate the data to.
+ * @param free_cb The function to call to free the associated data, @p free will be called if not specified.
+ * @return EINA_TRUE if insertion was fine.
+ *
+ * This function can only be safely called from within the filter callback.
+ * If you need eio to make a proper copy of the @p key to be safe use
+ * @ref eio_file_associate_add instead.
+ */
+EAPI Eina_Bool eio_file_associate_direct_add(Eio_File *ls,
+                                             const char *key,
+                                             const void *data, Eina_Free_Cb free_cb);
+
+/**
+ * @brief Get the data associated during the filter callback inside the main loop
+ * @param ls The Eio_File ls request currently calling the notify callback.
+ * @param key The key pointing to the data to retrieve.
+ * @return the data associated with the key or @p NULL if not found.
+ */
+EAPI void *eio_file_associate_find(Eio_File *ls, const char *key);
+
+/**
+ * @brief get access time from a Eina_Stat
+ * @param stat the structure to get the atime from
+ * @return the last accessed time
+ *
+ * This take care of doing type conversion to match rest of EFL time API.
+ * @note some filesystem don't update that information.
+ */
+static inline double eio_file_atime(const Eina_Stat *stat);
+
+/**
+ * @brief get modification time from a Eina_Stat
+ * @param stat the structure to get the mtime from
+ * @return the last modification time
+ *
+ * This take care of doing type conversion to match rest of EFL time API.
+ */
+static inline double eio_file_mtime(const Eina_Stat *stat);
+
+/**
+ * @brief get the size of the file described in Eina_Stat
+ * @param stat the structure to get the size from
+ * @return the size of the file
+ */
+static inline long long eio_file_size(const Eina_Stat *stat);
+
+/**
+ * @brief tell if the stated path was a directory or not.
+ * @param stat the structure to get the size from
+ * @return EINA_TRUE, if it was.
+ */
+static inline Eina_Bool eio_file_is_dir(const Eina_Stat *stat);
+
+/**
+ * @brief tell if the stated path was a link or not.
+ * @param stat the structure to get the size from
+ * @return EINA_TRUE, if it was.
+ */
+static inline Eina_Bool eio_file_is_lnk(const Eina_Stat *stat);
+
+/**
+ * @}
+ */
+
+/**
+ *
+ */
+
+/**
+ * @defgroup Eio_Map Manipulate an Eina_File asynchronously
+ *
+ * @brief This function help manipulating file asynchronously.
+ *
+ * This set of function work on top of Eina_File and Ecore_Thread to
+ * do basic operations in a file, like openning, closing and mapping a file to
+ * memory.
+ * @{
+ */
+
+/**
+ * @brief Assynchronously open a file.
+ * @param name The file to open.
+ * @param shared If it's a shared memory file.
+ * @param open_cb Callback called in the main loop when the file has been successfully opened.
+ * @param error_cb Callback called in the main loop when the file couldn't be opened.
+ * @param data Unmodified user data passed to callbacks
+ * @return Pointer to the file if successfull or NULL otherwise.
+ *
+ */
+EAPI Eio_File *eio_file_open(const char *name, Eina_Bool shared,
+                             Eio_Open_Cb open_cb,
+                             Eio_Error_Cb error_cb,
+                             const void *data);
+
+/**
+ * @brief Assynchronously close a file.
+ * @param f The file to close.
+ * @param done_cb Callback called in the main loop when the file has been successfully closed.
+ * @param error_cb Callback called in the main loop when the file couldn't be closed.
+ * @param data Unmodified user data passed to callbacks
+ * @return Pointer to the file if successfull or NULL otherwise.
+ */
+EAPI Eio_File *eio_file_close(Eina_File *f,
+                              Eio_Done_Cb done_cb,
+                              Eio_Error_Cb error_cb,
+                              const void *data);
+
+/**
+ * @brief Assynchronously map a file in memory.
+ * @param f The file to map.
+ * @param rule The rule to apply to the map.
+ * @param filter_cb Callback called in the thread to validate the content of the map.
+ * @param map_cb Callback called in the main loop when the file has been successfully mapped.
+ * @param error_cb Callback called in the main loop when the file can't be mapped.
+ * @param data Unmodified user data passed to callbacks
+ * @return Pointer to the file if successfull or NULL otherwise.
+ *
+ * The container of the Eio_File is the Eina_File.
+ */
+EAPI Eio_File *eio_file_map_all(Eina_File *f,
+                                Eina_File_Populate rule,
+                                Eio_Filter_Map_Cb filter_cb,
+                                Eio_Map_Cb map_cb,
+                                Eio_Error_Cb error_cb,
+                                const void *data);
+
+/**
+ * @brief Assynchronously map a part of a file in memory.
+ * @param f The file to map.
+ * @param rule The rule to apply to the map.
+ * @param offset The offset inside the file
+ * @param length The length of the memory to map
+ * @param filter_cb Callback called in the thread to validate the content of the map.
+ * @param map_cb Callback called in the main loop when the file has been successfully mapped.
+ * @param error_cb Callback called in the main loop when the file can't be mapped.
+ * @param data Unmodified user data passed to callbacks
+ * @return Pointer to the file if successfull or NULL otherwise.
+ *
+ * The container of the Eio_File is the Eina_File.
+ */
+EAPI Eio_File *eio_file_map_new(Eina_File *f,
+                                Eina_File_Populate rule,
+                                unsigned long int offset,
+                                unsigned long int length,
+                                Eio_Filter_Map_Cb filter_cb,
+                                Eio_Map_Cb map_cb,
+                                Eio_Error_Cb error_cb,
+                                const void *data);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Eio_Eet Eio asynchronous API for Eet file.
+ *
+ * @brief This set of functions help in the asynchronous use of Eet
+ *
+ * @{
+ */
+
+/**
+ * @brief Open an eet file on disk, and returns a handle to it asynchronously.
+ * @param filename The file path to the eet file. eg: @c "/tmp/file.eet".
+ * @param mode The mode for opening. Either EET_FILE_MODE_READ,
+ *        EET_FILE_MODE_WRITE or EET_FILE_MODE_READ_WRITE.
+ * @param eet_cb The callback to call when the file has been successfully opened.
+ * @param error_cb Callback called in the main loop when the file can't be opened.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ *
+ * This function calls eet_open() from another thread using Ecore_Thread.
+ */
+EAPI Eio_File *eio_eet_open(const char *filename,
+                            Eet_File_Mode mode,
+                            Eio_Eet_Open_Cb eet_cb,
+                            Eio_Error_Cb error_cb,
+                            const void *data);
+/**
+ * @brief Close an eet file handle and flush pending writes asynchronously.
+ * @param ef A valid eet file handle.
+ * @param done_cb Callback called from the main loop when the file has been closed.
+ * @param error_cb Callback called in the main loop when the file can't be closed.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ *
+ * This function will call eet_close() from another thread by
+ * using Ecore_Thread. You should assume that the Eet_File is dead after this
+ * function is called.
+ */
+EAPI Eio_File *eio_eet_close(Eet_File *ef,
+                             Eio_Done_Cb done_cb,
+                             Eio_Eet_Error_Cb error_cb,
+                             const void *data);
+
+/**
+ * @brief Sync content of an eet file handle, flushing pending writes asynchronously.
+ * @param ef A valid eet file handle.
+ * @param done_cb Callback called from the main loop when the file has been synced.
+ * @param error_cb Callback called in the main loop when the file can't be synced.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ *
+ * This function will call eet_flush() from another thread. As long as the done_cb or
+ * error_cb haven't be called, you must keep @p ef open.
+ */
+EAPI Eio_File *eio_eet_sync(Eet_File *ef,
+                            Eio_Done_Cb done_cb,
+                            Eio_Eet_Error_Cb error_cb,
+                            const void *data);
+
+/**
+ * @brief Write a data structure from memory and store in an eet file
+ * using a cipher asynchronously.
+ * @param ef The eet file handle to write to.
+ * @param edd The data descriptor to use when encoding.
+ * @param name The key to store the data under in the eet file.
+ * @param cipher_key The key to use as cipher.
+ * @param write_data A pointer to the data structure to save and encode.
+ * @param compress Compression flags for storage.
+ * @param done_cb Callback called from the main loop when the data has been put in the Eet_File.
+ * @param error_cb Callback called in the main loop when the file can't be written.
+ * @param user_data Private data given to each callback.
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_data_write_cipher(Eet_File *ef,
+                                         Eet_Data_Descriptor *edd,
+                                         const char *name,
+                                         const char *cipher_key,
+                                         void *write_data,
+                                         int compress,
+                                         Eio_Done_Int_Cb done_cb,
+                                         Eio_Error_Cb error_cb,
+                                         const void *user_data);
+
+/**
+ * @brief Read a data structure from an eet file and decodes it using a cipher asynchronously.
+ * @param ef The eet file handle to read from.
+ * @param edd The data descriptor handle to use when decoding.
+ * @param name The key the data is stored under in the eet file.
+ * @param cipher_key The key to use as cipher.
+ * @param done_cb Callback called from the main loop when the data has been read and decoded.
+ * @param error_cb Callback called in the main loop when the data can't be read.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_data_read_cipher(Eet_File *ef,
+                                        Eet_Data_Descriptor *edd,
+                                        const char *name,
+                                        const char *cipher_key,
+                                        Eio_Done_ERead_Cb done_cb,
+                                        Eio_Error_Cb error_cb,
+                                        const void *data);
+
+/**
+ * @brief Write image data to the named key in an eet file asynchronously.
+ * @param ef A valid eet file handle opened for writing.
+ * @param name Name of the entry. eg: "/base/file_i_want".
+ * @param cipher_key The key to use as cipher.
+ * @param write_data A pointer to the image pixel data.
+ * @param w The width of the image in pixels.
+ * @param h The height of the image in pixels.
+ * @param alpha The alpha channel flag.
+ * @param compress The compression amount.
+ * @param quality The quality encoding amount.
+ * @param lossy The lossiness flag.
+ * @param done_cb Callback called from the main loop when the data has been put in the Eet_File.
+ * @param error_cb Callback called in the main loop when the file can't be written.
+ * @param user_data Private data given to each callback.
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_data_image_write_cipher(Eet_File *ef,
+                                               const char *name,
+                                               const char *cipher_key,
+                                               void *write_data,
+                                               unsigned int w,
+                                               unsigned int h,
+                                               int alpha,
+                                               int compress,
+                                               int quality,
+                                               int lossy,
+                                               Eio_Done_Int_Cb done_cb,
+                                               Eio_Error_Cb error_cb,
+                                               const void *user_data);
+
+/**
+ * @brief Read a specified entry from an eet file and return data
+ * @param ef A valid eet file handle opened for reading.
+ * @param name Name of the entry. eg: "/base/file_i_want".
+ * @param done_cb Callback called from the main loop when the data has been read.
+ * @param error_cb Callback called in the main loop when the data can't be read.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_read_direct(Eet_File *ef,
+                                   const char *name,
+                                   Eio_Done_Data_Cb done_cb,
+                                   Eio_Error_Cb error_cb,
+                                   const void *data);
+
+/**
+ * @brief Read a specified entry from an eet file and return data
+ * @param ef A valid eet file handle opened for reading.
+ * @param name Name of the entry. eg: "/base/file_i_want".
+ * @param cipher_key The key to use as cipher.
+ * @param done_cb Callback called from the main loop when the data has been read.
+ * @param error_cb Callback called in the main loop when the data can't be read.
+ * @param data Unmodified user data passed to callbacks
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_read_cipher(Eet_File *ef,
+                                   const char *name,
+                                   const char *cipher_key,
+                                   Eio_Done_Read_Cb done_cb,
+                                   Eio_Error_Cb error_cb,
+                                   const void *data);
+
+/**
+ * @brief Write a specified entry to an eet file handle using a cipher.
+ * @param ef A valid eet file handle opened for writing.
+ * @param name Name of the entry. eg: "/base/file_i_want".
+ * @param write_data Pointer to the data to be stored.
+ * @param size Length in bytes in the data to be stored.
+ * @param compress Compression flags (1 == compress, 0 = don't compress).
+ * @param cipher_key The key to use as cipher.
+ * @param done_cb Callback called from the main loop when the data has been put in the Eet_File.
+ * @param error_cb Callback called in the main loop when the file can't be written.
+ * @param user_data Private data given to each callback.
+ * @return NULL in case of a failure.
+ */
+EAPI Eio_File *eio_eet_write_cipher(Eet_File *ef,
+                                    const char *name,
+                                    void *write_data,
+                                    int size,
+                                    int compress,
+                                    const char *cipher_key,
+                                    Eio_Done_Int_Cb done_cb,
+                                    Eio_Error_Cb error_cb,
+                                    const void *user_data);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Eio_Monitor Eio file and directory monitoring API
+ *
+ * @brief These function monitor changes in directories and files
+ *
+ * These functions use the best available method to monitor changes on a specified directory
+ * or file. They send ecore events when changes occur, and they maintain internal refcounts to
+ * reduce resource consumption on duplicate monitor targets.
+ *
+ * @{
+ */
+
+EAPI extern int EIO_MONITOR_FILE_CREATED; /**< A new file was created in a watched directory */
+EAPI extern int EIO_MONITOR_FILE_DELETED; /**< A watched file was deleted, or a file in a watched directory was deleted */
+EAPI extern int EIO_MONITOR_FILE_MODIFIED; /**< A file was modified in a watched directory */
+EAPI extern int EIO_MONITOR_FILE_CLOSED; /**< A file was closed in a watched directory. This event is never sent on Windows */
+EAPI extern int EIO_MONITOR_DIRECTORY_CREATED; /**< A new directory was created in a watched directory */
+EAPI extern int EIO_MONITOR_DIRECTORY_DELETED; /**< A directory has been deleted: this can be either a watched directory or one of its subdirectories */
+EAPI extern int EIO_MONITOR_DIRECTORY_MODIFIED; /**< A directory has been modified in a watched directory */
+EAPI extern int EIO_MONITOR_DIRECTORY_CLOSED; /**< A directory has been closed in a watched directory. This event is never sent on Windows */
+EAPI extern int EIO_MONITOR_SELF_RENAME; /**< The monitored path has been renamed, an error could happen just after if the renamed path doesn't exist */
+EAPI extern int EIO_MONITOR_SELF_DELETED; /**< The monitored path has been removed */
+EAPI extern int EIO_MONITOR_ERROR; /**< During operation the monitor failed and will no longer work. eio_monitor_del must be called on it. */
+
+typedef struct _Eio_Monitor Eio_Monitor;
+
+typedef struct _Eio_Monitor_Error Eio_Monitor_Error;
+typedef struct _Eio_Monitor_Event Eio_Monitor_Event;
+
+struct _Eio_Monitor_Error
+{
+   Eio_Monitor *monitor;
+   int error;
+};
+
+struct _Eio_Monitor_Event
+{
+   Eio_Monitor *monitor;
+   const char *filename;
+};
+
+/**
+ * @brief Adds a file/directory to monitor (inotify mechanism)
+ * @param path file/directory to monitor
+ * @return NULL in case of a failure or a pointer to the monitor in case of
+ * success.
+ *
+ * This function will add the given path to its internal
+ * list of files to monitor. It utilizes the inotify mechanism
+ * introduced in kernel 2.6.13 for passive monitoring.
+ */
+EAPI Eio_Monitor *eio_monitor_add(const char *path);
+
+/**
+ * @brief Adds a file/directory to monitor
+ * @param path file/directory to monitor
+ * @return NULL in case of a failure or a pointer to the monitor in case of
+ * success.
+ * @warning Do NOT pass non-stringshared strings to this function!
+ *  If you don't know what this means, use eio_monitor_add().
+ *
+ * This fuction is just like eio_monitor_add(), however the string passed by
+ * argument must be created using eina_stringshare_add().
+ */
+EAPI Eio_Monitor *eio_monitor_stringshared_add(const char *path);
+
+/**
+ * @brief Deletes a path from the “watched” list
+ * @param monitor The Eio_Monitor you want to stop watching.
+ *  It can only be an Eio_Monitor returned to you from calling
+ *  eio_monitor_add() or eio_monitor_stringshared_add()
+ */
+EAPI void eio_monitor_del(Eio_Monitor *monitor);
+
+/**
+ * @brief returns the path being watched by the given
+ *  Eio_Monitor.
+ * @param monitor Eio_Monitor to return the path of
+ * @return The stringshared path belonging to @p monitor
+ */
+EAPI const char *eio_monitor_path_get(Eio_Monitor *monitor);
+
+/**
+ * @}
+ */
+
+#include "eio_inline_helper.x"
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/src/lib/eio/eio_dir.c b/src/lib/eio/eio_dir.c
new file mode 100644
index 0000000000..71cc3a0540
--- /dev/null
+++ b/src/lib/eio/eio_dir.c
@@ -0,0 +1,1001 @@
+/* EIO - EFL data type library
+ * Copyright (C) 2010 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"
+
+/*============================================================================*
+ *                                  Local                                     *
+ *============================================================================*/
+
+/**
+ * @cond LOCAL
+ */
+
+static int
+eio_strcmp(const void *a, const void *b)
+{
+   return strcmp(a, b);
+}
+static Eina_Bool
+_eio_dir_recursive_progress(Eio_Dir_Copy *copy, Eio_File *handler, const Eina_File_Direct_Info *info)
+{
+   if (copy->filter_cb && !copy->filter_cb(&copy->progress.common.data, handler, info))
+     return EINA_FALSE;
+
+   switch (info->type)
+     {
+      case EINA_FILE_UNKNOWN:
+         eio_file_thread_error(&copy->progress.common, handler->thread);
+         return EINA_FALSE;
+      case EINA_FILE_LNK:
+         copy->links = eina_list_append(copy->links, eina_stringshare_add(info->path));
+         break;
+      case EINA_FILE_DIR:
+         copy->dirs = eina_list_append(copy->dirs, eina_stringshare_add(info->path));
+         break;
+      default:
+         copy->files = eina_list_append(copy->files, eina_stringshare_add(info->path));
+         break;
+     }
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_eio_file_recursiv_ls(Ecore_Thread *thread,
+                      Eio_File *common,
+                      Eio_Filter_Direct_Cb filter_cb,
+                      Eina_Iterator *(*Eina_File_Ls)(const char *target),
+                      void *data,
+                      const char *target)
+{
+   Eina_File_Direct_Info *info;
+   Eina_Iterator *it = NULL;
+   Eina_List *dirs = NULL;
+   const char *dir;
+
+   it = Eina_File_Ls(target);
+   if (!it)
+     {
+        eio_file_thread_error(common, thread);
+        return EINA_FALSE;
+     }
+
+   eio_file_container_set(common, eina_iterator_container_get(it));
+
+   EINA_ITERATOR_FOREACH(it, info)
+     {
+        Eina_Bool filter = EINA_TRUE;
+        _eio_stat_t buffer;
+
+        switch (info->type)
+          {
+           case EINA_FILE_DIR:
+              if (_eio_lstat(info->path, &buffer) != 0)
+                continue;
+
+              if (S_ISLNK(buffer.st_mode))
+                info->type = EINA_FILE_LNK;
+           default:
+              break;
+          }
+
+        filter = filter_cb(data, common, info);
+        if (filter && info->type == EINA_FILE_DIR)
+          dirs = eina_list_append(dirs, eina_stringshare_add(info->path));
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+     }
+
+   eio_file_container_set(common, NULL);
+
+   eina_iterator_free(it);
+   it = NULL;
+
+   EINA_LIST_FREE(dirs, dir)
+     {
+       Eina_Bool err;
+
+       err = !_eio_file_recursiv_ls(thread, common, filter_cb, Eina_File_Ls, data, dir);
+
+       eina_stringshare_del(dir);
+       if (err) goto on_error;
+     }
+
+   return EINA_TRUE;
+
+ on_error:
+   if (it) eina_iterator_free(it);
+
+   EINA_LIST_FREE(dirs, dir)
+     eina_stringshare_del(dir);
+
+   return EINA_FALSE;
+}
+
+
+static Eina_Bool
+_eio_dir_recursiv_ls(Ecore_Thread *thread, Eio_Dir_Copy *copy, const char *target)
+{
+   if (!_eio_file_recursiv_ls(thread, &copy->progress.common,
+                              (Eio_Filter_Direct_Cb) _eio_dir_recursive_progress,
+                              eina_file_stat_ls,
+                              copy, target))
+     return EINA_FALSE;
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_eio_dir_init(Ecore_Thread *thread,
+              long long *step, long long *count,
+              int *length_source, int *length_dest,
+              Eio_Dir_Copy *order,
+              Eio_File_Progress *progress)
+{
+   struct stat buffer;
+
+   /* notify main thread of the amount of work todo */
+   *step = 0;
+   *count = eina_list_count(order->files)
+     + eina_list_count(order->dirs) * 2
+     + eina_list_count(order->links);
+   eio_progress_send(thread, &order->progress, *step, *count);
+
+   /* sort the content, so we create the directory in the right order */
+   order->dirs = eina_list_sort(order->dirs, -1, eio_strcmp);
+   order->files = eina_list_sort(order->files, -1, eio_strcmp);
+   order->links = eina_list_sort(order->links, -1, eio_strcmp);
+
+   /* prepare stuff */
+   *length_source = eina_stringshare_strlen(order->progress.source);
+   *length_dest = eina_stringshare_strlen(order->progress.dest);
+
+   memcpy(progress, &order->progress, sizeof (Eio_File_Progress));
+   progress->source = NULL;
+   progress->dest = NULL;
+
+   /* create destination dir if not available */
+   if (stat(order->progress.dest, &buffer) != 0)
+     {
+        if (stat(order->progress.source, &buffer) != 0)
+          {
+             eio_file_thread_error(&order->progress.common, thread);
+             return EINA_FALSE;
+          }
+
+        if (mkdir(order->progress.dest, buffer.st_mode) != 0)
+          {
+             eio_file_thread_error(&order->progress.common, thread);
+             return EINA_FALSE;
+          }
+     }
+
+   return EINA_TRUE;
+}
+
+static void
+_eio_dir_target(Eio_Dir_Copy *order, char *target, const char *dir, int length_source, int length_dest)
+{
+   int length;
+
+   length = eina_stringshare_strlen(dir);
+
+   memcpy(target, order->progress.dest, length_dest);
+   target[length_dest] = '/';
+   memcpy(target + length_dest + 1, dir + length_source, length - length_source + 1);
+}
+
+static Eina_Bool
+_eio_dir_mkdir(Ecore_Thread *thread, Eio_Dir_Copy *order,
+               long long *step, long long count,
+               int length_source, int length_dest)
+{
+   const char *dir;
+   Eina_List *l;
+   char target[PATH_MAX];
+
+   /* create all directory */
+   EINA_LIST_FOREACH(order->dirs, l, dir)
+     {
+        /* build target dir path */
+        _eio_dir_target(order, target, dir, length_source, length_dest);
+
+        /* create the directory (we will apply the mode later) */
+        if (mkdir(target, 0777) != 0)
+          {
+             eio_file_thread_error(&order->progress.common, thread);
+             return EINA_FALSE;
+          }
+
+        /* inform main thread */
+        (*step)++;
+        eio_progress_send(thread, &order->progress, *step, count);
+
+        /* check for cancel request */
+        if (ecore_thread_check(thread))
+          return EINA_FALSE;
+     }
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_eio_dir_link(Ecore_Thread *thread, Eio_Dir_Copy *order,
+              long long *step, long long count,
+              int length_source, int length_dest)
+{
+   const char *ln;
+   Eina_List *l;
+   char oldpath[PATH_MAX];
+   char target[PATH_MAX];
+   char buffer[PATH_MAX];
+   char *newpath;
+
+   /* Build once the base of the link target */
+   memcpy(buffer, order->progress.dest, length_dest);
+   buffer[length_dest] = '/';
+
+   /* recreate all links */
+   EINA_LIST_FOREACH(order->links, l, ln)
+     {
+        ssize_t length;
+
+        /* build oldpath link */
+        _eio_dir_target(order, oldpath, ln, length_source, length_dest);
+
+        /* read link target */
+        length = readlink(ln, target, PATH_MAX);
+        if (length < 0)
+          goto on_error;
+
+        if (strncmp(target, order->progress.source, length_source) == 0)
+          {
+             /* The link is inside the zone to copy, so rename it */
+             memcpy(buffer + length_dest + 1, target + length_source, length - length_source + 1);
+             newpath = target;
+          }
+        else
+          {
+             /* The link is outside the zone to copy */
+             newpath = target;
+          }
+
+        /* create the link */
+        if (symlink(newpath, oldpath) != 0)
+          goto on_error;
+
+        /* inform main thread */
+        (*step)++;
+        eio_progress_send(thread, &order->progress, *step, count);
+
+        /* check for cancel request */
+        if (ecore_thread_check(thread))
+          return EINA_FALSE;
+     }
+
+   return EINA_TRUE;
+
+ on_error:
+   eio_file_thread_error(&order->progress.common, thread);
+   return EINA_FALSE;
+}
+
+static Eina_Bool
+_eio_dir_chmod(Ecore_Thread *thread, Eio_Dir_Copy *order,
+               long long *step, long long count,
+               int length_source, int length_dest,
+               Eina_Bool rmdir_source)
+{
+   const char *dir;
+   char target[PATH_MAX];
+   struct stat buffer;
+
+   while(order->dirs)
+     {
+        /* destroy in reverse order so that we don't prevent change of lower dir */
+        dir = eina_list_data_get(eina_list_last(order->dirs));
+        order->dirs = eina_list_remove_list(order->dirs, eina_list_last(order->dirs));
+
+        /* build target dir path */
+        _eio_dir_target(order, target, dir, length_source, length_dest);
+
+        /* FIXME: in some case we already did a stat call, so would be nice to reuse previous result here */
+        /* stat the original dir for mode info */
+        if (stat(dir, &buffer) != 0)
+          goto on_error;
+
+        /* set the orginal mode to the newly created dir */
+        if (chmod(target, buffer.st_mode) != 0)
+          goto on_error;
+
+        /* if required destroy original directory */
+        if (rmdir_source)
+          {
+             if (rmdir(dir) != 0)
+               goto on_error;
+          }
+
+        /* inform main thread */
+        (*step)++;
+        eio_progress_send(thread, &order->progress, *step, count);
+
+        /* check for cancel request */
+        if (ecore_thread_check(thread))
+          goto on_cancel;
+
+        eina_stringshare_del(dir);
+     }
+
+   return EINA_TRUE;
+
+ on_error:
+   eio_file_thread_error(&order->progress.common, thread);
+ on_cancel:
+   if (dir) eina_stringshare_del(dir);
+   return EINA_FALSE;
+}
+
+static void
+_eio_dir_copy_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_Dir_Copy *copy = data;
+   const char *file = NULL;
+   const char *dir;
+   const char *ln;
+
+   Eio_File_Progress file_copy;
+   char target[PATH_MAX];
+
+   int length_source = 0;
+   int length_dest = 0;
+   long long count;
+   long long step;
+
+   /* list all the content that should be copied */
+   if (!_eio_dir_recursiv_ls(thread, copy, copy->progress.source))
+     return ;
+
+   /* init all structure needed to copy the file */
+   if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, copy, &file_copy))
+     goto on_error;
+
+   /* suboperation is a file copy */
+   file_copy.op = EIO_FILE_COPY;
+
+   /* create all directory */
+   if (!_eio_dir_mkdir(thread, copy, &step, count, length_source, length_dest))
+     goto on_error;
+
+   /* copy all files */
+   EINA_LIST_FREE(copy->files, file)
+     {
+        /* build target file path */
+        _eio_dir_target(copy, target, file, length_source, length_dest);
+
+        file_copy.source = file;
+        file_copy.dest = eina_stringshare_add(target);
+
+        /* copy the file */
+        if (!eio_file_copy_do(thread, &file_copy))
+          {
+             copy->progress.common.error = file_copy.common.error;
+             goto on_error;
+          }
+
+        /* notify main thread */
+        step++;
+        eio_progress_send(thread, &copy->progress, step, count);
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+
+        eina_stringshare_del(file_copy.dest);
+        eina_stringshare_del(file);
+     }
+   file_copy.dest = NULL;
+   file = NULL;
+
+   /* recreate link */
+   if (!_eio_dir_link(thread, copy, &step, count, length_source, length_dest))
+     goto on_error;
+
+   /* set directory right back */
+   if (!_eio_dir_chmod(thread, copy, &step, count, length_source, length_dest, EINA_FALSE))
+     goto on_error;
+
+ on_error:
+   /* cleanup the mess */
+   if (file_copy.dest) eina_stringshare_del(file_copy.dest);
+   if (file) eina_stringshare_del(file);
+
+   EINA_LIST_FREE(copy->files, file)
+     eina_stringshare_del(file);
+   EINA_LIST_FREE(copy->dirs, dir)
+     eina_stringshare_del(dir);
+   EINA_LIST_FREE(copy->links, ln)
+     eina_stringshare_del(ln);
+
+   if (!ecore_thread_check(thread))
+     eio_progress_send(thread, &copy->progress, count, count);
+
+   return ;
+}
+
+static void
+_eio_dir_copy_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_Dir_Copy *copy = data;
+   Eio_Progress *progress = msg_data;
+
+   eio_progress_cb(progress, &copy->progress);
+}
+
+static void
+_eio_dir_copy_free(Eio_Dir_Copy *copy)
+{
+   eina_stringshare_del(copy->progress.source);
+   eina_stringshare_del(copy->progress.dest);
+   eio_file_free(&copy->progress.common);
+}
+
+static void
+_eio_dir_copy_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Dir_Copy *copy = data;
+
+   copy->progress.common.done_cb((void*) copy->progress.common.data, &copy->progress.common);
+
+   _eio_dir_copy_free(copy);
+}
+
+static void
+_eio_dir_copy_error(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Dir_Copy *copy = data;
+
+   eio_file_error(&copy->progress.common);
+
+   _eio_dir_copy_free(copy);
+}
+
+static void
+_eio_dir_move_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_Dir_Copy *move = data;
+   const char *file = NULL;
+   const char *dir = NULL;
+
+   Eio_File_Progress file_move;
+   char target[PATH_MAX];
+
+   int length_source;
+   int length_dest;
+   long long count;
+   long long step;
+
+   /* just try a rename, maybe we are lucky... */
+   if (rename(move->progress.source, move->progress.dest) == 0)
+     {
+        /* we are really lucky */
+        eio_progress_send(thread, &move->progress, 1, 1);
+        return ;
+     }
+
+   /* list all the content that should be moved */
+   if (!_eio_dir_recursiv_ls(thread, move, move->progress.source))
+     return ;
+
+   /* init all structure needed to move the file */
+   if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, move, &file_move))
+     goto on_error;
+
+   /* sub operation is a file move */
+   file_move.op = EIO_FILE_MOVE;
+
+   /* create all directory */
+   if (!_eio_dir_mkdir(thread, move, &step, count, length_source, length_dest))
+     goto on_error;
+
+   /* move file around */
+   EINA_LIST_FREE(move->files, file)
+     {
+        /* build target file path */
+        _eio_dir_target(move, target, file, length_source, length_dest);
+
+        file_move.source = file;
+        file_move.dest = eina_stringshare_add(target);
+
+        /* first try to rename */
+        if (rename(file_move.source, file_move.dest) < 0)
+          {
+             if (errno != EXDEV)
+               {
+                  eio_file_thread_error(&move->progress.common, thread);
+                  goto on_error;
+               }
+
+             /* then try real copy */
+             if (!eio_file_copy_do(thread, &file_move))
+               {
+                  move->progress.common.error = file_move.common.error;
+                  goto on_error;
+               }
+
+             /* and unlink the original */
+             if (unlink(file) != 0)
+               {
+                  eio_file_thread_error(&move->progress.common, thread);
+                  goto on_error;
+               }
+          }
+
+        step++;
+        eio_progress_send(thread, &move->progress, step, count);
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+
+        eina_stringshare_del(file_move.dest);
+        eina_stringshare_del(file);
+     }
+   file_move.dest = NULL;
+   file = NULL;
+
+   /* recreate link */
+   if (!_eio_dir_link(thread, move, &step, count, length_source, length_dest))
+     goto on_error;
+
+   /* set directory right back */
+   if (!_eio_dir_chmod(thread, move, &step, count, length_source, length_dest, EINA_TRUE))
+     goto on_error;
+
+   if (rmdir(move->progress.source) != 0)
+     goto on_error;
+
+ on_error:
+   /* cleanup the mess */
+   if (file_move.dest) eina_stringshare_del(file_move.dest);
+   if (file) eina_stringshare_del(file);
+
+   EINA_LIST_FREE(move->files, file)
+     eina_stringshare_del(file);
+   EINA_LIST_FREE(move->dirs, dir)
+     eina_stringshare_del(dir);
+
+   if (!ecore_thread_check(thread))
+     eio_progress_send(thread, &move->progress, count, count);
+
+   return;
+}
+
+static void
+_eio_dir_rmrf_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_Dir_Copy *rmrf = data;
+   const char *file = NULL;
+   const char *dir = NULL;
+
+   long long count;
+   long long step;
+
+   /* list all the content that should be moved */
+   if (!_eio_dir_recursiv_ls(thread, rmrf, rmrf->progress.source))
+     return ;
+
+   /* init counter */
+   step = 0;
+   count = eina_list_count(rmrf->files) + eina_list_count(rmrf->dirs) + 1;
+
+   EINA_LIST_FREE(rmrf->files, file)
+     {
+        if (unlink(file) != 0)
+          {
+             eio_file_thread_error(&rmrf->progress.common, thread);
+             goto on_error;
+          }
+
+        eina_stringshare_replace(&rmrf->progress.dest, file);
+
+        step++;
+        eio_progress_send(thread, &rmrf->progress, step, count);
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+
+        eina_stringshare_del(file);
+     }
+   file = NULL;
+
+   /* reverse directory listing, so the leaf would be destroyed before
+      the root */
+   rmrf->dirs = eina_list_reverse(rmrf->dirs);
+
+   EINA_LIST_FREE(rmrf->dirs, dir)
+     {
+        if (rmdir(dir) != 0)
+          {
+             eio_file_thread_error(&rmrf->progress.common, thread);
+             goto on_error;
+          }
+
+        eina_stringshare_replace(&rmrf->progress.dest, dir);
+
+        step++;
+        eio_progress_send(thread, &rmrf->progress, step, count);
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+
+        eina_stringshare_del(dir);
+     }
+   dir = NULL;
+
+   if (rmdir(rmrf->progress.source) != 0)
+     goto on_error;
+   step++;
+
+ on_error:
+   if (dir) eina_stringshare_del(dir);
+   if (file) eina_stringshare_del(file);
+
+   EINA_LIST_FREE(rmrf->dirs, dir)
+     eina_stringshare_del(dir);
+   EINA_LIST_FREE(rmrf->files, file)
+     eina_stringshare_del(file);
+
+   if (!ecore_thread_check(thread))
+     eio_progress_send(thread, &rmrf->progress, count, count);
+
+   return;
+}
+
+static Eina_Bool
+_eio_dir_stat_find_forward(Eio_File_Dir_Ls *async,
+                           Eio_File *handler,
+                           Eina_File_Direct_Info *info)
+{
+   Eina_Bool filter = EINA_TRUE;
+   double current;
+
+   if (async->filter_cb)
+     {
+        filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, info);
+     }
+
+   if (filter)
+     {
+        Eio_File_Direct_Info *send_di;
+
+        send_di = eio_direct_info_malloc();
+        if (!send_di) return EINA_FALSE;
+
+        memcpy(&send_di->info, info, sizeof (Eina_File_Direct_Info));
+        send_di->associated = async->ls.common.worker.associated;
+        async->ls.common.worker.associated = NULL;
+
+        async->pack = eina_list_append(async->pack, send_di);
+     }
+   else if (async->ls.common.worker.associated)
+     {
+        eina_hash_free(async->ls.common.worker.associated);
+        async->ls.common.worker.associated = NULL;
+     }
+
+   current = ecore_time_get();
+   if (current - async->start > EIO_PACKED_TIME)
+     {
+        async->start = current;
+        ecore_thread_feedback(handler->thread, async->pack);
+        async->pack = NULL;
+     }
+
+   return filter;
+}
+
+static void
+_eio_dir_stat_find_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Dir_Ls *async = data;
+
+   async->ls.common.thread = thread;
+   async->pack = NULL;
+   async->start = ecore_time_get();
+
+   _eio_file_recursiv_ls(thread, &async->ls.common,
+                         (Eio_Filter_Direct_Cb) _eio_dir_stat_find_forward,
+                         eina_file_stat_ls,
+                         async, async->ls.directory);
+
+   if (async->pack) ecore_thread_feedback(thread, async->pack);
+   async->pack = NULL;
+}
+
+static void
+_eio_dir_direct_find_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Dir_Ls *async = data;
+
+   async->ls.common.thread = thread;
+   async->pack = NULL;
+   async->start = ecore_time_get();
+
+   _eio_file_recursiv_ls(thread, &async->ls.common,
+                         (Eio_Filter_Direct_Cb) _eio_dir_stat_find_forward,
+                         eina_file_direct_ls,
+                         async, async->ls.directory);
+
+   if (async->pack) ecore_thread_feedback(thread, async->pack);
+   async->pack = NULL;
+}
+
+static void
+_eio_dir_stat_find_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_File_Dir_Ls *async = data;
+   Eina_List *pack = msg_data;
+   Eio_File_Direct_Info *info;
+
+   EINA_LIST_FREE(pack, info)
+     {
+        async->ls.common.main.associated = info->associated;
+
+        async->main_cb((void*) async->ls.common.data, &async->ls.common, &info->info);
+
+        if (async->ls.common.main.associated)
+          {
+             eina_hash_free(async->ls.common.main.associated);
+             async->ls.common.main.associated = NULL;
+          }
+
+        eio_direct_info_free(info);
+     }
+}
+
+static void
+_eio_dir_stat_done(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Ls *async = data;
+
+   async->common.done_cb((void*) async->common.data, &async->common);
+
+   eio_async_free(async);
+}
+
+static void
+_eio_dir_stat_error(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Ls *async = data;
+
+   eio_file_error(&async->common);
+
+   eio_async_free(async);
+}
+
+/**
+ * @endcond
+ */
+
+/*============================================================================*
+ *                                 Global                                     *
+ *============================================================================*/
+
+
+/*============================================================================*
+ *                                   API                                      *
+ *============================================================================*/
+
+
+EAPI Eio_File *
+eio_dir_copy(const char *source,
+             const char *dest,
+             Eio_Filter_Direct_Cb filter_cb,
+             Eio_Progress_Cb progress_cb,
+             Eio_Done_Cb done_cb,
+             Eio_Error_Cb error_cb,
+             const void *data)
+{
+   Eio_Dir_Copy *copy;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   copy = malloc(sizeof(Eio_Dir_Copy));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(copy, NULL);
+
+   copy->progress.op = EIO_DIR_COPY;
+   copy->progress.progress_cb = progress_cb;
+   copy->progress.source = eina_stringshare_add(source);
+   copy->progress.dest = eina_stringshare_add(dest);
+   copy->filter_cb = filter_cb;
+   copy->files = NULL;
+   copy->dirs = NULL;
+   copy->links = NULL;
+
+   if (!eio_long_file_set(&copy->progress.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_dir_copy_heavy,
+                          _eio_dir_copy_notify,
+                          _eio_dir_copy_end,
+                          _eio_dir_copy_error))
+     return NULL;
+
+   return &copy->progress.common;
+}
+
+EAPI Eio_File *
+eio_dir_move(const char *source,
+             const char *dest,
+             Eio_Filter_Direct_Cb filter_cb,
+             Eio_Progress_Cb progress_cb,
+             Eio_Done_Cb done_cb,
+             Eio_Error_Cb error_cb,
+             const void *data)
+{
+   Eio_Dir_Copy *move;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   move = malloc(sizeof(Eio_Dir_Copy));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(move, NULL);
+
+   move->progress.op = EIO_DIR_MOVE;
+   move->progress.progress_cb = progress_cb;
+   move->progress.source = eina_stringshare_add(source);
+   move->progress.dest = eina_stringshare_add(dest);
+   move->filter_cb = filter_cb;
+   move->files = NULL;
+   move->dirs = NULL;
+   move->links = NULL;
+
+   if (!eio_long_file_set(&move->progress.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_dir_move_heavy,
+                          _eio_dir_copy_notify,
+                          _eio_dir_copy_end,
+                          _eio_dir_copy_error))
+     return NULL;
+
+   return &move->progress.common;
+}
+
+EAPI Eio_File *
+eio_dir_unlink(const char *path,
+               Eio_Filter_Direct_Cb filter_cb,
+               Eio_Progress_Cb progress_cb,
+               Eio_Done_Cb done_cb,
+               Eio_Error_Cb error_cb,
+               const void *data)
+{
+   Eio_Dir_Copy *rmrf;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   rmrf = malloc(sizeof(Eio_Dir_Copy));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(rmrf, NULL);
+
+   rmrf->progress.op = EIO_UNLINK;
+   rmrf->progress.progress_cb = progress_cb;
+   rmrf->progress.source = eina_stringshare_add(path);
+   rmrf->progress.dest = NULL;
+   rmrf->filter_cb = filter_cb;
+   rmrf->files = NULL;
+   rmrf->dirs = NULL;
+   rmrf->links = NULL;
+
+   if (!eio_long_file_set(&rmrf->progress.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_dir_rmrf_heavy,
+                          _eio_dir_copy_notify,
+                          _eio_dir_copy_end,
+                          _eio_dir_copy_error))
+     return NULL;
+
+   return &rmrf->progress.common;
+}
+
+EAPI Eio_File *
+eio_dir_stat_ls(const char *dir,
+                Eio_Filter_Direct_Cb filter_cb,
+                Eio_Main_Direct_Cb main_cb,
+                Eio_Done_Cb done_cb,
+                Eio_Error_Cb error_cb,
+                const void *data)
+{
+   Eio_File_Dir_Ls *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   async = malloc(sizeof(Eio_File_Dir_Ls));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
+
+   /* Eio_Filter_Direct_Cb must be casted to Eio_Filter_Dir_Cb here
+    * because we keep the Eio_File_Dir_Ls pointing to that variant
+    * where info can be modified, but in our case it's already doing
+    * stat() then it shouldn't be needed!
+    */
+   async->filter_cb = (Eio_Filter_Dir_Cb)filter_cb;
+   async->main_cb = main_cb;
+   async->ls.directory = eina_stringshare_add(dir);
+
+   if (!eio_long_file_set(&async->ls.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_dir_stat_find_heavy,
+                          _eio_dir_stat_find_notify,
+                          _eio_dir_stat_done,
+                          _eio_dir_stat_error))
+     return NULL;
+
+   return &async->ls.common;
+}
+
+EAPI Eio_File *
+eio_dir_direct_ls(const char *dir,
+                  Eio_Filter_Dir_Cb filter_cb,
+                  Eio_Main_Direct_Cb main_cb,
+                  Eio_Done_Cb done_cb,
+                  Eio_Error_Cb error_cb,
+                  const void *data)
+{
+   Eio_File_Dir_Ls *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   async = malloc(sizeof(Eio_File_Dir_Ls));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
+
+   async->filter_cb = filter_cb;
+   async->main_cb = main_cb;
+   async->ls.directory = eina_stringshare_add(dir);
+
+   if (!eio_long_file_set(&async->ls.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_dir_direct_find_heavy,
+                          _eio_dir_stat_find_notify,
+                          _eio_dir_stat_done,
+                          _eio_dir_stat_error))
+     return NULL;
+
+   return &async->ls.common;
+}
diff --git a/src/lib/eio/eio_eet.c b/src/lib/eio/eio_eet.c
new file mode 100644
index 0000000000..c25cc4a035
--- /dev/null
+++ b/src/lib/eio/eio_eet.c
@@ -0,0 +1,640 @@
+/* EIO - EFL data type library
+ * Copyright (C) 2010 Enlightenment Developers:
+ *           Cedric Bail <cedric.bail@free.fr>
+ *           Vincent "caro" Torri  <vtorri at univ-evry dot fr>
+ *           Stephen "okra" Houston <UnixTitan@gmail.com>
+ *
+ * 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"
+
+/*============================================================================*
+ *                                  Local                                     *
+ *============================================================================*/
+
+/**
+ * @cond LOCAL
+ */
+
+static void
+_eio_eet_open_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Open *eet = data;
+
+   eet->result = eet_open(eet->filename, eet->mode);
+   if (!eet->result) eio_file_thread_error(&eet->common, thread);
+}
+
+static void
+_eio_eet_open_free(Eio_Eet_Open *eet)
+{
+   if (eet->filename) eina_stringshare_del(eet->filename);
+   free(eet);
+}
+
+static void
+_eio_eet_open_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Open *eet = data;
+
+   eet->eet_cb((void*) eet->common.data, &eet->common, eet->result);
+   _eio_eet_open_free(eet);
+}
+
+static void
+_eio_eet_open_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Open *eet = data;
+
+   eio_file_error(&eet->common);
+   _eio_eet_open_free(eet);
+}
+
+static void
+_eio_eet_close_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Simple *eet = data;
+
+   eet->error = eet_close(eet->ef);
+   if (eet->error != EET_ERROR_NONE) eio_file_thread_error(&eet->common, thread);
+}
+
+static void
+_eio_eet_sync_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Simple *eet = data;
+
+   eet->error = eet_sync(eet->ef);
+   if (eet->error != EET_ERROR_NONE) eio_file_thread_error(&eet->common, thread);
+}
+
+static void
+_eio_eet_simple_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Simple *eet = data;
+
+   eet->common.done_cb((void*) eet->common.data, &eet->common);
+   free(eet);
+}
+
+static void
+_eio_eet_simple_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Simple *eet = data;
+
+   eet->error_cb((void*) eet->common.data, &eet->common, eet->error);
+   free(eet);
+}
+
+static void
+_eio_eet_data_write_cipher_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Write *ew = data;
+
+   ew->result = eet_data_write_cipher(ew->ef, ew->edd,
+                                      ew->name, ew->cipher_key,
+                                      ew->write_data,
+                                      ew->compress);
+   if (ew->result == 0) eio_file_thread_error(&ew->common, thread);
+}
+
+static void
+_eio_eet_write_cipher_free(Eio_Eet_Write *ew)
+{
+   eina_stringshare_del(ew->name);
+   eina_stringshare_del(ew->cipher_key);
+   free(ew);
+}
+
+static void
+_eio_eet_data_write_cipher_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Write *ew = data;
+
+   ew->done_cb((void*) ew->common.data, &ew->common, ew->result);
+   _eio_eet_write_cipher_free(ew);
+}
+
+static void
+_eio_eet_data_write_cipher_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Write *ew = data;
+
+   eio_file_error(&ew->common);
+   _eio_eet_write_cipher_free(ew);
+}
+
+static void
+_eio_eet_image_write_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Image_Write *eiw = data;
+
+   eiw->result = eet_data_image_write_cipher(eiw->ef, eiw->name, eiw->cipher_key,
+                                             eiw->write_data,
+                                             eiw->w,
+                                             eiw->h,
+                                             eiw->alpha,
+                                             eiw->compress,
+                                             eiw->quality,
+                                             eiw->lossy);
+   if (!eiw->result) eio_file_thread_error(&eiw->common, thread);
+}
+
+static void
+_eio_eet_image_write_free(Eio_Eet_Image_Write *eiw)
+{
+   eina_stringshare_del(eiw->name);
+   eina_stringshare_del(eiw->cipher_key);
+   free(eiw);
+}
+
+static void
+_eio_eet_image_write_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Image_Write *eiw = data;
+
+   eiw->done_cb((void*) eiw->common.data, &eiw->common, eiw->result);
+   _eio_eet_image_write_free(eiw);
+}
+
+static void
+_eio_eet_image_write_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Image_Write *eiw = data;
+
+   eio_file_error(&eiw->common);
+   _eio_eet_image_write_free(eiw);
+}
+
+static void
+_eio_eet_write_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Write *ew = data;
+
+   ew->result = eet_write_cipher(ew->ef,
+                                 ew->name, ew->write_data,
+                                 ew->size, ew->compress,
+                                 ew->cipher_key);
+   if (!ew->result) eio_file_thread_error(&ew->common, thread);
+}
+
+static void
+_eio_eet_write_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Write *ew = data;
+
+   ew->done_cb((void*) ew->common.data, &ew->common, ew->result);
+   _eio_eet_write_cipher_free(ew);
+}
+
+static void
+_eio_eet_write_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Write *ew = data;
+
+   eio_file_error(&ew->common);
+   _eio_eet_write_cipher_free(ew);
+}
+
+static void
+_eio_eet_data_read_cipher_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Read *er = data;
+
+   er->result = eet_data_read_cipher(er->ef, er->edd,
+                                     er->name, er->cipher_key);
+   if (!er->result) eio_file_thread_error(&er->common, thread);
+}
+
+static void
+_eio_eet_read_free(Eio_Eet_Read *er)
+{
+   eina_stringshare_del(er->name);
+   eina_stringshare_del(er->cipher_key);
+   free(er);
+}
+
+static void
+_eio_eet_data_read_cipher_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Read *er = data;
+
+   er->done_cb.eread((void*) er->common.data, &er->common, er->result);
+   _eio_eet_read_free(er);
+}
+
+static void
+_eio_eet_data_read_cipher_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Read *er = data;
+
+   eio_file_error(&er->common);
+   _eio_eet_read_free(er);
+}
+
+static void
+_eio_eet_read_direct_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Read *er = data;
+
+   er->result = (void*) eet_read_direct(er->ef, er->name, &er->size);
+   if (!er->result) eio_file_thread_error(&er->common, thread);
+}
+
+static void
+_eio_eet_read_direct_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Read *er = data;
+
+   er->done_cb.data((void*) er->common.data, &er->common,
+                    er->result, er->size);
+   _eio_eet_read_free(er);
+}
+
+static void
+_eio_eet_read_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Read *er = data;
+
+   eio_file_error(&er->common);
+   _eio_eet_read_free(er);
+}
+
+static void
+_eio_eet_read_cipher_job(void *data, Ecore_Thread *thread)
+{
+   Eio_Eet_Read *er = data;
+
+   er->result = (void*) eet_read_cipher(er->ef, er->name,
+                                        &er->size, er->cipher_key);
+   if (!er->result) eio_file_thread_error(&er->common, thread);
+}
+
+static void
+_eio_eet_read_cipher_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_Eet_Read *er = data;
+
+   er->done_cb.read((void*) er->common.data, &er->common,
+                    er->result, er->size);
+   _eio_eet_read_free(er);
+}
+
+/**
+ * @endcond
+ */
+
+/*============================================================================*
+ *                                 Global                                     *
+ *============================================================================*/
+
+
+/*============================================================================*
+ *                                   API                                      *
+ *============================================================================*/
+
+EAPI Eio_File *
+eio_eet_open(const char *filename,
+             Eet_File_Mode mode,
+             Eio_Eet_Open_Cb eet_cb,
+             Eio_Error_Cb error_cb,
+             const void *data)
+{
+   Eio_Eet_Open *eet;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(filename, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(eet_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   eet = malloc(sizeof (Eio_Eet_Open));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(eet, NULL);
+
+   eet->eet_cb = eet_cb;
+   eet->filename = eina_stringshare_add(filename);
+   eet->mode = mode;
+   eet->result = NULL;
+
+   if (!eio_file_set(&eet->common,
+                     NULL,
+                     error_cb,
+                     data,
+                     _eio_eet_open_job,
+                     _eio_eet_open_end,
+                     _eio_eet_open_cancel))
+     return NULL;
+   return &eet->common;
+}
+
+EAPI Eio_File *
+eio_eet_close(Eet_File *ef,
+              Eio_Done_Cb done_cb,
+              Eio_Eet_Error_Cb error_cb,
+              const void *data)
+{
+   Eio_Eet_Simple *eet;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   eet = malloc(sizeof (Eio_Eet_Simple));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(eet, NULL);
+
+   eet->ef = ef;
+   eet->error_cb = error_cb;
+   eet->error = EET_ERROR_NONE;
+
+   if (!eio_file_set(&eet->common,
+                     done_cb,
+                     NULL,
+                     data,
+                     _eio_eet_close_job,
+                     _eio_eet_simple_end,
+                     _eio_eet_simple_cancel))
+     return NULL;
+   return &eet->common;
+}
+
+EAPI Eio_File *
+eio_eet_flush(Eet_File *ef,
+              Eio_Done_Cb done_cb,
+              Eio_Eet_Error_Cb error_cb,
+              const void *data)
+{
+   Eio_Eet_Simple *eet;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   eet = malloc(sizeof (Eio_Eet_Simple));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(eet, NULL);
+
+   eet->ef = ef;
+   eet->error_cb = error_cb;
+   eet->error = EET_ERROR_NONE;
+
+   if (!eio_file_set(&eet->common,
+                     done_cb,
+                     NULL,
+                     data,
+                     _eio_eet_sync_job,
+                     _eio_eet_simple_end,
+                     _eio_eet_simple_cancel))
+     return NULL;
+   return &eet->common;
+}
+
+EAPI Eio_File *
+eio_eet_data_write_cipher(Eet_File *ef,
+                          Eet_Data_Descriptor *edd,
+                          const char *name,
+                          const char *cipher_key,
+                          void *write_data,
+                          int compress,
+                          Eio_Done_Int_Cb done_cb,
+                          Eio_Error_Cb error_cb,
+                          const void *user_data)
+{
+   Eio_Eet_Write *ew;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(edd, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   ew = malloc(sizeof (Eio_Eet_Write));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ew, NULL);
+
+   ew->ef = ef;
+   ew->edd = edd;
+   ew->name = eina_stringshare_add(name);
+   ew->cipher_key = eina_stringshare_add(cipher_key);
+   ew->write_data = write_data;
+   ew->compress = compress;
+   ew->done_cb = done_cb;
+   ew->result = 0;
+
+   if (!eio_file_set(&ew->common,
+                     NULL,
+                     error_cb,
+                     user_data,
+                     _eio_eet_data_write_cipher_job,
+                     _eio_eet_data_write_cipher_end,
+                     _eio_eet_data_write_cipher_cancel))
+     return NULL;
+   return &ew->common;
+}
+
+EAPI Eio_File *
+eio_eet_data_read_cipher(Eet_File *ef,
+                         Eet_Data_Descriptor *edd,
+                         const char *name,
+                         const char *cipher_key,
+                         Eio_Done_ERead_Cb done_cb,
+                         Eio_Error_Cb error_cb,
+                         const void *data)
+{
+   Eio_Eet_Read *er;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(edd, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   er = malloc(sizeof (Eio_Eet_Read));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(er, NULL);
+
+   er->ef = ef;
+   er->edd = edd;
+   er->name = eina_stringshare_add(name);
+   er->cipher_key = eina_stringshare_add(cipher_key);
+   er->done_cb.eread = done_cb;
+
+   if (!eio_file_set(&er->common,
+                     NULL,
+                     error_cb,
+                     data,
+                     _eio_eet_data_read_cipher_job,
+                     _eio_eet_data_read_cipher_end,
+                     _eio_eet_data_read_cipher_cancel))
+     return NULL;
+
+   return &er->common;
+}
+
+EAPI Eio_File *
+eio_eet_data_image_write_cipher(Eet_File *ef,
+                                const char *name,
+                                const char *cipher_key,
+                                void *write_data,
+                                unsigned int w,
+                                unsigned int h,
+                                int alpha,
+                                int compress,
+                                int quality,
+                                int lossy,
+                                Eio_Done_Int_Cb done_cb,
+                                Eio_Error_Cb error_cb,
+                                const void *user_data)
+{
+   Eio_Eet_Image_Write *eiw;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   eiw = malloc(sizeof (Eio_Eet_Image_Write));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(eiw, NULL);
+
+   eiw->ef = ef;
+   eiw->name = eina_stringshare_add(name);
+   eiw->cipher_key = eina_stringshare_add(cipher_key);
+   eiw->write_data = write_data;
+   eiw->w = w;
+   eiw->h = h;
+   eiw->alpha = alpha;
+   eiw->compress = compress;
+   eiw->quality = quality;
+   eiw->lossy = lossy;
+   eiw->done_cb = done_cb;
+   eiw->result = 0;
+
+   if (!eio_file_set(&eiw->common,
+                     NULL,
+                     error_cb,
+                     user_data,
+                     _eio_eet_image_write_job,
+                     _eio_eet_image_write_end,
+                     _eio_eet_image_write_cancel))
+     return NULL;
+   return &eiw->common;
+}
+
+EAPI Eio_File *
+eio_eet_read_direct(Eet_File *ef,
+                    const char *name,
+                    Eio_Done_Data_Cb done_cb,
+                    Eio_Error_Cb error_cb,
+                    const void *data)
+{
+   Eio_Eet_Read *er;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   er = malloc(sizeof (Eio_Eet_Read));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(er, NULL);
+
+   er->ef = ef;
+   er->name = eina_stringshare_add(name);
+   er->cipher_key = NULL;
+   er->done_cb.data = done_cb;
+   er->result = NULL;
+
+   if (!eio_file_set(&er->common,
+                     NULL,
+                     error_cb,
+                     data,
+                     _eio_eet_read_direct_job,
+                     _eio_eet_read_direct_end,
+                     _eio_eet_read_cancel))
+     return NULL;
+
+   return &er->common;
+}
+
+EAPI Eio_File *
+eio_eet_read_cipher(Eet_File *ef,
+                    const char *name,
+                    const char *cipher_key,
+                    Eio_Done_Read_Cb done_cb,
+                    Eio_Error_Cb error_cb,
+                    const void *data)
+{
+   Eio_Eet_Read *er;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   er = malloc(sizeof (Eio_Eet_Read));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(er, NULL);
+
+   er->ef = ef;
+   er->name = eina_stringshare_add(name);
+   er->cipher_key = eina_stringshare_add(cipher_key);
+   er->done_cb.read = done_cb;
+   er->result = NULL;
+
+   if (!eio_file_set(&er->common,
+                     NULL,
+                     error_cb,
+                     data,
+                     _eio_eet_read_cipher_job,
+                     _eio_eet_read_cipher_end,
+                     _eio_eet_read_cancel))
+     return NULL;
+   return &er->common;
+}
+
+EAPI Eio_File *
+eio_eet_write_cipher(Eet_File *ef,
+                     const char *name,
+                     void *write_data,
+                     int size,
+                     int compress,
+                     const char *cipher_key,
+                     Eio_Done_Int_Cb done_cb,
+                     Eio_Error_Cb error_cb,
+                     const void *user_data)
+{
+   Eio_Eet_Write *ew;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ef, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   ew = malloc(sizeof (Eio_Eet_Write));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ew, NULL);
+
+   ew->ef = ef;
+   ew->name = eina_stringshare_add(name);
+   ew->cipher_key = eina_stringshare_add(cipher_key);
+   ew->write_data = write_data;
+   ew->size = size;
+   ew->compress = compress;
+   ew->done_cb = done_cb;
+   ew->result = 0;
+
+   if (!eio_file_set(&ew->common,
+                     NULL,
+                     error_cb,
+                     user_data,
+                     _eio_eet_write_job,
+                     _eio_eet_write_end,
+                     _eio_eet_write_cancel))
+     return NULL;
+   return &ew->common;
+}
diff --git a/src/lib/eio/eio_file.c b/src/lib/eio/eio_file.c
new file mode 100644
index 0000000000..ffcd2a73ad
--- /dev/null
+++ b/src/lib/eio/eio_file.c
@@ -0,0 +1,979 @@
+/* EIO - EFL data type library
+ * Copyright (C) 2010 Enlightenment Developers:
+ *           Cedric Bail <cedric.bail@free.fr>
+ *           Vincent "caro" Torri  <vtorri at univ-evry dot fr>
+ *           Stephen "okra" Houston <UnixTitan@gmail.com>
+ *
+ * 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"
+
+#ifdef HAVE_XATTR
+# include <sys/xattr.h>
+#endif
+
+/*============================================================================*
+ *                                  Local                                     *
+ *============================================================================*/
+
+/**
+ * @cond LOCAL
+ */
+
+static void
+_eio_file_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Char_Ls *async = data;
+   Eina_Iterator *ls;
+   const char *file;
+   Eina_List *pack = NULL;
+   double start, current;
+
+   ls = eina_file_ls(async->ls.directory);
+   if (!ls)
+     {
+        eio_file_thread_error(&async->ls.common, thread);
+        return ;
+     }
+
+   eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
+
+   start = ecore_time_get();
+
+   EINA_ITERATOR_FOREACH(ls, file)
+     {
+        Eina_Bool filter = EINA_TRUE;
+
+        if (async->filter_cb)
+          {
+             filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, file);
+          }
+
+        if (filter)
+          {
+             Eio_File_Char *send_fc;
+
+             send_fc = eio_char_malloc();
+             if (!send_fc) goto on_error;
+
+             send_fc->filename = file;
+             send_fc->associated = async->ls.common.worker.associated;
+             async->ls.common.worker.associated = NULL;
+
+             pack = eina_list_append(pack, send_fc);
+          }
+        else
+          {
+          on_error:
+             eina_stringshare_del(file);
+
+             if (async->ls.common.worker.associated)
+               {
+                  eina_hash_free(async->ls.common.worker.associated);
+                  async->ls.common.worker.associated = NULL;
+               }
+          }
+
+        current = ecore_time_get();
+        if (current - start > EIO_PACKED_TIME)
+          {
+             start = current;
+             ecore_thread_feedback(thread, pack);
+             pack = NULL;
+          }
+
+        if (ecore_thread_check(thread))
+          break;
+     }
+
+   if (pack) ecore_thread_feedback(thread, pack);
+
+   eio_file_container_set(&async->ls.common, NULL);
+
+   eina_iterator_free(ls);
+}
+
+static void
+_eio_file_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_File_Char_Ls *async = data;
+   Eina_List *pack = msg_data;
+   Eio_File_Char *info;
+
+   EINA_LIST_FREE(pack, info)
+     {
+        async->ls.common.main.associated = info->associated;
+
+        async->main_cb((void*) async->ls.common.data,
+                       &async->ls.common,
+                       info->filename);
+
+        if (async->ls.common.main.associated)
+          {
+             eina_hash_free(async->ls.common.main.associated);
+             async->ls.common.main.associated = NULL;
+          }
+
+        eina_stringshare_del(info->filename);
+        eio_char_free(info);
+     }
+}
+
+static void
+_eio_file_eina_ls_heavy(Ecore_Thread *thread, Eio_File_Direct_Ls *async, Eina_Iterator *ls)
+{
+   const Eina_File_Direct_Info *info;
+   Eina_List *pack = NULL;
+   double start, current;
+
+   if (!ls)
+     {
+        eio_file_thread_error(&async->ls.common, thread);
+        return ;
+     }
+
+   eio_file_container_set(&async->ls.common, eina_iterator_container_get(ls));
+
+   start = ecore_time_get();
+
+   EINA_ITERATOR_FOREACH(ls, info)
+     {
+        Eina_Bool filter = EINA_TRUE;
+
+        if (async->filter_cb)
+          {
+             filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, info);
+          }
+
+        if (filter)
+          {
+             Eio_File_Direct_Info *send_di;
+
+             send_di = eio_direct_info_malloc();
+             if (!send_di) continue;
+
+             memcpy(&send_di->info, info, sizeof (Eina_File_Direct_Info));
+             send_di->associated = async->ls.common.worker.associated;
+             async->ls.common.worker.associated = NULL;
+
+             pack = eina_list_append(pack, send_di);
+          }
+        else if (async->ls.common.worker.associated)
+          {
+             eina_hash_free(async->ls.common.worker.associated);
+             async->ls.common.worker.associated = NULL;
+          }
+
+        current = ecore_time_get();
+        if (current - start > EIO_PACKED_TIME)
+          {
+             start = current;
+             ecore_thread_feedback(thread, pack);
+             pack = NULL;
+          }
+
+        if (ecore_thread_check(thread))
+          break;
+     }
+
+   if (pack) ecore_thread_feedback(thread, pack);
+
+   eio_file_container_set(&async->ls.common, NULL);
+
+   eina_iterator_free(ls);
+}
+
+static void
+_eio_file_direct_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Direct_Ls *async = data;
+   Eina_Iterator *ls;
+
+   ls = eina_file_direct_ls(async->ls.directory);
+
+   _eio_file_eina_ls_heavy(thread, async, ls);
+}
+
+static void
+_eio_file_stat_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Direct_Ls *async = data;
+   Eina_Iterator *ls;
+
+   ls = eina_file_stat_ls(async->ls.directory);
+
+   _eio_file_eina_ls_heavy(thread, async, ls);
+}
+
+static void
+_eio_file_direct_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_File_Direct_Ls *async = data;
+   Eina_List *pack = msg_data;
+   Eio_File_Direct_Info *info;
+
+   EINA_LIST_FREE(pack, info)
+     {
+        async->ls.common.main.associated = info->associated;
+
+        async->main_cb((void*) async->ls.common.data,
+                       &async->ls.common,
+                       &info->info);
+
+        if (async->ls.common.main.associated)
+          {
+             eina_hash_free(async->ls.common.main.associated);
+             async->ls.common.main.associated = NULL;
+          }
+
+        eio_direct_info_free(info);
+     }
+}
+
+static void
+_eio_eina_file_copy_xattr(Ecore_Thread *thread EINA_UNUSED,
+                          Eio_File_Progress *op EINA_UNUSED,
+                          Eina_File *f, int out)
+{
+   Eina_Iterator *it;
+   Eina_Xattr *attr;
+
+   it = eina_file_xattr_value_get(f);
+   EINA_ITERATOR_FOREACH(it, attr)
+     {
+#ifdef HAVE_XATTR
+        fsetxattr(out, attr->name, attr->value, attr->length, 0);
+#endif
+     }
+   eina_iterator_free(it);
+}
+
+#ifdef HAVE_XATTR
+static void
+_eio_file_copy_xattr(Ecore_Thread *thread EINA_UNUSED,
+                     Eio_File_Progress *op EINA_UNUSED,
+                     int in, int out)
+{
+   char *tmp;
+   ssize_t length;
+   ssize_t i;
+
+   length = flistxattr(in, NULL, 0);
+
+   if (length <= 0) return ;
+
+   tmp = alloca(length);
+   length = flistxattr(in, tmp, length);
+
+   for (i = 0; i < length; i += strlen(tmp) + 1)
+     {
+        ssize_t attr_length;
+        void *value;
+
+        attr_length = fgetxattr(in, tmp, NULL, 0);
+        if (!attr_length) continue ;
+
+        value = malloc(attr_length);
+        if (!value) continue ;
+        attr_length = fgetxattr(in, tmp, value, attr_length);
+
+        if (attr_length > 0)
+          fsetxattr(out, tmp, value, attr_length, 0);
+
+        free(value);
+     }
+}
+#endif
+
+static Eina_Bool
+_eio_file_write(int fd, void *mem, ssize_t length)
+{
+   ssize_t count;
+
+   if (length == 0) return EINA_TRUE;
+
+   count = write(fd, mem, length);
+   if (count != length) return EINA_FALSE;
+   return EINA_TRUE;
+}
+
+#ifndef MAP_HUGETLB
+# define MAP_HUGETLB 0
+#endif
+
+static Eina_Bool
+_eio_file_copy_mmap(Ecore_Thread *thread, Eio_File_Progress *op, Eina_File *f, int out)
+{
+   char *m = MAP_FAILED;
+   long long i;
+   long long size;
+
+   size = eina_file_size_get(f);
+
+   for (i = 0; i < size; i += EIO_PACKET_SIZE * EIO_PACKET_COUNT)
+     {
+        int j;
+        int k;
+        int c;
+
+        m = eina_file_map_new(f, EINA_FILE_SEQUENTIAL,
+                              i, EIO_PACKET_SIZE * EIO_PACKET_COUNT);
+        if (!m)
+          goto on_error;
+
+        c = size - i;
+        if (c - EIO_PACKET_SIZE * EIO_PACKET_COUNT > 0)
+          c = EIO_PACKET_SIZE * EIO_PACKET_COUNT;
+        else
+          c = size - i;
+
+        for (j = EIO_PACKET_SIZE, k = 0; j < c; k = j, j += EIO_PACKET_SIZE)
+          {
+             if (!_eio_file_write(out, m + k, EIO_PACKET_SIZE))
+               goto on_error;
+
+             eio_progress_send(thread, op, i + j, size);
+          }
+
+        if (!_eio_file_write(out, m + k, c - k))
+          goto on_error;
+
+        if (eina_file_map_faulted(f, m))
+          goto on_error;
+
+        eio_progress_send(thread, op, i + c, size);
+
+        eina_file_map_free(f, m);
+        m = NULL;
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+     }
+
+   return EINA_TRUE;
+
+ on_error:
+   if (m != NULL) eina_file_map_free(f, m);
+   return EINA_FALSE;
+}
+
+#ifdef HAVE_SPLICE
+static int
+_eio_file_copy_splice(Ecore_Thread *thread, Eio_File_Progress *op, int in, int out, long long size)
+{
+   int result = 0;
+   long long count;
+   long long i;
+   int pipefd[2];
+
+   if (pipe(pipefd) < 0)
+     return -1;
+
+   for (i = 0; i < size; i += count)
+     {
+        count = splice(in, 0, pipefd[1], NULL, EIO_PACKET_SIZE * EIO_PACKET_COUNT, SPLICE_F_MORE | SPLICE_F_MOVE);
+        if (count < 0) goto on_error;
+
+        count = splice(pipefd[0], NULL, out, 0, count, SPLICE_F_MORE | SPLICE_F_MOVE);
+        if (count < 0) goto on_error;
+
+        eio_progress_send(thread, op, i, size);
+
+        if (ecore_thread_check(thread))
+          goto on_error;
+     }
+
+   result = 1;
+
+ on_error:
+   if (result != 1 && (errno == EBADF || errno == EINVAL)) result = -1;
+   close(pipefd[0]);
+   close(pipefd[1]);
+
+   return result;
+}
+#endif
+
+static void
+_eio_file_copy_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Progress *copy = data;
+
+   eio_file_copy_do(thread, copy);
+}
+
+static void
+_eio_file_copy_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_File_Progress *copy = data;
+
+   eio_progress_cb(msg_data, copy);
+}
+
+static void
+_eio_file_copy_free(Eio_File_Progress *copy)
+{
+   eina_stringshare_del(copy->source);
+   eina_stringshare_del(copy->dest);
+   eio_file_free(&copy->common);
+}
+
+static void
+_eio_file_copy_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Progress *copy = data;
+
+   copy->common.done_cb((void*) copy->common.data, &copy->common);
+
+   _eio_file_copy_free(copy);
+}
+
+static void
+_eio_file_copy_error(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Progress *copy = data;
+
+   eio_file_error(&copy->common);
+
+   _eio_file_copy_free(copy);
+}
+
+static void
+_eio_file_move_free(Eio_File_Move *move)
+{
+   eina_stringshare_del(move->progress.source);
+   eina_stringshare_del(move->progress.dest);
+   eio_file_free(&move->progress.common);
+}
+
+static void
+_eio_file_move_copy_progress(void *data, Eio_File *handler EINA_UNUSED, const Eio_Progress *info)
+{
+   Eio_File_Move *move = data;
+
+   move->progress.progress_cb((void*) move->progress.common.data, &move->progress.common, info);
+}
+
+static void
+_eio_file_move_unlink_done(void *data, Eio_File *handler EINA_UNUSED)
+{
+   Eio_File_Move *move = data;
+
+   move->progress.common.done_cb((void*) move->progress.common.data, &move->progress.common);
+
+   _eio_file_move_free(move);
+}
+
+static void
+_eio_file_move_unlink_error(void *data, Eio_File *handler EINA_UNUSED, int error)
+{
+   Eio_File_Move *move = data;
+
+   move->copy = NULL;
+
+   move->progress.common.error = error;
+   eio_file_error(&move->progress.common);
+
+   _eio_file_move_free(move);
+}
+
+static void
+_eio_file_move_copy_done(void *data, Eio_File *handler EINA_UNUSED)
+{
+   Eio_File_Move *move = data;
+   Eio_File *rm;
+
+   rm = eio_file_unlink(move->progress.source,
+                        _eio_file_move_unlink_done,
+                        _eio_file_move_unlink_error,
+                        move);
+   if (rm) move->copy = rm;
+}
+
+static void
+_eio_file_move_copy_error(void *data, Eio_File *handler EINA_UNUSED, int error)
+{
+   Eio_File_Move *move = data;
+
+   move->progress.common.error = error;
+   eio_file_error(&move->progress.common);
+
+   _eio_file_move_free(move);
+}
+
+static void
+_eio_file_move_heavy(void *data, Ecore_Thread *thread)
+{
+   Eio_File_Move *move = data;
+
+   if (rename(move->progress.source, move->progress.dest) < 0)
+     eio_file_thread_error(&move->progress.common, thread);
+   else
+     eio_progress_send(thread, &move->progress, 1, 1);
+}
+
+static void
+_eio_file_move_notify(void *data, Ecore_Thread *thread EINA_UNUSED, void *msg_data)
+{
+   Eio_File_Move *move = data;
+
+   eio_progress_cb(msg_data, &move->progress);
+}
+
+static void
+_eio_file_move_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Move *move = data;
+
+   move->progress.common.done_cb((void*) move->progress.common.data, &move->progress.common);
+
+   _eio_file_move_free(move);
+}
+
+static void
+_eio_file_move_error(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Move *move = data;
+
+   if (move->copy)
+     {
+        eio_file_cancel(move->copy);
+        return ;
+     }
+
+   if (move->progress.common.error == EXDEV)
+     {
+        Eio_File *eio_cp;
+
+        eio_cp = eio_file_copy(move->progress.source, move->progress.dest,
+                               move->progress.progress_cb ? _eio_file_move_copy_progress : NULL,
+                               _eio_file_move_copy_done,
+                               _eio_file_move_copy_error,
+                               move);
+
+        if (eio_cp)
+          {
+             move->copy = eio_cp;
+
+             move->progress.common.thread = ((Eio_File_Progress*)move->copy)->common.thread;
+             return ;
+          }
+     }
+
+   eio_file_error(&move->progress.common);
+
+   _eio_file_move_free(move);
+}
+
+/**
+ * @endcond
+ */
+
+
+/*============================================================================*
+ *                                 Global                                     *
+ *============================================================================*/
+
+/**
+ * @cond LOCAL
+ */
+
+void
+eio_progress_cb(Eio_Progress *progress, Eio_File_Progress *op)
+{
+   op->progress_cb((void *) op->common.data, &op->common, progress);
+
+   eio_progress_free(progress);
+}
+
+Eina_Bool
+eio_file_copy_do(Ecore_Thread *thread, Eio_File_Progress *copy)
+{
+   Eina_File *f;
+#ifdef HAVE_SPLICE
+   struct stat buf;
+   int in = -1;
+#endif
+   mode_t md;
+   int result = -1;
+   int out = -1;
+
+#ifdef HAVE_SPLICE
+   in = open(copy->source, O_RDONLY);
+   if (in < 0)
+     {
+        eio_file_thread_error(&copy->common, thread);
+        return EINA_FALSE;
+     }
+
+   /*
+     As we need file size for progression information and both copy method
+     call fstat (better than stat as it avoid race condition).
+    */
+   if (fstat(in, &buf) < 0)
+     goto on_error;
+
+   md = buf.st_mode;
+#endif
+
+   /* open write */
+   out = open(copy->dest, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+   if (out < 0)
+     goto on_error;
+
+#ifdef HAVE_SPLICE
+   /* fast file copy code using Linux splice API */
+   result = _eio_file_copy_splice(thread, copy, in, out, buf.st_size);
+   if (result == 0)
+     goto on_error;
+#endif
+
+   /* classic copy method using mmap and write */
+   if (result == -1)
+     {
+#ifndef HAVE_SPLICE
+        struct stat buf;
+
+        if (stat(copy->source, &buf) < 0)
+          goto on_error;
+
+        md = buf.st_mode;
+#endif
+
+        f = eina_file_open(copy->source, 0);
+        if (!f) goto on_error;
+
+        if (!_eio_file_copy_mmap(thread, copy, f, out))
+          {
+             eina_file_close(f);
+             goto on_error;
+          }
+
+        _eio_eina_file_copy_xattr(thread, copy, f, out);
+
+        eina_file_close(f);
+     }
+   else
+     {
+#if defined HAVE_XATTR && defined HAVE_SPLICE
+       _eio_file_copy_xattr(thread, copy, in, out);
+#endif
+     }
+
+   /* change access right to match source */
+#ifdef HAVE_CHMOD
+   if (fchmod(out, md) != 0)
+     goto on_error;
+#else
+   if (chmod(copy->dest, md) != 0)
+     goto on_error;
+#endif
+
+   close(out);
+#ifdef HAVE_SPLICE
+   close(in);
+#endif
+
+   return EINA_TRUE;
+
+ on_error:
+   eio_file_thread_error(&copy->common, thread);
+
+#ifdef HAVE_SPLICE
+   if (in >= 0) close(in);
+#endif
+   if (out >= 0) close(out);
+   if (out >= 0)
+     unlink(copy->dest);
+   return EINA_FALSE;
+}
+
+void
+eio_async_free(Eio_File_Ls *async)
+{
+   eina_stringshare_del(async->directory);
+   eio_file_free(&async->common);
+}
+
+void
+eio_async_end(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Ls *async = data;
+
+   async->common.done_cb((void*) async->common.data, &async->common);
+
+   eio_async_free(async);
+}
+
+void
+eio_async_error(void *data, Ecore_Thread *thread EINA_UNUSED)
+{
+   Eio_File_Ls *async = data;
+
+   eio_file_error(&async->common);
+
+   eio_async_free(async);
+}
+
+/**
+ * @endcond
+ */
+
+
+/*============================================================================*
+ *                                   API                                      *
+ *============================================================================*/
+
+EAPI Eio_File *
+eio_file_ls(const char *dir,
+            Eio_Filter_Cb filter_cb,
+            Eio_Main_Cb main_cb,
+            Eio_Done_Cb done_cb,
+            Eio_Error_Cb error_cb,
+            const void *data)
+{
+   Eio_File_Char_Ls *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   async = malloc(sizeof (Eio_File_Char_Ls));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
+
+   async->filter_cb = filter_cb;
+   async->main_cb = main_cb;
+   async->ls.directory = eina_stringshare_add(dir);
+
+   if (!eio_long_file_set(&async->ls.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_file_heavy,
+                          _eio_file_notify,
+                          eio_async_end,
+                          eio_async_error))
+     return NULL;
+
+   return &async->ls.common;
+}
+
+EAPI Eio_File *
+eio_file_direct_ls(const char *dir,
+                   Eio_Filter_Direct_Cb filter_cb,
+                   Eio_Main_Direct_Cb main_cb,
+                   Eio_Done_Cb done_cb,
+                   Eio_Error_Cb error_cb,
+                   const void *data)
+{
+   Eio_File_Direct_Ls *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   async = malloc(sizeof(Eio_File_Direct_Ls));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
+
+   async->filter_cb = filter_cb;
+   async->main_cb = main_cb;
+   async->ls.directory = eina_stringshare_add(dir);
+
+   if (!eio_long_file_set(&async->ls.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_file_direct_heavy,
+                          _eio_file_direct_notify,
+                          eio_async_end,
+                          eio_async_error))
+     return NULL;
+
+   return &async->ls.common;
+}
+
+EAPI Eio_File *
+eio_file_stat_ls(const char *dir,
+                 Eio_Filter_Direct_Cb filter_cb,
+                 Eio_Main_Direct_Cb main_cb,
+                 Eio_Done_Cb done_cb,
+                 Eio_Error_Cb error_cb,
+                 const void *data)
+{
+   Eio_File_Direct_Ls *async;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   async = malloc(sizeof(Eio_File_Direct_Ls));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
+
+   async->filter_cb = filter_cb;
+   async->main_cb = main_cb;
+   async->ls.directory = eina_stringshare_add(dir);
+
+   if (!eio_long_file_set(&async->ls.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_file_stat_heavy,
+                          _eio_file_direct_notify,
+                          eio_async_end,
+                          eio_async_error))
+     return NULL;
+
+   return &async->ls.common;
+}
+
+EAPI Eina_Bool
+eio_file_cancel(Eio_File *ls)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_FALSE);
+   return ecore_thread_cancel(ls->thread);
+}
+
+EAPI Eina_Bool
+eio_file_check(Eio_File *ls)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_TRUE);
+   return ecore_thread_check(ls->thread);
+}
+
+EAPI void *
+eio_file_container_get(Eio_File *ls)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ls, EINA_FALSE);
+   return ls->container;
+}
+
+EAPI Eina_Bool
+eio_file_associate_add(Eio_File *ls,
+                       const char *key,
+                       const void *data, Eina_Free_Cb free_cb)
+{
+   /* FIXME: Check if we are in the right worker thred */
+   if (!ls->worker.associated)
+     ls->worker.associated = eina_hash_string_small_new(eio_associate_free);
+
+   return eina_hash_add(ls->worker.associated,
+                        key,
+                        eio_associate_malloc(data, free_cb));
+}
+
+EAPI Eina_Bool
+eio_file_associate_direct_add(Eio_File *ls,
+                              const char *key,
+                              const void *data, Eina_Free_Cb free_cb)
+{
+   /* FIXME: Check if we are in the right worker thred */
+   if (!ls->worker.associated)
+     ls->worker.associated = eina_hash_string_small_new(eio_associate_free);
+
+   return eina_hash_direct_add(ls->worker.associated,
+                               key,
+                               eio_associate_malloc(data, free_cb));
+}
+
+EAPI void *
+eio_file_associate_find(Eio_File *ls, const char *key)
+{
+   Eio_File_Associate *search;
+
+   if (!ls->main.associated)
+     return NULL;
+
+   search = eina_hash_find(ls->main.associated, key);
+   if (!search) return NULL;
+   return search->data;
+}
+
+EAPI Eio_File *
+eio_file_copy(const char *source,
+              const char *dest,
+              Eio_Progress_Cb progress_cb,
+              Eio_Done_Cb done_cb,
+              Eio_Error_Cb error_cb,
+              const void *data)
+{
+   Eio_File_Progress *copy;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   copy = malloc(sizeof(Eio_File_Progress));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(copy, NULL);
+
+   copy->op = EIO_FILE_COPY;
+   copy->progress_cb = progress_cb;
+   copy->source = eina_stringshare_add(source);
+   copy->dest = eina_stringshare_add(dest);
+
+   if (!eio_long_file_set(&copy->common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_file_copy_heavy,
+                          _eio_file_copy_notify,
+                          _eio_file_copy_end,
+                          _eio_file_copy_error))
+     return NULL;
+
+   return &copy->common;
+}
+
+EAPI Eio_File *
+eio_file_move(const char *source,
+              const char *dest,
+              Eio_Progress_Cb progress_cb,
+              Eio_Done_Cb done_cb,
+              Eio_Error_Cb error_cb,
+              const void *data)
+{
+   Eio_File_Move *move;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
+
+   move = malloc(sizeof(Eio_File_Move));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(move, NULL);
+
+   move->progress.op = EIO_FILE_MOVE;
+   move->progress.progress_cb = progress_cb;
+   move->progress.source = eina_stringshare_add(source);
+   move->progress.dest = eina_stringshare_add(dest);
+   move->copy = NULL;
+
+   if (!eio_long_file_set(&move->progress.common,
+                          done_cb,
+                          error_cb,
+                          data,
+                          _eio_file_move_heavy,
+                          _eio_file_move_notify,
+                          _eio_file_move_end,
+                          _eio_file_move_error))
+     return NULL;
+
+   return &move->progress.common;
+}
diff --git a/src/lib/eio/eio_inline_helper.x b/src/lib/eio/eio_inline_helper.x
new file mode 100644
index 0000000000..af49646b72
--- /dev/null
+++ b/src/lib/eio/eio_inline_helper.x
@@ -0,0 +1,105 @@
+/* EIO - EFL data type library
+ * Copyright (C) 2010 Enlightenment Developers:
+ *           Cedric Bail <cedric.bail@free.fr>
+ *           Vincent "caro" Torri  <vtorri at univ-evry dot fr>
+ *           Stephen "okra" Houston <unixtitan@gmail.com>
+ *
+ * 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/>.
+ */
+
+#ifndef EIO_INLINE_HELPER_H__
+# define EIO_INLINE_HELPER_H__
+
+/**
+ * @addtogroup Eio_Helper
+ *
+ * @{
+ */
+
+/**