merge: add evil files

SVN revision: 76464

103 files changed, 19456 insertions, 0 deletions

diff --git a/src/bin/evil/Makefile.am b/src/bin/evil/Makefile.am
new file mode 100644
index 0000000000..538bbdcc69
--- /dev/null
+++ b/src/bin/evil/Makefile.am
@@ -0,0 +1,53 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I$(top_srcdir) \
+-I$(top_srcdir)/bin \
+-I$(top_srcdir)/src/lib \
+@EVIL_CPPFLAGS@
+
+AM_CFLAGS = @EVIL_CFLAGS@
+
+bin_PROGRAMS = evil_suite test_evil
+
+evil_suite_SOURCES = \
+evil_suite.c \
+evil_test_dlfcn.c \
+evil_test_environment.c \
+evil_test_gettimeofday.c \
+evil_test_link.c \
+evil_test_memcpy.c \
+evil_test_mkstemp.c \
+evil_test_pipe.c \
+evil_test_print.c \
+evil_test_realpath.c \
+evil_test_util.c \
+evil_suite.h \
+evil_test_dlfcn.h \
+evil_test_environment.h \
+evil_test_gettimeofday.h \
+evil_test_link.h \
+evil_test_memcpy.h \
+evil_test_mkstemp.h \
+evil_test_pipe.h \
+evil_test_print.h \
+evil_test_realpath.h \
+evil_test_util.h
+
+if EVIL_HAVE_WINCE
+
+evil_suite_SOURCES +=  memcpy_glibc_arm.S
+
+#else
+
+#suite_SOURCES +=  memcpy_glibc_i686.S
+
+endif
+
+evil_suite_LDADD = $(top_builddir)/src/lib/libdl.la $(top_builddir)/src/lib/libevil.la -lm
+evil_suite_LDFLAGS = -Wl,--enable-auto-import
+
+test_evil_SOURCES = test_evil.c
+test_evil_LDADD = $(top_builddir)/src/lib/libevil.la
+test_evil_LDFLAGS = -Wl,--enable-auto-import
diff --git a/src/bin/evil/evil_suite.c b/src/bin/evil/evil_suite.c
new file mode 100644
index 0000000000..ba928f0682
--- /dev/null
+++ b/src/bin/evil/evil_suite.c
@@ -0,0 +1,221 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include "Evil.h"
+#include "evil_suite.h"
+#include "evil_test_dlfcn.h"
+#include "evil_test_environment.h"
+#include "evil_test_gettimeofday.h"
+#include "evil_test_link.h"
+#include "evil_test_memcpy.h"
+#include "evil_test_mkstemp.h"
+#include "evil_test_pipe.h"
+#include "evil_test_print.h"
+#include "evil_test_realpath.h"
+#include "evil_test_util.h"
+
+
+typedef int(*function)(suite *s);
+
+struct test
+{
+   const char *name;
+   function    fct;
+};
+
+struct list
+{
+  void *data;
+   int  succeed;
+  list *next;
+};
+
+struct suite
+{
+   LARGE_INTEGER freq;
+   LARGE_INTEGER start;
+   LARGE_INTEGER end;
+
+   list         *first;
+   list         *l;
+
+   int           tests_count;
+   int           tests_success;
+};
+
+
+static suite *
+suite_new(void)
+{
+   suite *s;
+
+   s = (suite *)malloc(sizeof(suite));
+   if (!s) return NULL;
+
+   if (!QueryPerformanceFrequency(&s->freq))
+     {
+        free(s);
+        return NULL;
+     }
+
+   s->first = NULL;
+   s->l = NULL;
+
+   s->tests_count = 0;
+   s->tests_success = 0;
+
+   return s;
+}
+
+static void
+suite_del(suite *s)
+{
+   list *l;
+   list *tmp;
+
+   if (!s) return;
+
+   l = s->first;
+   while (l)
+     {
+        tmp = l->next;
+        free(l->data);
+        free(l);
+        l = tmp;
+     }
+
+   free(s);
+}
+
+void
+suite_time_start(suite *s)
+{
+   QueryPerformanceCounter(&s->start);
+}
+
+void
+suite_time_stop(suite *s)
+{
+   QueryPerformanceCounter(&s->end);
+}
+
+double
+suite_time_get(suite *s)
+{
+   return (double)(s->end.QuadPart - s->start.QuadPart) / (double)s->freq.QuadPart;
+}
+
+static void
+suite_test_add(suite *s, const char *name, function fct)
+{
+   test *t;
+   list *l;
+
+   t = (test *)malloc(sizeof(test));
+   if (!t) return;
+
+   l = (list *)malloc(sizeof(list));
+   if (!l)
+     {
+        free(t);
+        return;
+     }
+
+   t->name = name;
+   t->fct = fct;
+
+   l->data = t;
+   l->succeed = 0;
+   l->next = NULL;
+
+   if (!s->first) s->first = l;
+
+   if (!s->l)
+     s->l = l;
+   else
+     {
+        s->l->next = l;
+        s->l =l;
+     }
+}
+
+static void
+suite_run(suite *s)
+{
+   list *l;
+
+   l = s->first;
+   while (l)
+     {
+        test *t;
+
+        t = (test *)l->data;
+        l->succeed = t->fct(s);
+        printf("%s test: %s\n", t->name, l->succeed ? "success" : "failure");
+        s->tests_count++;
+        if (l->succeed)
+          s->tests_success++;
+        l = l->next;
+     }
+}
+
+static void
+suite_show(suite *s)
+{
+   printf ("\n%d/%d tests passed (%d%%)\n",
+           s->tests_success,
+           s->tests_count,
+           (100 * s->tests_success) / s->tests_count);
+}
+
+int
+main(void)
+{
+   test tests[] = {
+     { "dlfcn       ",  test_dlfcn },
+     { "environment ",  test_environment },
+     { "gettimeofday",  test_gettimeofday },
+     { "link        ",  test_link },
+     { "mkstemp     ",  test_mkstemp },
+     { "pipe        ",  test_pipe },
+     { "print       ",  test_print },
+     { "realpath    ",  test_realpath },
+     { "util        ",  test_util },
+/*      { "memcpy      ",  test_memcpy }, */
+     { NULL,            NULL },
+   };
+   suite *s;
+   int    i;
+
+   if (!evil_init())
+     return EXIT_FAILURE;
+
+   s = suite_new();
+   if (!s)
+     {
+        evil_shutdown();
+        return EXIT_FAILURE;
+     }
+
+   for (i = 0; tests[i].name; ++i)
+     {
+        suite_test_add(s, tests[i].name, tests[i].fct);
+     }
+
+   suite_run(s);
+
+   suite_show(s);
+
+   suite_del(s);
+   evil_shutdown();
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/bin/evil/evil_suite.h b/src/bin/evil/evil_suite.h
new file mode 100644
index 0000000000..d3284b4fbb
--- /dev/null
+++ b/src/bin/evil/evil_suite.h
@@ -0,0 +1,14 @@
+#ifndef __EVIL_SUITE_H__
+#define __EVIL_SUITE_H__
+
+
+typedef struct test test;
+typedef struct list list;
+typedef struct suite suite;
+
+void suite_time_start(suite *s);
+void suite_time_stop(suite *s);
+double suite_time_get(suite *s);
+
+
+#endif /* __EVIL_SUITE_H__ */
diff --git a/src/bin/evil/evil_test_dlfcn.c b/src/bin/evil/evil_test_dlfcn.c
new file mode 100644
index 0000000000..fb32dd1540
--- /dev/null
+++ b/src/bin/evil/evil_test_dlfcn.c
@@ -0,0 +1,80 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+#include <dlfcn.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_dlfcn.h"
+
+
+typedef int (*_evil_init)(void);
+typedef int (*_evil_shutdwon)(void);
+
+
+static int
+test_dlfcn_test_dlopen(void)
+{
+   void *handle;
+
+   handle = dlopen("libevil-1.dll", 0);
+   if (!handle)
+     return 0;
+
+   if (dlclose(handle))
+     return 0;
+
+   return 1;
+}
+
+static int
+test_dlfcn_test_dlsym(void)
+{
+   void          *handle;
+   _evil_init     sym_init;
+   _evil_shutdwon sym_shutdown;
+
+   handle = dlopen("libevil-1.dll", 0);
+   if (!handle)
+     return 0;
+
+   sym_init = dlsym(handle, "evil_init");
+   if (!sym_init)
+     {
+        dlclose(handle);
+        return 0;
+     }
+
+   sym_shutdown = dlsym(handle, "evil_shutdown");
+   if (!sym_shutdown)
+     {
+        dlclose(handle);
+        return 0;
+     }
+
+   if (dlclose(handle))
+     return 0;
+
+   return 1;
+}
+
+static int
+test_dlfcn_tests_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res  = test_dlfcn_test_dlopen();
+   res &= test_dlfcn_test_dlsym();
+
+   return res;
+}
+
+int
+test_dlfcn(suite *s)
+{
+
+   return test_dlfcn_tests_run(s);
+}
diff --git a/src/bin/evil/evil_test_dlfcn.h b/src/bin/evil/evil_test_dlfcn.h
new file mode 100644
index 0000000000..0c9bce689e
--- /dev/null
+++ b/src/bin/evil/evil_test_dlfcn.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_DLFCN_H__
+#define __EVIL_TEST_DLFCN_H__
+
+
+int test_dlfcn(suite *s);
+
+
+#endif /* __EVIL_TEST_DLFCN_H__ */
diff --git a/src/bin/evil/evil_test_environment.c b/src/bin/evil/evil_test_environment.c
new file mode 100644
index 0000000000..3048a40124
--- /dev/null
+++ b/src/bin/evil/evil_test_environment.c
@@ -0,0 +1,178 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_environment.h"
+
+
+static int
+test_env_test_setenv_NULL(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV", NULL, 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+
+   return val ? 0 : 1;
+}
+
+static int
+test_env_test_setenv_NULL_after_set(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV", "val", 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+   if (!val)
+     return 0;
+
+   if (strcmp(val, "val"))
+     return 0;
+
+   res = setenv("EVIL_TEST_ENV", NULL, 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+
+   return val ? 0 : 1;
+}
+
+static int
+test_env_test_getenv_one(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV", "val", 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+   if (!val)
+     return 0;
+
+   if (strcmp(val, "val"))
+     return 0;
+
+   return 1;
+}
+
+static int
+test_env_test_getenv_two(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV1", "val1", 1);
+   if (res < 0)
+     return 0;
+
+   res = setenv("EVIL_TEST_ENV2", "val2", 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV1");
+   if (!val)
+     return 0;
+   if (strcmp(val, "val1"))
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV2");
+   if (!val)
+     return 0;
+
+   if (strcmp(val, "val2"))
+     return 0;
+
+   return 1;
+}
+
+static int
+test_env_test_getenv_two_swapped(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV1", "val1", 1);
+   if (res < 0)
+     return 0;
+
+   res = setenv("EVIL_TEST_ENV2", "val2", 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV2");
+   if (!val)
+     return 0;
+   if (strcmp(val, "val2"))
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV1");
+   if (!val)
+     return 0;
+
+   if (strcmp(val, "val1"))
+     return 0;
+
+   return 1;
+}
+
+static int
+test_env_test_unsetenv(void)
+{
+   char *val;
+   int   res;
+
+   res = setenv("EVIL_TEST_ENV", "val", 1);
+   if (res < 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+   if (!val)
+     return 0;
+
+   if (unsetenv("EVIL_TEST_ENV") != 0)
+     return 0;
+
+   val = getenv("EVIL_TEST_ENV");
+   if (val)
+     return 0;
+
+   return 1;
+}
+
+static int
+test_env_tests_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res  = test_env_test_setenv_NULL();
+   res &= test_env_test_setenv_NULL_after_set();
+   res &= test_env_test_getenv_one();
+   res &= test_env_test_getenv_two();
+   res &= test_env_test_getenv_two_swapped();
+   res &= test_env_test_unsetenv();
+
+   return res;
+}
+
+int
+test_environment(suite *s)
+{
+
+   return test_env_tests_run(s);
+}
diff --git a/src/bin/evil/evil_test_environment.h b/src/bin/evil/evil_test_environment.h
new file mode 100644
index 0000000000..763ee401b1
--- /dev/null
+++ b/src/bin/evil/evil_test_environment.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_ENVIRONMENT_H__
+#define __EVIL_TEST_ENVIRONMENT_H__
+
+
+int test_environment(suite *s);
+
+
+#endif /* __EVIL_TEST_ENVIRONMENT_H__ */
diff --git a/src/bin/evil/evil_test_gettimeofday.c b/src/bin/evil/evil_test_gettimeofday.c
new file mode 100644
index 0000000000..49742eb5d3
--- /dev/null
+++ b/src/bin/evil/evil_test_gettimeofday.c
@@ -0,0 +1,51 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+#include <math.h>
+#include <sys/time.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_gettimeofday.h"
+
+static int
+test_time_test_gettimeofday(void)
+{
+   struct timeval tp1;
+   struct timeval tp2;
+   double         delta;
+
+   gettimeofday (&tp1, NULL);
+
+   Sleep(1000);
+
+   gettimeofday (&tp2, NULL);
+
+   delta = (double)(tp2.tv_sec - tp1.tv_sec) + (double)(tp2.tv_usec - tp1.tv_usec) / 1000000.0;
+   if (fabs(delta - 1) > 0.005)
+     {
+        return 0;
+     }
+
+   return 1;
+}
+
+static int
+test_time_tests_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res = test_time_test_gettimeofday();
+
+   return res;
+}
+
+int
+test_gettimeofday(suite *s)
+{
+
+   return test_time_tests_run(s);
+}
diff --git a/src/bin/evil/evil_test_gettimeofday.h b/src/bin/evil/evil_test_gettimeofday.h
new file mode 100644
index 0000000000..ad3155b146
--- /dev/null
+++ b/src/bin/evil/evil_test_gettimeofday.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_GETTIMEOFDAY_H__
+#define __EVIL_TEST_GETTIMEOFDAY_H__
+
+
+int test_gettimeofday(suite *s);
+
+
+#endif /* __EVIL_TEST_GETTIMEOFDAY_H__ */
diff --git a/src/bin/evil/evil_test_link.c b/src/bin/evil/evil_test_link.c
new file mode 100644
index 0000000000..cf4cd931ae
--- /dev/null
+++ b/src/bin/evil/evil_test_link.c
@@ -0,0 +1,158 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_link.h"
+
+static int
+test_link_test_file_create(const char *name, const char *data)
+{
+   FILE       *f;
+   size_t      length;
+   size_t      res;
+
+   f = fopen(name, "wb");
+   if (!f)
+     return 0;
+
+   length = strlen(data) + 1;
+   res = fwrite(data, 1, length, f);
+   if (res < length)
+     {
+        fclose(f);
+        return 0;
+     }
+
+   fclose(f);
+
+   return 1;
+}
+
+static int
+test_link_test_symlink(void)
+{
+#ifdef _WIN32_WCE
+   const char *old_name = "\\efl\\evil_test_link.dat";
+   const char *new_name = "\\efl\\evil_test_link.lnk";
+#else
+   const char *old_name = "evil_test_link.dat";
+   const char *new_name = "evil_test_link.lnk";
+#endif
+
+   if (!test_link_test_file_create(old_name,
+                                   "evil_test_link symlink data\n"))
+     return 0;
+
+   if (symlink(old_name, new_name) < 0)
+     {
+        unlink(old_name);
+        return 0;
+     }
+
+   if (unlink(new_name) < 0)
+     {
+        unlink(old_name);
+        return 0;
+     }
+
+   if (unlink(old_name) < 0)
+     return 0;
+
+   return 1;
+}
+
+static int
+test_link_test_readlink(void)
+{
+   char        buf[1024];
+#ifdef _WIN32_WCE
+   const char *old_name = "\\efl\\evil_test_link.dat";
+   const char *new_name = "\\efl\\evil_test_link.lnk";
+#else
+   const char *old_name = "evil_test_link.dat";
+   const char *new_name = "evil_test_link.lnk";
+#endif
+   const char *data = "evil_test_link symlink data\n";
+   FILE       *f;
+   ssize_t     s1;
+   size_t      s2;
+   int         l;
+
+   if (!test_link_test_file_create(old_name, data))
+     return 0;
+
+   if (symlink(old_name, new_name) < 0)
+     return 0;
+
+   if ((s1 = readlink(new_name, buf, 1023)) < 0)
+     {
+        unlink(old_name);
+        unlink(new_name);
+        return 0;
+     }
+
+   buf[s1] = '\0';
+
+   f = fopen(buf, "rb");
+   if (!f)
+     {
+        unlink(old_name);
+        unlink(new_name);
+        return 0;
+     }
+
+   l = strlen(data);
+   s2 = fread(buf, 1, l + 1, f);
+
+   if ((int)s2 != (l + 1))
+     {
+        fclose(f);
+        unlink(old_name);
+        unlink(new_name);
+        return 0;
+     }
+
+   if (strcmp(buf, data))
+     {
+        fclose(f);
+        unlink(old_name);
+        unlink(new_name);
+        return 0;
+     }
+
+   fclose(f);
+
+   if (unlink(new_name) < 0)
+     {
+        unlink(old_name);
+        return 0;
+     }
+
+   if (unlink(old_name) < 0)
+     return 0;
+
+   return 1;
+}
+
+static int
+test_link_tests_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res  = test_link_test_symlink();
+   res &= test_link_test_readlink();
+
+   return res;
+}
+
+int
+test_link(suite *s)
+{
+
+   return test_link_tests_run(s);
+}
diff --git a/src/bin/evil/evil_test_link.h b/src/bin/evil/evil_test_link.h
new file mode 100644
index 0000000000..6f8bfa2328
--- /dev/null
+++ b/src/bin/evil/evil_test_link.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_LINK_H__
+#define __EVIL_TEST_LINK_H__
+
+
+int test_link(suite *s);
+
+
+#endif /* __EVIL_TEST_LINK_H__ */
diff --git a/src/bin/evil/evil_test_memcpy.c b/src/bin/evil/evil_test_memcpy.c
new file mode 100644
index 0000000000..0adfe373f0
--- /dev/null
+++ b/src/bin/evil/evil_test_memcpy.c
@@ -0,0 +1,145 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include "evil_suite.h"
+#include "evil_test_memcpy.h"
+
+
+typedef void *(*memcpy_decl)(void *dest, const void *src, size_t n);
+
+void *memcpy_glibc(void *dest, const void *src, size_t n);
+
+
+static unsigned char *buf1 = NULL;
+static unsigned char *buf2 = NULL;
+static size_t         page_size = 0;
+
+
+#if defined (__MINGW32CE__) || defined (_MSC_VER)
+static int
+getpagesize()
+{
+   return 1024;
+}
+#endif /* __MINGW32CE__ || _MSC_VER */
+
+
+static void
+test_memcpy_test_run(suite *s, memcpy_decl fct, char *dst, const char *src, size_t len)
+{
+   double best;
+   int    i;
+
+   best = 1000000000.0;
+
+   for (i = 0; i < 128; ++i)
+     {
+        double time;
+
+        suite_time_start(s);
+        fct(dst, src, len);
+        suite_time_stop(s);
+        time = suite_time_get(s);
+        if (time < best) best = time;
+     }
+
+   printf ("  %e", best);
+}
+
+static void
+test_memcpy_tests_run(suite *s, size_t align1, size_t align2, size_t len)
+{
+   size_t i, j;
+   char *s1, *s2;
+
+   printf ("running test..\n");
+
+/*    align1 &= 63; */
+/*    if (align1 + len >= page_size) */
+/*      return; */
+
+/*    align2 &= 63; */
+/*    if (align2 + len >= page_size) */
+/*      return; */
+
+   s1 = (char *) (buf1 + align1);
+   s2 = (char *) (buf2 + align2);
+
+   for (i = 0, j = 1; i < len; i++, j += 23)
+     s1[i] = j;
+
+   printf ("length: %6d, align %2d/%2d:", (int)len, align1, align2);
+
+   test_memcpy_test_run(s, memcpy, s2, s1, len);
+#ifdef _WIN32_WCE
+   test_memcpy_test_run(s, memcpy_glibc, s2, s1, len);
+#endif /* _WIN32_WCE */
+
+   printf ("\n");
+}
+
+int
+test_memcpy(suite *s)
+{
+   size_t i;
+
+   page_size = 2 * 1024;
+
+   buf1 = (unsigned char *)malloc(16 * getpagesize());
+   if (!buf1) return 0;
+
+   buf2 = (unsigned char *)malloc(16 * getpagesize());
+   if (!buf2)
+     {
+        free(buf1);
+        return 0;
+     }
+
+   memset (buf1, 0xa5, page_size);
+   memset (buf2, 0x5a, page_size);
+
+  for (i = 0; i < 5; ++i)
+    {
+      test_memcpy_tests_run(s, 0, 0, 1 << i);
+      test_memcpy_tests_run(s, i, 0, 1 << i);
+      test_memcpy_tests_run(s, 0, i, 1 << i);
+      test_memcpy_tests_run(s, i, i, 1 << i);
+    }
+
+  for (i = 0; i < 32; ++i)
+    {
+      test_memcpy_tests_run(s, 0, 0, i);
+      test_memcpy_tests_run(s, i, 0, i);
+      test_memcpy_tests_run(s, 0, i, i);
+      test_memcpy_tests_run(s, i, i, i);
+    }
+
+  for (i = 3; i < 32; ++i)
+    {
+      if ((i & (i - 1)) == 0)
+        continue;
+      test_memcpy_tests_run(s, 0, 0, 16 * i);
+      test_memcpy_tests_run(s, i, 0, 16 * i);
+      test_memcpy_tests_run(s, 0, i, 16 * i);
+      test_memcpy_tests_run(s, i, i, 16 * i);
+    }
+
+  test_memcpy_tests_run(s, 0, 0, getpagesize ());
+  test_memcpy_tests_run(s, 0, 0, 2 * getpagesize ());
+  test_memcpy_tests_run(s, 0, 0, 4 * getpagesize ());
+  test_memcpy_tests_run(s, 0, 0, 8 * getpagesize ());
+  test_memcpy_tests_run(s, 0, 0, 16 * getpagesize ());
+
+  free(buf2);
+  free(buf1);
+
+  return 1;
+}
diff --git a/src/bin/evil/evil_test_memcpy.h b/src/bin/evil/evil_test_memcpy.h
new file mode 100644
index 0000000000..808dd09f37
--- /dev/null
+++ b/src/bin/evil/evil_test_memcpy.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_MEMCPY__
+#define __EVIL_TEST_MEMCPY__
+
+
+int test_memcpy(suite *s);
+
+
+#endif /* __EVIL_TEST_MEMCPY__ */
diff --git a/src/bin/evil/evil_test_mkstemp.c b/src/bin/evil/evil_test_mkstemp.c
new file mode 100644
index 0000000000..dc8c4e64f5
--- /dev/null
+++ b/src/bin/evil/evil_test_mkstemp.c
@@ -0,0 +1,53 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_mkstemp.h"
+
+
+static int
+test_mkstemp_test(void)
+{
+   char  _template[PATH_MAX];
+#ifdef _WIN32_WCE
+   char  cwd[PATH_MAX];
+#endif
+   int   fd;
+
+#ifdef _WIN32_WCE
+   if (!getcwd(cwd, PATH_MAX))
+     return 0;
+   _snprintf(_template, PATH_MAX, "%s\\%s", cwd, "file_XXXXXX");
+#else
+   _snprintf(_template, PATH_MAX, "%s", "file_XXXXXX");
+#endif
+
+   fd = mkstemp(_template);
+
+   if (fd < 0)
+     return 0;
+
+   return 1;
+}
+
+static int
+test_mkstemp_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res = test_mkstemp_test();
+
+   return res;
+}
+
+int
+test_mkstemp(suite *s)
+{
+
+   return test_mkstemp_run(s);
+}
diff --git a/src/bin/evil/evil_test_mkstemp.h b/src/bin/evil/evil_test_mkstemp.h
new file mode 100644
index 0000000000..f5bb0c4270
--- /dev/null
+++ b/src/bin/evil/evil_test_mkstemp.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_MKSTEMP_H__
+#define __EVIL_TEST_MKSTEMP_H__
+
+
+int test_mkstemp(suite *s);
+
+
+#endif /* __EVIL_TEST_MKSTEMP_H__ */
diff --git a/src/bin/evil/evil_test_pipe.c b/src/bin/evil/evil_test_pipe.c
new file mode 100644
index 0000000000..2fc530d545
--- /dev/null
+++ b/src/bin/evil/evil_test_pipe.c
@@ -0,0 +1,126 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+# define WIN32_LEAN_AND_MEAN
+# include <winsock2.h>
+# undef WIN32_LEAN_AND_MEAN
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_pipe.h"
+
+
+#define FDREAD  0
+#define FDWRITE 1
+
+typedef struct
+{
+  int val;
+  int fd_write;
+} data;
+
+
+static DWORD WINAPI
+thread (void *param)
+{
+   data *d;
+   void *buf[1];
+
+   Sleep (2 * 1000);
+   d = (data *)param;
+   buf[0] = d;
+   send(d->fd_write, (char *)buf, sizeof(buf), 0);
+
+   return 0;
+}
+
+static int
+test_pipe_test(void)
+{
+   int            sockets[2];
+   struct timeval t;
+   fd_set         rfds;
+   int            ret;
+   data          *d;
+   DWORD          thread_id;
+   HANDLE         h;
+
+   FD_ZERO(&rfds);
+
+   t.tv_sec = 5;
+   t.tv_usec = 0;
+
+   if (pipe(sockets) < 0)
+     return 0;
+
+   FD_SET(sockets[FDREAD], &rfds);
+   fcntl(sockets[FDREAD], F_SETFL, O_NONBLOCK);
+
+   d = (data *)malloc(sizeof (data));
+   if (!d)
+     return 0;
+
+   d->val = 14;
+   d->fd_write = sockets[FDWRITE];
+
+   h = CreateThread(NULL, 0, thread, d, 0, &thread_id);
+   if (!h)
+
+   ret = select(sockets[FDREAD] + 1, &rfds, NULL, NULL, &t);
+
+   if (ret < 0)
+     goto free_d;
+   else if (ret == 0)
+     goto close_h;
+   else /* ret > 0 */
+     {
+        void *buf[1];
+        data *d2 = NULL;
+        int   len;
+
+        while ((len = recv(sockets[FDREAD], (char *)buf, sizeof(buf), 0)) > 0)
+          {
+             if (len == sizeof(buf))
+               {
+                  d2 = (data *)buf[0];
+                  break;
+               }
+          }
+        if (d2 && (d2->val == d->val))
+          ret = 1;
+        else
+          ret = 0;
+     }
+
+   CloseHandle(h);
+   free(d);
+
+   return ret;
+
+ close_h:
+   CloseHandle(h);
+ free_d:
+   free(d);
+   return 0;
+}
+
+static int
+test_pipe_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res = test_pipe_test();
+
+   return res;
+}
+
+int
+test_pipe(suite *s)
+{
+   return test_pipe_run(s);
+}
diff --git a/src/bin/evil/evil_test_pipe.h b/src/bin/evil/evil_test_pipe.h
new file mode 100644
index 0000000000..ff8041f716
--- /dev/null
+++ b/src/bin/evil/evil_test_pipe.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_PIPE_H__
+#define __EVIL_TEST_PIPE_H__
+
+
+int test_pipe(suite *s);
+
+
+#endif /* __EVIL_TEST_PIPE_H__ */
diff --git a/src/bin/evil/evil_test_print.c b/src/bin/evil/evil_test_print.c
new file mode 100644
index 0000000000..b930a538f4
--- /dev/null
+++ b/src/bin/evil/evil_test_print.c
@@ -0,0 +1,46 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_print.h"
+
+static int
+test_print_test(void)
+{
+  char buf[16];
+  int i1 = 1;
+  size_t i2 = 123456;
+  int res;
+
+  res = printf("%02hhd\n", i1);
+  if (res != 3)
+    return 0;
+
+  res = snprintf(buf, sizeof(buf), "%zu", i2);
+  if (res != 6)
+    return 0;
+
+  return 1;
+}
+
+static int
+test_print_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res = test_print_test();
+
+   return res;
+}
+
+int
+test_print(suite *s)
+{
+   return test_print_run(s);
+}
diff --git a/src/bin/evil/evil_test_print.h b/src/bin/evil/evil_test_print.h
new file mode 100644
index 0000000000..2bbf43904f
--- /dev/null
+++ b/src/bin/evil/evil_test_print.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_PRINT_H__
+#define __EVIL_TEST_PRINT_H__
+
+
+int test_print(suite *s);
+
+
+#endif /* __EVIL_TEST_PRINT_H__ */
diff --git a/src/bin/evil/evil_test_realpath.c b/src/bin/evil/evil_test_realpath.c
new file mode 100644
index 0000000000..f9a48cb977
--- /dev/null
+++ b/src/bin/evil/evil_test_realpath.c
@@ -0,0 +1,44 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_realpath.h"
+
+
+static int
+test_realpath_test(void)
+{
+   char  buf[PATH_MAX];
+   char *filename;
+   char *result;
+
+   filename = "evil_suite.exe";
+
+   if (!(result = realpath(filename, buf)))
+     return 0;
+
+   printf ("res : %s\n", buf);
+
+   return 1;
+}
+
+static int
+test_realpath_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res = test_realpath_test();
+
+   return res;
+}
+
+int
+test_realpath(suite *s)
+{
+   return test_realpath_run(s);
+}
diff --git a/src/bin/evil/evil_test_realpath.h b/src/bin/evil/evil_test_realpath.h
new file mode 100644
index 0000000000..0205aad149
--- /dev/null
+++ b/src/bin/evil/evil_test_realpath.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_REALPATH_H__
+#define __EVIL_TEST_REALPATH_H__
+
+
+int test_realpath(suite *s);
+
+
+#endif /* __EVIL_TEST_REALPATH_H__ */
diff --git a/src/bin/evil/evil_test_util.c b/src/bin/evil/evil_test_util.c
new file mode 100644
index 0000000000..6226ceb040
--- /dev/null
+++ b/src/bin/evil/evil_test_util.c
@@ -0,0 +1,110 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include <Evil.h>
+
+#include "evil_suite.h"
+#include "evil_test_util.h"
+
+
+static int test_path_absolute_test_1(void)
+{
+   char *path;
+   int   result;
+
+   path = NULL;
+   result = evil_path_is_absolute(path);
+   if (result != 0)
+     return 0;
+
+   return 1;
+}
+
+static int test_path_absolute_test_2(void)
+{
+   char *path;
+   int   result;
+
+   path = "1";
+   result = evil_path_is_absolute(path);
+   if (result != 0)
+     return 0;
+
+   return 1;
+}
+
+static int test_path_absolute_test_3(void)
+{
+   char *path;
+   int   result;
+
+   path = "1:\\";
+   result = evil_path_is_absolute(path);
+   if (result != 0)
+     return 0;
+
+   return 1;
+}
+
+static int test_path_absolute_test_4(void)
+{
+   char *path;
+   int   result;
+
+   path = "1/\\";
+   result = evil_path_is_absolute(path);
+   if (result != 0)
+     return 0;
+
+   return 1;
+}
+
+static int test_path_absolute_test_5(void)
+{
+   char *path;
+   int   result;
+
+   path = "F:/foo";
+   result = evil_path_is_absolute(path);
+   if (result == 0)
+     return 0;
+
+   return 1;
+}
+
+static int test_path_absolute_test_6(void)
+{
+   char *path;
+   int   result;
+
+   path = "C:\\foo";
+   result = evil_path_is_absolute(path);
+   if (result == 0)
+     return 0;
+
+   return 1;
+}
+
+static int
+test_path_absolute_run(suite *s __UNUSED__)
+{
+   int res;
+
+   res  = test_path_absolute_test_1();
+   res &= test_path_absolute_test_2();
+   res &= test_path_absolute_test_3();
+   res &= test_path_absolute_test_4();
+   res &= test_path_absolute_test_5();
+   res &= test_path_absolute_test_6();
+
+   return res;
+}
+
+int
+test_util(suite *s)
+{
+   return test_path_absolute_run(s);
+}
diff --git a/src/bin/evil/evil_test_util.h b/src/bin/evil/evil_test_util.h
new file mode 100644
index 0000000000..bee5c7a164
--- /dev/null
+++ b/src/bin/evil/evil_test_util.h
@@ -0,0 +1,8 @@
+#ifndef __EVIL_TEST_UTIL_H__
+#define __EVIL_TEST_UTIL_H__
+
+
+int test_util(suite *s);
+
+
+#endif /* __EVIL_TEST_UTIL_H__ */
diff --git a/src/bin/evil/memcpy_glibc_arm.S b/src/bin/evil/memcpy_glibc_arm.S
new file mode 100644
index 0000000000..7c42898647
--- /dev/null
+++ b/src/bin/evil/memcpy_glibc_arm.S
@@ -0,0 +1,231 @@
+/* Copyright (C) 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   Contributed by MontaVista Software, Inc. (written by Nicolas Pitre)
+
+   The GNU C 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.
+
+   The GNU C 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 the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* Copyright (C) 2008 Vincent Torri
+   modification of the name and of the entry / end declaration
+  */
+
+/*
+ * Data preload for architectures that support it (ARM V5TE and above)
+ */
+#if (!defined (__ARM_ARCH_2__) && !defined (__ARM_ARCH_3__) \
+     && !defined (__ARM_ARCH_3M__) && !defined (__ARM_ARCH_4__) \
+     && !defined (__ARM_ARCH_4T__) && !defined (__ARM_ARCH_5__) \
+     && !defined (__ARM_ARCH_5T__))
+#define PLD(code...)    code
+#else
+#define PLD(code...)
+#endif
+
+/*
+ * This can be used to enable code to cacheline align the source pointer.
+ * Experiments on tested architectures (StrongARM and XScale) didn't show
+ * this a worthwhile thing to do.  That might be different in the future.
+ */
+//#define CALGN(code...)        code
+#define CALGN(code...)
+
+/*
+ * Endian independent macros for shifting bytes within registers.
+ */
+#ifndef __ARMEB__
+#define pull            lsr
+#define push            lsl
+#else
+#define pull            lsl
+#define push            lsr
+#endif
+
+        .text
+
+/* Prototype: void *memcpy_glibc(void *dest, const void *src, size_t n); */
+
+        .align
+        .global memcpy_glibc
+        .func   memcpy_glibc
+memcpy_glibc:
+
+                stmfd   sp!, {r0, r4, lr}
+
+                subs    r2, r2, #4
+                blt     8f
+                ands    ip, r0, #3
+        PLD(    pld     [r1, #0]                )
+                bne     9f
+                ands    ip, r1, #3
+                bne     10f
+
+1:              subs    r2, r2, #(28)
+                stmfd   sp!, {r5 - r8}
+                blt     5f
+
+        CALGN(  ands    ip, r1, #31             )
+        CALGN(  rsb     r3, ip, #32             )
+        CALGN(  sbcnes  r4, r3, r2              )  @ C is always set here
+        CALGN(  bcs     2f                      )
+        CALGN(  adr     r4, 6f                  )
+        CALGN(  subs    r2, r2, r3              )  @ C gets set
+        CALGN(  add     pc, r4, ip              )
+
+        PLD(    pld     [r1, #0]                )
+2:      PLD(    subs    r2, r2, #96             )
+        PLD(    pld     [r1, #28]               )
+        PLD(    blt     4f                      )
+        PLD(    pld     [r1, #60]               )
+        PLD(    pld     [r1, #92]               )
+
+3:      PLD(    pld     [r1, #124]              )
+4:              ldmia   r1!, {r3, r4, r5, r6, r7, r8, ip, lr}
+                subs    r2, r2, #32
+                stmia   r0!, {r3, r4, r5, r6, r7, r8, ip, lr}
+                bge     3b
+        PLD(    cmn     r2, #96                 )
+        PLD(    bge     4b                      )
+
+5:              ands    ip, r2, #28
+                rsb     ip, ip, #32
+                addne   pc, pc, ip              @ C is always clear here
+                b       7f
+6:              nop
+                ldr     r3, [r1], #4
+                ldr     r4, [r1], #4
+                ldr     r5, [r1], #4
+                ldr     r6, [r1], #4
+                ldr     r7, [r1], #4
+                ldr     r8, [r1], #4
+                ldr     lr, [r1], #4
+
+                add     pc, pc, ip
+                nop
+                nop
+                str     r3, [r0], #4
+                str     r4, [r0], #4
+                str     r5, [r0], #4
+                str     r6, [r0], #4
+                str     r7, [r0], #4
+                str     r8, [r0], #4
+                str     lr, [r0], #4
+
+        CALGN(  bcs     2b                      )
+
+7:              ldmfd   sp!, {r5 - r8}
+
+8:              movs    r2, r2, lsl #31
+                ldrneb  r3, [r1], #1
+                ldrcsb  r4, [r1], #1
+                ldrcsb  ip, [r1]
+                strneb  r3, [r0], #1
+                strcsb  r4, [r0], #1
+                strcsb  ip, [r0]
+
+                ldmfd   sp!, {r0, r4, pc}
+
+9:              rsb     ip, ip, #4
+                cmp     ip, #2
+                ldrgtb  r3, [r1], #1
+                ldrgeb  r4, [r1], #1
+                ldrb    lr, [r1], #1
+                strgtb  r3, [r0], #1
+                strgeb  r4, [r0], #1
+                subs    r2, r2, ip
+                strb    lr, [r0], #1
+                blt     8b
+                ands    ip, r1, #3
+                beq     1b
+
+10:             bic     r1, r1, #3
+                cmp     ip, #2
+                ldr     lr, [r1], #4
+                beq     17f
+                bgt     18f
+
+
+                .macro  forward_copy_shift pull push
+
+                subs    r2, r2, #28
+                blt     14f
+
+        CALGN(  ands    ip, r1, #31             )
+        CALGN(  rsb     ip, ip, #32             )
+        CALGN(  sbcnes  r4, ip, r2              )  @ C is always set here
+        CALGN(  subcc   r2, r2, ip              )
+        CALGN(  bcc     15f                     )
+
+11:             stmfd   sp!, {r5 - r9}
+
+        PLD(    pld     [r1, #0]                )
+        PLD(    subs    r2, r2, #96             )
+        PLD(    pld     [r1, #28]               )
+        PLD(    blt     13f                     )
+        PLD(    pld     [r1, #60]               )
+        PLD(    pld     [r1, #92]               )
+
+12:     PLD(    pld     [r1, #124]              )
+13:             ldmia   r1!, {r4, r5, r6, r7}
+                mov     r3, lr, pull #\pull
+                subs    r2, r2, #32
+                ldmia   r1!, {r8, r9, ip, lr}
+                orr     r3, r3, r4, push #\push
+                mov     r4, r4, pull #\pull
+                orr     r4, r4, r5, push #\push
+                mov     r5, r5, pull #\pull
+                orr     r5, r5, r6, push #\push
+                mov     r6, r6, pull #\pull
+                orr     r6, r6, r7, push #\push
+                mov     r7, r7, pull #\pull
+                orr     r7, r7, r8, push #\push
+                mov     r8, r8, pull #\pull
+                orr     r8, r8, r9, push #\push
+                mov     r9, r9, pull #\pull
+                orr     r9, r9, ip, push #\push
+                mov     ip, ip, pull #\pull
+                orr     ip, ip, lr, push #\push
+                stmia   r0!, {r3, r4, r5, r6, r7, r8, r9, ip}
+                bge     12b
+        PLD(    cmn     r2, #96                 )
+        PLD(    bge     13b                     )
+
+                ldmfd   sp!, {r5 - r9}
+
+14:             ands    ip, r2, #28
+                beq     16f
+
+15:             mov     r3, lr, pull #\pull
+                ldr     lr, [r1], #4
+                subs    ip, ip, #4
+                orr     r3, r3, lr, push #\push
+                str     r3, [r0], #4
+                bgt     15b
+        CALGN(  cmp     r2, #0                  )
+        CALGN(  bge     11b                     )
+
+16:             sub     r1, r1, #(\push / 8)
+                b       8b
+
+                .endm
+
+
+                forward_copy_shift      pull=8  push=24
+
+17:             forward_copy_shift      pull=16 push=16
+
+18:             forward_copy_shift      pull=24 push=8
+
+.endfunc
diff --git a/src/bin/evil/memcpy_glibc_i686.S b/src/bin/evil/memcpy_glibc_i686.S
new file mode 100755
index 0000000000..72da118cf0
--- /dev/null
+++ b/src/bin/evil/memcpy_glibc_i686.S
@@ -0,0 +1,81 @@
+/* Copy memory block and return pointer to beginning of destination block
+   For Intel 80x86, x>=6.
+   This file is part of the GNU C Library.
+   Copyright (C) 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1999.
+
+   The GNU C 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.
+
+   The GNU C 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 the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#   define CHECK_BOUNDS_BOTH_WIDE(VAL_REG, BP_MEM, LENGTH)      \
+        CHECK_BOUNDS_LOW(VAL_REG, BP_MEM);                      \
+        addl LENGTH, VAL_REG;                                   \
+        cmpl 8+BP_MEM, VAL_REG;                                 \
+        jbe 0f; /* continue if value <= high */                 \
+        BOUNDS_VIOLATED;                                        \
+    0:  subl LENGTH, VAL_REG /* restore value */
+
+#   define RETURN_BOUNDED_POINTER(BP_MEM)       \
+        movl RTN(%esp), %edx;                   \
+        movl %eax, 0(%edx);                     \
+        movl 4+BP_MEM, %eax;                    \
+        movl %eax, 4(%edx);                     \
+        movl 8+BP_MEM, %eax;                    \
+        movl %eax, 8(%edx)
+
+#define PTR_SIZE 12
+#define RTN_SIZE 4
+#define LINKAGE 8
+
+#define PARMS   LINKAGE         /* no space for saved regs */
+#define RTN     PARMS
+#define DEST    RTN+RTN_SIZE
+#define SRC     DEST+PTR_SIZE
+#define LEN     SRC+PTR_SIZE
+
+        .text
+
+        .align
+        .global memcpy_glibc
+        .func   memcpy_glibc
+memcpy_glibc:
+
+        pushl %ebp
+        movl %esp, %ebp
+
+        movl    LEN(%esp), %ecx
+        movl    %edi, %eax
+        movl    DEST(%esp), %edi
+        movl    %esi, %edx
+        movl    SRC(%esp), %esi
+
+        cld
+        shrl    $1, %ecx
+        jnc     1f
+        movsb
+1:      shrl    $1, %ecx
+        jnc     2f
+        movsw
+2:      rep
+        movsl
+        movl    %eax, %edi
+        movl    %edx, %esi
+        movl    DEST(%esp), %eax
+        RETURN_BOUNDED_POINTER (DEST(%esp))
+
+        movl %ebp, %esp
+        popl %ebp
+
+.endfunc
diff --git a/src/bin/evil/test_evil.c b/src/bin/evil/test_evil.c
new file mode 100644
index 0000000000..5b91172cb3
--- /dev/null
+++ b/src/bin/evil/test_evil.c
@@ -0,0 +1,27 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#include <windows.h>
+
+
+
+int
+main()
+{
+   struct timeval tv;
+   double         t1 = 0.0;
+   double         t2 = 0.0;
+
+   if (gettimeofday(&tv, NULL) == 0)
+     t1 = tv.tv_sec + tv.tv_usec / 1000000.0;
+
+   Sleep(3000);
+
+   if (gettimeofday(&tv, NULL) == 0)
+     t2 = tv.tv_sec + tv.tv_usec / 1000000.0;
+
+   printf ("3 seconds ? %f\n", t2 - t1);
+
+   return EXIT_SUCCESS;
+}
diff --git a/src/lib/evil/Evil.h b/src/lib/evil/Evil.h
new file mode 100644
index 0000000000..e807dffb61
--- /dev/null
+++ b/src/lib/evil/Evil.h
@@ -0,0 +1,186 @@
+#ifndef __EVIL_H__
+#define __EVIL_H__
+
+/**
+ * @mainpage Evil
+ * @image html  e_big.png
+ * @author Vincent Torri
+ * @version 1.7.0
+ * @date 2008-2012
+ *
+ * @section intro_sec Introduction
+ *
+ * The Evil library is an evil library that ports some evil Unix
+ * functions to the Windows (XP or above, or Mobile) platform. The
+ * evilness is so huge that the most of the functions are not POSIX or
+ * BSD compliant.
+ *
+ * These functions are intended to be used in the Enlightenment
+ * Foundation Libraries only and can be compiled only on Windows,
+ * using MSYS/MinGW on Windows, and cross-compilation on Unix. This
+ * library is minimal in the sense that only the functions needed to
+ * compile the EFL are available. The purpose of this library is NOT
+ * to have a full POSIX emulation et it is NOT a replacement of
+ * cygwin. To compare the size of the DLL themselves, Evil is around
+ * 33 KB and cygwin DLL is around 800 KB.
+ *
+ * @section acknowledgments_sec Acknowledgments
+ *
+ * This library has receive some from people interested in the EFL or
+ * not. Among them, evil thanks to Lars Munch, Raoul Hecky, Nicolas
+ * Aguirre, Tor Lillqvist, Lance Fetters, Vincent Richomme, Paul
+ * Vixie, Daniel Stenberg, who helped the author of the library in
+ * different fields (code and tests).
+ *
+ * @section license_sec license
+ *
+ * The Evil library is distributes under a modified BSD license. See
+ * the files COPYING and COPYING-PLAIN in the top level directory for
+ * the full license text.
+ *
+ * @section reference_sec Reference API
+ *
+ * Use the horizontal menu above to navigate into the reference API
+ */
+
+/**
+ * @file Evil.h
+ * @brief The file that provides miscellaneous functions ported from Unix.
+ * @defgroup Evil Miscellaneous functions ported from Unix.
+ *
+ * This header provides miscellaneous functions that exist on Unix
+ * but not on Windows platform. They try to follow the conformance of
+ * the Unix versions.
+ */
+
+/**
+ * @cond LOCAL
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <math.h>
+#include <direct.h>
+
+
+#ifdef _MSC_VER
+
+# include <io.h>
+
+# define F_OK 0  /* Check for file existence */
+# define X_OK 1  /* MS access() doesn't check for execute permission. */
+# define W_OK 2  /* Check for write permission */
+# define R_OK 4  /* Check for read permission */
+
+typedef DWORD          pid_t;
+typedef unsigned short mode_t;
+
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef signed int int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+typedef SSIZE_T ssize_t;
+
+# define strdup(s) _strdup(s)
+# define unlink(filename) _unlink(filename)
+# define fileno(f) _fileno(f)
+# define fdopen(fd,m) _fdopen((fd),(m))
+# define access(p,m) _access((p),(m))
+# define hypot(x,y) _hypot((x),(y))
+# define tzset _tzset
+
+#endif /* _MSC_VER */
+
+#ifdef _WIN32_WCE
+# ifndef offsetof
+#  define offsetof(type, ident) ((size_t)&(((type*)0)->ident))
+# endif
+#endif
+
+typedef unsigned long  uid_t;
+typedef unsigned long  gid_t;
+
+
+#include "evil_macro.h"
+#include "evil_fcntl.h"
+#include "evil_inet.h"
+#include "evil_langinfo.h"
+#include "evil_libgen.h"
+#include "evil_main.h"
+#include "evil_print.h"
+#include "evil_stdlib.h"
+#include "evil_stdio.h"
+#include "evil_string.h"
+#include "evil_time.h"
+#include "evil_unistd.h"
+#include "evil_util.h"
+#include "evil_macro_pop.h"
+
+
+#if (defined(_WIN32) && !defined(_UWIN) && !defined(__CYGWIN__))
+# if defined(_MSC_VER) || defined(__MINGW32__)
+
+# ifdef S_ISDIR
+#  undef S_ISDIR
+# endif
+# ifdef S_ISREG
+#  undef S_ISREG
+# endif
+# define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
+# define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+
+# define S_ISLNK(m) 0
+
+# define S_IRUSR _S_IRUSR
+# define S_IWUSR _S_IWUSR
+# define S_IXUSR _S_IXUSR
+# define S_IRGRP S_IRUSR
+# define S_IROTH S_IRUSR
+# define S_IWGRP S_IWUSR
+# define S_IWOTH S_IWUSR
+# define S_IXGRP S_IXUSR
+# define S_IXOTH S_IXUSR
+
+# define _S_IRWXU (_S_IREAD | _S_IWRITE | _S_IEXEC)
+# define _S_IXUSR _S_IEXEC
+# define _S_IWUSR _S_IWRITE
+# define _S_IRUSR _S_IREAD
+
+#  define mkdir(p,m) _mkdir(p)
+  /*
+#  define close(fd) _close(fd)
+#  define read(fd,buffer,count) _read((fd),(buffer),(count))
+#  define write(fd,buffer,count) _write((fd),(buffer),(count))
+#  define unlink(filename) _unlink((filename))
+#  define lstat(f,s) _stat((f),(s))
+  */
+
+# endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**
+ * @endcond
+ */
+
+#endif /* __EVIL_H__ */
diff --git a/src/lib/evil/Makefile.am b/src/lib/evil/Makefile.am
new file mode 100644
index 0000000000..62d0d56bf3
--- /dev/null
+++ b/src/lib/evil/Makefile.am
@@ -0,0 +1,132 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+lib_LTLIBRARIES = libevil.la libdl.la
+
+install_evilheadersdir = $(includedir)/evil-@VMAJ@
+dist_install_evilheaders_DATA = \
+Evil.h \
+evil_fcntl.h \
+evil_inet.h \
+evil_langinfo.h \
+evil_libgen.h \
+evil_macro.h \
+evil_macro_pop.h \
+evil_main.h \
+evil_print.h \
+evil_stdlib.h \
+evil_stdio.h \
+evil_string.h \
+evil_time.h \
+evil_unistd.h \
+evil_util.h
+
+stdheadersdir = $(includedir)/evil-@VMAJ@
+nobase_dist_stdheaders_DATA = pwd.h sys/mman.h fnmatch.h dirent.h dlfcn.h
+
+if EVIL_HAVE_WINCE
+
+nobase_dist_stdheaders_DATA += mingw32ce/errno.h
+
+endif
+
+# gdtoa
+libevil_la_SOURCES = \
+gdtoa/arithchk.c \
+gdtoa/dmisc.c \
+gdtoa/dtoa.c \
+gdtoa/gd_arith.h \
+gdtoa/g_dfmt.c \
+gdtoa/gd_qnan.h \
+gdtoa/gdtoa.c \
+gdtoa/gdtoa_fltrnds.h \
+gdtoa/gdtoa.h \
+gdtoa/gdtoaimp.h \
+gdtoa/gethex.c \
+gdtoa/g_ffmt.c \
+gdtoa/g__fmt.c \
+gdtoa/gmisc.c \
+gdtoa/g_xfmt.c \
+gdtoa/hd_init.c \
+gdtoa/hexnan.c \
+gdtoa/misc.c \
+gdtoa/qnan.c \
+gdtoa/smisc.c \
+gdtoa/strtodg.c \
+gdtoa/strtof.c \
+gdtoa/strtopx.c \
+gdtoa/sum.c \
+gdtoa/ulp.c
+
+#evil
+libevil_la_SOURCES += \
+evil_dirent.c \
+evil_fcntl.c \
+evil_fnmatch.c \
+evil_fnmatch_list_of_states.c \
+evil_inet.c \
+evil_langinfo.c \
+evil_libgen.c \
+evil_main.c \
+evil_mman.c \
+evil_pformata.c \
+evil_pformatw.c \
+evil_printa.c \
+evil_printw.c \
+evil_pwd.c \
+evil_stdlib.c \
+evil_stdio.c \
+evil_string.c \
+evil_time.c \
+evil_unistd.c \
+evil_util.c \
+evil_uuid.c \
+evil_pformat.h \
+evil_private.h \
+evil_fnmatch_private.h
+
+if EVIL_HAVE_WINCE
+
+libevil_la_SOURCES += evil_errno.c evil_link_ce.c
+
+else
+
+libevil_la_SOURCES += evil_link_xp.cpp
+
+endif
+
+libevil_la_CPPFLAGS = @EVIL_CPPFLAGS@
+libevil_la_CFLAGS = @EVIL_CFLAGS@
+libevil_la_CXXFLAGS = @EVIL_CXXFLAGS@
+libevil_la_LIBADD = @EVIL_LIBS@
+libevil_la_LDFLAGS = -no-undefined -Wl,--enable-auto-import -version-info @version_info@
+
+if EVIL_HAVE_WINCE
+
+libevil_la_LINK = $(LINK) $(libevil_la_LDFLAGS)
+
+else
+
+libevil_la_LINK = $(CXXLINK) $(libevil_la_LDFLAGS)
+
+endif
+
+libdl_la_SOURCES = dlfcn.c
+
+libdl_la_CPPFLAGS = @EVIL_DLFCN_CPPFLAGS@
+libdl_la_CFLAGS = @EVIL_CFLAGS@
+libdl_la_LIBADD = $(top_builddir)/src/lib/libevil.la @EVIL_DLFCN_LIBS@
+libdl_la_LDFLAGS = -no-undefined -Wl,--enable-auto-import -version-info @version_info@
+
+EXTRA_DIST = gdtoa/README gdtoa/README.mingw
+
+install-data-hook:
+        rm -f $(libdir)/libevil.la $(libdir)/libdl.la
+
+uninstall-local:
+        rm -f $(DESTDIR)$(bindir)/libevil-@VMAJ@.dll
+        rm -f $(DESTDIR)$(bindir)/libdl-@VMAJ@.dll
+        rm -f $(DESTDIR)$(libdir)/libevil.dll.a
+        rm -f $(DESTDIR)$(libdir)/libevil.a
+        rm -f $(DESTDIR)$(libdir)/libdl.dll.a
+        rm -f $(DESTDIR)$(libdir)/libdl.a
diff --git a/src/lib/evil/dirent.h b/src/lib/evil/dirent.h
new file mode 100644
index 0000000000..3fe9d12866
--- /dev/null
+++ b/src/lib/evil/dirent.h
@@ -0,0 +1,141 @@
+#ifndef __EVIL_DIRENT_H__
+#define __EVIL_DIRENT_H__
+
+#ifdef EAPI
+# undef EAPI
+#endif /* EAPI */
+
+#ifdef _WIN32
+# ifdef EFL_EVIL_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVIL_BUILD */
+#endif /* _WIN32 */
+
+
+/**
+ * @file dirent.h
+ * @brief The file that provides functions ported from Unix in dirent.h.
+ * @defgroup Evil_Dirent_Group Dirent.h functions
+ *
+ * This header provides functions ported from Unix in dirent.h.
+ *
+ * @{
+ */
+
+
+#ifdef UNICODE
+# include <wchar.h>
+#endif
+
+/**
+ * @def DT_UNKNOWN
+ * Specifies that the file type is unknown.
+ */
+#define DT_UNKNOWN 0
+
+/**
+ * @def DT_DIR
+ * Specifies that the file type is a directory.
+ */
+#define DT_DIR     4
+
+/**
+ * @typedef DIR
+ * @brief A structure that describes a directory stream.
+ */
+typedef struct DIR DIR;
+
+/**
+ * @struct dirent
+ * @brief A structure that describes a directory stream.
+ */
+struct dirent
+{
+   char          d_name[260 + 1]; /**< The filename. */
+   int           d_mode;          /**< The mode */
+   unsigned char d_type;          /**< The type */
+};
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * @brief Open the given directory.
+ *
+ * @param name The directory to open.
+ * @return A pointer to the directory stream.
+ *
+ * This function opens the directory @p name and return the directory
+ * stream. On error or if @p dir is NULL, -1 is returned, and errno is
+ * set appropriately (on Windows XP only). On success, 0 is returned.
+ *
+ * @see closedir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI DIR *opendir(char const *name);
+
+/**
+ * @brief Close the given directory.
+ *
+ * @param dir The directory stream to close.
+ * @return A pointer to the directory stream.
+ *
+ * This function closes the stream directory @p dir. On error or is
+ * @p path is NULL or an empty string, NULL is returned, and errno is set
+ * appropriately (on Windows XP only).
+ *
+ * @see opendir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI int closedir(DIR *dir);
+
+/**
+ * @brief Read the given directory.
+ *
+ * @param dir The directory stream to read.
+ * @return A pointer to a dirent structure, @c NULL oterhwise.
+ *
+ * This function returns a pointer to a dirent structure representing
+ * the next directory entry in the directory stream pointed to by
+ * @p dir. It returns NULL on reaching the end of the directory stream
+ * or if an error occurred and errno is set appropriately (on Windows XP only).
+ *
+ * @see opendir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI struct dirent *readdir(DIR *dir);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+
+/**
+ * @}
+ */
+
+
+#endif /* __EVIL_DIRENT_H__ */
diff --git a/src/lib/evil/dlfcn.c b/src/lib/evil/dlfcn.c
new file mode 100644
index 0000000000..818cabf014
--- /dev/null
+++ b/src/lib/evil/dlfcn.c
@@ -0,0 +1,272 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+
+#if defined(__MINGW32CE__) || defined(_MSC_VER)
+# include <limits.h>
+#endif /* __MINGW32CE__ || _MSC_VER */
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#ifdef _WIN32_WCE
+# include <tlhelp32.h> /* CreateToolhelp32Snapshot */
+#else
+# include <psapi.h> /*  EnumProcessModules(Ex) */
+#endif
+
+#include "Evil.h"
+
+#include "dlfcn.h"
+
+
+static char *dl_err = NULL;
+static int dl_err_viewed = 0;
+
+static void
+get_last_error(char *desc)
+{
+   char  *str;
+   size_t l1;
+   size_t l2;
+
+   str = evil_last_error_get();
+
+   l1 = strlen(desc);
+   l2 = strlen(str);
+
+   if (dl_err)
+     free(dl_err);
+
+   dl_err = (char *)malloc(sizeof(char) * (l1 + l2 + 1));
+   if (!dl_err)
+     dl_err = strdup("not enough resource");
+   else
+     {
+        memcpy(dl_err, desc, l1);
+        memcpy(dl_err + l1, str, l2);
+        dl_err[l1 + l2] = '\0';
+     }
+   free(str);
+   dl_err_viewed = 0;
+}
+
+void *
+dlopen(const char* path, int mode __UNUSED__)
+{
+   HMODULE module = NULL;
+
+   if (!path)
+     {
+        module = GetModuleHandle(NULL);
+        if (!module)
+          get_last_error("GetModuleHandle returned: ");
+     }
+   else
+     {
+        char        *new_path;
+        size_t       l;
+        unsigned int i;
+
+        /* according to MSDN, we must change the slash to backslash */
+        l = strlen(path);
+        new_path = (char *)malloc(sizeof(char) * (l + 1));
+        if (!new_path)
+          {
+             if (dl_err)
+               free(dl_err);
+             dl_err = strdup("not enough resource");
+             dl_err_viewed = 0;
+             return NULL;
+          }
+        for (i = 0; i <= l; i++)
+          {
+             if (path[i] == '/')
+               new_path[i] = '\\';
+             else
+               new_path[i] = path[i];
+          }
+#ifdef UNICODE
+        {
+           wchar_t *wpath;
+
+           wpath = evil_char_to_wchar(new_path);
+           module = LoadLibrary(wpath);
+           free(wpath);
+        }
+#else
+        module = LoadLibraryEx(new_path, NULL,
+                               LOAD_WITH_ALTERED_SEARCH_PATH);
+#endif /* ! UNICODE */
+        if (!module)
+          get_last_error("LoadLibraryEx returned: ");
+
+        free(new_path);
+     }
+
+   return module;
+}
+
+int
+dlclose(void* handle)
+{
+   if (FreeLibrary(handle))
+     return 0;
+   else
+     {
+        get_last_error("FreeLibrary returned: ");
+        return -1;
+     }
+}
+
+void *
+dlsym(void *handle, const char *symbol)
+{
+   FARPROC fp = NULL;
+   LPCTSTR new_symbol;
+
+   if (!symbol || !*symbol) return NULL;
+
+#ifdef UNICODE
+   new_symbol = evil_char_to_wchar(symbol);
+#else
+   new_symbol = symbol;
+#endif /* UNICODE */
+
+   if (handle == RTLD_DEFAULT)
+     {
+#ifdef _WIN32_WCE
+        HANDLE snapshot;
+        MODULEENTRY32 module;
+
+        snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS |
+                                            TH32CS_SNAPMODULE |
+                                            TH32CS_GETALLMODS,
+                                            0);
+        if (!snapshot)
+          return NULL;
+
+        module.dwSize = sizeof(module);
+        if (Module32First(snapshot, &module))
+          do {
+            fp = GetProcAddress(module.hModule, new_symbol);
+            if (fp) break;
+          } while (Module32Next(snapshot, &module));
+
+        CloseToolhelp32Snapshot(snapshot);
+#else
+        HMODULE modules[1024];
+        DWORD needed;
+        DWORD i;
+
+        /* TODO: use EnumProcessModulesEx() on Windows >= Vista */
+        if (!EnumProcessModules(GetCurrentProcess(),
+                                modules, sizeof(modules), &needed))
+          return NULL;
+
+        for (i = 0; i < (needed /  sizeof(HMODULE)); i++)
+          {
+            fp = GetProcAddress(modules[i], new_symbol);
+            if (fp) break;
+          }
+#endif
+     }
+   else
+     fp = GetProcAddress(handle, new_symbol);
+
+#ifdef UNICODE
+   free((void *)new_symbol);
+#endif /* UNICODE */
+
+   if (!fp)
+     get_last_error("GetProcAddress returned: ");
+
+   return fp;
+}
+
+int
+dladdr (const void *addr __UNUSED__, Dl_info *info)
+{
+   TCHAR  tpath[PATH_MAX];
+   MEMORY_BASIC_INFORMATION mbi;
+   char  *path;
+   char  *tmp;
+   size_t length;
+   int    ret = 0;
+
+   if (!info)
+     return 0;
+
+#ifdef _WIN32_WINNT
+   length = VirtualQuery(addr, &mbi, sizeof(mbi));
+   if (!length)
+     return 0;
+
+   if (mbi.State != MEM_COMMIT)
+     return 0;
+
+   if (!mbi.AllocationBase)
+     return 0;
+
+   ret = GetModuleFileName((HMODULE)mbi.AllocationBase, (LPTSTR)&tpath, PATH_MAX);
+   if (!ret)
+     return 0;
+#else
+   ret = GetModuleFileName(NULL, (LPTSTR)&tpath, PATH_MAX);
+   if (!ret)
+     return 0;
+#endif
+
+#ifdef UNICODE
+   path = evil_wchar_to_char(tpath);
+#else
+   path = tpath;
+#endif /* ! UNICODE */
+
+   length = strlen (path);
+   if (length >= PATH_MAX)
+     {
+       length = PATH_MAX - 1;
+       path[PATH_MAX - 1] = '\0';
+     }
+
+   /* replace '/' by '\' */
+   tmp = path;
+   while (*tmp)
+     {
+        if (*tmp == '/') *tmp = '\\';
+        tmp++;
+     }
+
+   memcpy (info->dli_fname, path, length + 1);
+   info->dli_fbase = NULL;
+   info->dli_sname = NULL;
+   info->dli_saddr = NULL;
+
+#ifdef UNICODE
+   free (path);
+#endif /* ! UNICODE */
+
+   return 1;
+}
+
+char *
+dlerror (void)
+{
+   if (!dl_err_viewed)
+     {
+        dl_err_viewed = 1;
+        return dl_err;
+     }
+   else
+     {
+        if (dl_err)
+          free(dl_err);
+        return NULL;
+     }
+}
diff --git a/src/lib/evil/dlfcn.h b/src/lib/evil/dlfcn.h
new file mode 100644
index 0000000000..610331b702
--- /dev/null
+++ b/src/lib/evil/dlfcn.h
@@ -0,0 +1,258 @@
+#ifndef __EVIL_DLFCN_H__
+#define __EVIL_DLFCN_H__
+
+
+#include <limits.h>
+
+
+#ifdef EAPI
+# undef EAPI
+#endif /* EAPI */
+
+#ifdef _WIN32
+# ifdef EFL_EVIL_DLFCN_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVIL_DLFCN_BUILD */
+#endif /* _WIN32 */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32_WCE
+# ifndef PATH_MAX
+#  define PATH_MAX 260
+# endif
+#endif
+
+
+/**
+ * @file dlfcn.h
+ * @brief The file that provides functions to manage dynamic-link libraries
+ * @defgroup Dlfcn Functions that manage dynamic-link libraries.
+ *
+ * This header provides functions to load and unload dynamic-link
+ * libaries, to get the address of a symbol, and to get diagnostic
+ * information.
+ */
+
+
+/**
+ * @def RTLD_LAZY
+ * Lazy function call binding.
+ */
+# define RTLD_LAZY    0x00001  /* lazy function call binding */
+
+/**
+ * @def RTLD_NOW
+ * Immediate function call binding.
+ */
+# define RTLD_NOW     0x00002  /* immediate function call binding */
+
+/**
+ * @def RTLD_GLOBAL
+ * Symbols in this dlopen'ed obj are visible to other dlopen'ed objs.
+ */
+# define RTLD_GLOBAL  0x00100  /* symbols in this dlopen'ed obj are visible
+                                  to other dlopen'ed objs */
+
+/**
+ * @def RTLD_NODELETE
+ * Symbols are not deleted when closed.
+ */
+#define RTLD_NODELETE 0x01000  /* do not delete object when closed.  */
+
+/**
+ * @def RTLD_DEFAULT
+ * Symbols are searched in all the DLL opened by the current process.
+ */
+#define RTLD_DEFAULT ((void*)1) /* search the symbol on all the DLL of the current process */
+
+/**
+ * @typedef Dl_info
+ * @brief A structure that stores infomation of a calling process.
+ */
+typedef struct Dl_info Dl_info;
+
+/**
+ * @struct Dl_info
+ * @brief A structure that stores infomation of a calling process.
+ */
+struct Dl_info
+{
+   char        dli_fname[PATH_MAX];  /**< Filename of defining object */
+   void       *dli_fbase;            /**< Load address of that object */
+   const char *dli_sname;            /**< Name of nearest lower symbol */
+   void       *dli_saddr;            /**< Exact value of nearest symbol */
+};
+
+/**
+ * @brief Map a specified executable module (either a .dll or .exe file)
+ * into the address space of the user process.
+ *
+ * @param path Name of the module.
+ * @param mode Unused.
+ * @return A pointer that represent the module, or @c NULL on failure.
+ *
+ * Map a specified executable module (either a .dll or .exe file)
+ * into the address space of the user process. If @p path is @c NULL,
+ * then the module corresponding to the current process is returned.
+ * Otherwise the module specified by @p path is loaded if it exists.
+ * If not, @c NULL is returned. The directory separators can be forward
+ * slash, or backward ones. Mapping a module can map other modules.
+ * @p mode is unused.
+ *
+ * If an error occurred, an error string can be retrived with dlerror().
+ *
+ * According to the OS, the search order of the module can change,
+ * according to the value of SafeDllSearchMode.
+ *
+ *  - For Windows Vista, Windows Server 2003, and Windows XP SP2:
+ *    SafeDLLSearchMode is enabled by default.
+ *  - For Windows XP and Windows 2000 SP4:  SafeDLLSearchMode is disabled
+ *    by default.
+ *
+ * If SafeDllSearchMode is enabled
+ *  - The directory from which the application loaded.
+ *  - The system directory. Use the GetSystemDirectory() function
+ *    to get the path of this directory.
+ *  - The 16-bit system directory. There is no function that obtains
+ *    the path of this directory, but it is searched.
+ *  - The Windows directory. Use the GetWindowsDirectory() function
+ *    to get the path of this directory.
+ *  - The current directory.
+ *  - The directories that are listed in the PATH environment variable.
+ *    Note that this does not include the per-application path specified
+ *    by the App Paths registry key.
+ *
+ * If SafeDllSearchMode is disabled
+ *  - The directory from which the application loaded.
+ *  - The current directory.
+ *  - The system directory. Use the GetSystemDirectory() function
+ *    to get the path of this directory.
+ *  - The 16-bit system directory. There is no function that obtains
+ *    the path of this directory, but it is searched.
+ *  - The Windows directory. Use the GetWindowsDirectory() function
+ *    to get the path of this directory.
+ *  - The directories that are listed in the PATH environment variable.
+ *    Note that this does not include the per-application path specified
+ *    by the App Paths registry key.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI void *dlopen(const char* path, int mode);
+
+/**
+ * @brief Close a dynamic-link library.
+ *
+ * @param handle Handle that references a dynamic-link library.
+ * @return O on sucess, -1 otherwise.
+ *
+ * Release a reference to the dynamic-link library referenced
+ * by @p handle.  If the reference count drops to 0, the handle is
+ * removed from the address space and is rendered invalid. @p handle
+ * is the value returned by a previous call to dlopen().
+ *
+ * If no error occurred, the returned value is 0, otherwise the
+ * returned value is -1 and an error string can be retrived with
+ * dlerror().
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI int   dlclose(void* handle);
+
+/**
+ * @brief Get the address of a symbol.
+ *
+ * @param handle Handle that references a dynamic-link library.
+ * @param symbol @c NULL-terminated string.
+ * @return O on sucess, NULL otherwise.
+ *
+ * Return the address of the code or data location specified by the
+ * string @p symbol.  @p handle references a library that contains
+ * the function or variable @p symbol.
+ *
+ * If no error occurred, the returned value is the code or data
+ * location, otherwise the returned value is NULL and an error
+ * string can be retrived with dlerror().
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI void *dlsym(void* handle, const char* symbol);
+
+/**
+ * @brief Get the location of the current process (.exe)
+ *
+ * @param addr Unused.
+ * @param info Pointer to the Dl_info to fill.
+ * @return 1 on success, 0 otherwise.
+ *
+ * Fill the dli_fname member of @p info with the absolute name
+ * of the current calling process (.exe file that is executed).
+ * All other members are set to @c NULL.
+ *
+ * Contrary to the unix function, the full name of the shared
+ * library is not returned, but insted the full name of the current
+ * calling process (.exe file).
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI int dladdr (const void *addr, Dl_info *info);
+
+/**
+ * @brief Get diagnostic information
+ *
+ * @return A @c NULL-terminated string if an error occured, @c NULL
+ * otherwise.
+ *
+ * Return a @c NULL-terminated character string describing the last
+ * error that occurred on this thread during a call to dlopen(),
+ * dlsym(), or dlclose(). If no such error has occurred, dlerror()
+ * returns a null pointer.  At each call to dlerror(), the error
+ * indication is reset.  Thus in the case of two calls to dlerror(),
+ * where the second call follows the first immediately, the second
+ * call will always return a null pointer.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI char *dlerror (void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __EVIL_DLFCN_H__ */
diff --git a/src/lib/evil/evil_dirent.c b/src/lib/evil/evil_dirent.c
new file mode 100644
index 0000000000..e02b95fe27
--- /dev/null
+++ b/src/lib/evil/evil_dirent.c
@@ -0,0 +1,197 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <dirent.h>
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif
+
+#include "Evil.h"
+
+
+struct DIR
+{
+   struct dirent   dirent;
+   WIN32_FIND_DATA data;
+   HANDLE          handle;
+};
+
+
+DIR *opendir(char const *name)
+{
+   DIR     *dir;
+   char    *tmp1;
+   char    *tmp2;
+   DWORD    attr;
+   size_t   l;
+#ifdef UNICODE
+   wchar_t *wname;
+   char    *d_name;
+#endif
+
+   /* valid name */
+   if (!name || !*name)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOENT;
+#endif
+        return NULL;
+     }
+
+#ifdef UNICODE
+   wname = evil_char_to_wchar(name);
+   if (!wname)
+     {
+# ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+# endif
+        return NULL;
+     }
+
+   if((attr = GetFileAttributes(wname)) == 0xFFFFFFFF)
+#else
+   if((attr = GetFileAttributes(name)) == 0xFFFFFFFF)
+#endif
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOENT;
+#endif
+        return NULL;
+     }
+
+#ifdef UNICODE
+   free(wname);
+#endif
+
+   /* directory */
+   if (!(attr & FILE_ATTRIBUTE_DIRECTORY))
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOTDIR;
+#endif
+        return NULL;
+     }
+
+   dir = (DIR *)malloc(sizeof(DIR));
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        return NULL;
+     }
+
+   l = strlen(name);
+   tmp1 = (char *)malloc(sizeof(char) * l + 5);
+   if (!tmp1)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        return NULL;
+     }
+
+   memcpy(tmp1, name, l);
+   memcpy(tmp1 + l, "\\*.*", 5);
+
+   tmp2 = tmp1;
+   while (*tmp2)
+     {
+        if (*tmp2 == '/') *tmp2 = '\\';
+        tmp2++;
+     }
+
+#ifdef UNICODE
+   wname = evil_char_to_wchar(tmp1);
+   if (!wname)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        free(tmp1);
+
+        return NULL;
+     }
+   dir->handle = FindFirstFile(wname, &dir->data);
+   free(wname);
+#else
+   dir->handle = FindFirstFile(tmp1, &dir->data);
+#endif
+
+   free(tmp1);
+
+   if (dir->handle == INVALID_HANDLE_VALUE)
+     {
+        free(dir);
+        return NULL;
+     }
+
+#ifdef UNICODE
+   d_name = evil_wchar_to_char(dir->data.cFileName);
+   strcpy(dir->dirent.d_name, d_name);
+   free(d_name);
+#else
+   strcpy(dir->dirent.d_name, dir->data.cFileName);
+#endif
+   dir->dirent.d_mode = (int)dir->data.dwFileAttributes;
+
+   if (dir->data.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
+     dir->dirent.d_type = DT_DIR;
+   else
+     dir->dirent.d_type = DT_UNKNOWN;
+
+   return dir;
+}
+
+int closedir(DIR *dir)
+{
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = EBADF;
+#endif
+        return -1;
+     }
+
+   if (dir->handle != INVALID_HANDLE_VALUE)
+     FindClose(dir->handle);
+   free(dir);
+
+   return 0;
+}
+
+struct dirent *readdir(DIR *dir)
+{
+#ifdef UNICODE
+   char *d_name;
+#endif
+
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = EBADF;
+#endif
+        return NULL;
+     }
+
+   if (dir->handle == INVALID_HANDLE_VALUE)
+     return NULL;
+
+#ifdef UNICODE
+     d_name = evil_wchar_to_char(dir->data.cFileName);
+     strcpy(dir->dirent.d_name, d_name);
+     free(d_name);
+#else
+     strcpy(dir->dirent.d_name, dir->data.cFileName);
+#endif
+
+   if (!FindNextFile(dir->handle, &dir->data))
+     {
+        FindClose(dir->handle);
+        dir->handle = INVALID_HANDLE_VALUE;
+     }
+
+   return &dir->dirent;
+}
diff --git a/src/lib/evil/evil_errno.c b/src/lib/evil/evil_errno.c
new file mode 100644
index 0000000000..37cac611f0
--- /dev/null
+++ b/src/lib/evil/evil_errno.c
@@ -0,0 +1,9 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Evil.h"
+#include "mingw32ce/errno.h"
+
+
+int errno = 0;
diff --git a/src/lib/evil/evil_fcntl.c b/src/lib/evil/evil_fcntl.c
new file mode 100644
index 0000000000..7c62c2a310
--- /dev/null
+++ b/src/lib/evil/evil_fcntl.c
@@ -0,0 +1,124 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+
+#ifdef _MSC_VER
+# include <io.h>   /* for _get_osfhandle _lseek and _locking */
+#endif
+
+#include <sys/locking.h>
+
+#include <winsock2.h> /* for ioctlsocket */
+
+#include "Evil.h"
+
+
+#ifdef __MINGW32CE__
+# define _get_osfhandle(FILEDES) ((HANDLE)FILEDES)
+#endif /* __MINGW32CE__ */
+
+
+/*
+ * port of fcntl function
+ *
+ */
+
+int fcntl(int fd, int cmd, ...)
+{
+   va_list va;
+   HANDLE  h;
+   int     res = -1;
+
+   va_start (va, cmd);
+
+   h = (HANDLE)_get_osfhandle(fd);
+   if (h == INVALID_HANDLE_VALUE)
+     return -1;
+
+   if (cmd == F_GETFD)
+     {
+#ifndef __MINGW32CE__
+        DWORD flag;
+
+        if (!GetHandleInformation(h, &flag))
+          return -1;
+
+        res = 0;
+#endif /* ! __MINGW32CE__ */
+     }
+
+   if (cmd == F_SETFD)
+     {
+        long flag;
+
+        flag = va_arg(va, long);
+        if (flag == FD_CLOEXEC)
+          {
+#ifndef __MINGW32CE__
+             if (SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0))
+               res = 0;
+#endif /* ! __MINGW32CE__ */
+          }
+     }
+   else if (cmd == F_SETFL)
+     {
+        long flag;
+
+        flag = va_arg(va, long);
+        if (flag == O_NONBLOCK)
+          {
+             u_long arg = 1;
+             int    type;
+             int    len;
+             int    ret;
+
+             len = (int)sizeof(int);
+             ret = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, (char *)&type, &len);
+             if (!ret && (type == SOCK_STREAM))
+               {
+                  if (!ioctlsocket((SOCKET)fd, FIONBIO, &arg) == SOCKET_ERROR)
+                    res = 0;
+               }
+          }
+     }
+#ifndef __MINGW32CE__
+   else if ((cmd == F_SETLK) || (cmd == F_SETLKW))
+     {
+        struct flock *fl;
+        off_t        length = 0;
+        long         pos;
+
+        fl = va_arg(va, struct flock *);
+
+        if (fl->l_len == 0)
+          {
+             length = _lseek(fd, 0L, SEEK_END);
+             if (length != -1L)
+               res = 0;
+          }
+        fl->l_len = length - fl->l_start - 1;
+
+        pos = _lseek(fd, fl->l_start, fl->l_whence);
+        if (pos != -1L)
+          res = 0;
+
+        if ((fl->l_type == F_RDLCK) || (fl->l_type == F_WRLCK))
+          {
+             if (cmd == F_SETLK)
+               res = _locking(fd, _LK_NBLCK, fl->l_len); /* if cannot be locked, we return immediatly */
+             else /* F_SETLKW */
+               res = _locking(fd, _LK_LOCK, fl->l_len); /* otherwise, we try several times */
+          }
+
+        if (fl->l_type == F_UNLCK)
+          res = _locking(fd, _LK_UNLCK, fl->l_len);
+     }
+
+#endif /* ! __MINGW32CE__ */
+
+   va_end(va);
+
+   return res;
+}
diff --git a/src/lib/evil/evil_fcntl.h b/src/lib/evil/evil_fcntl.h
new file mode 100644
index 0000000000..194341b369
--- /dev/null
+++ b/src/lib/evil/evil_fcntl.h
@@ -0,0 +1,110 @@
+#ifndef __EVIL_FCNTL_H__
+#define __EVIL_FCNTL_H__
+
+
+# include <sys/types.h>
+
+
+/**
+ * @def FD_CLOEXEC
+ * Specifies that the file descriptor should be closed when an exec()
+ * function is invoked.
+ */
+# define FD_CLOEXEC 1
+
+/**
+ * @def O_NONBLOCK
+ * Specifies that the socket is in non-blocking mode.
+ */
+# define O_NONBLOCK 04000
+
+/**
+ * @def F_SETFD
+ * Specifies that fcntl() should set the file descriptor flags
+ * associated with the filedes argument.
+ */
+
+/**
+ * @def F_SETLK
+ * Specifies that fcntl() should set or clear a file segment lock
+ * according to the lock description pointed to by the third argument.
+ */
+
+/**
+ * @def F_SETLKW
+ * Equivalent to F_SETLK except that if a shared or exclusive lock
+ * is blocked by other locks, the thread shall wait until the request
+ * can be satisfied.
+ */
+
+# define F_GETFD    1
+# define F_SETFD    2
+# define F_SETFL    4
+# define F_SETLK    6
+# define F_SETLKW   7
+
+/**
+ * @def F_RDLCK
+ * Read (or shared) lock
+ */
+
+/**
+ * @def F_WRLCK
+ * Write (or exclusive) lock
+ */
+
+/**
+ * @def F_UNLCK
+ * Remove lock
+ */
+
+# ifndef F_RDLCK
+#  define F_RDLCK     0
+#  define F_WRLCK     1
+#  define F_UNLCK     2
+# endif /* ! F_RDLCK */
+
+/**
+ * @struct flock
+ * @brief A structure that controls the lock of a file descriptor.
+ */
+struct flock
+{
+   short int l_type;   /**< lock type: read, write, ... */
+   short int l_whence; /**< type of l_start */
+   off_t     l_start;  /**< starting offset */
+   off_t     l_len;    /**< 0 means end of the file */
+   pid_t     l_pid;    /**< lock owner */
+};
+
+
+/**
+ * @brief Provide control over file descriptors.
+ *
+ * @param fd The file descriptor.
+ * @param cmd The type of control.
+ * @return 0 on success, -1 otherwise.
+ *
+ * Performs one of various miscellaneous operations on @p fd.
+ * The operation in question is determined by @p cmd:
+ *
+ * - F_SETFD: Set the close-on-exec flag to the value specified
+ *   by the argument after command (only the least significant
+ *   bit is used).
+ * - F_SETLK and F_SETLKW: used to manage discretionary file locks.
+ *   The third argument must be a pointer to a struct flock (that
+ *   may be overwritten by this call).
+ *
+ * This function returns 0 on success, -1 otherwise.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Evil
+ */
+EAPI int fcntl(int fd, int cmd, ...);
+
+
+#endif /* __EVIL_FCNTL_H__ */
diff --git a/src/lib/evil/evil_fnmatch.c b/src/lib/evil/evil_fnmatch.c
new file mode 100644
index 0000000000..0b4af7bfb0
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch.c
@@ -0,0 +1,231 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+#include <string.h>
+
+#include "fnmatch.h"
+#include "evil_fnmatch_private.h"
+
+enum fnmatch_status
+{
+  fnmatch_not_found    = 0,
+  fnmatch_found        = 1,
+  fnmatch_syntax_error = 2
+};
+
+static
+size_t
+fnmatch_match_class_token(enum fnmatch_status *status,
+                          const char          *class_token,
+                          char                 c)
+{
+  if (! *class_token)
+    {
+      *status = fnmatch_syntax_error;
+      return 0;
+    }
+  else if (class_token[1] == '-' && class_token[2] != ']')
+    {
+      if (class_token[0] <= c && c <= class_token[2])
+        *status = fnmatch_found;
+      return 3;
+    }
+  else
+    {
+      if (c == *class_token)
+        *status = fnmatch_found;
+      return 1;
+    }
+}
+
+static
+size_t
+fnmatch_complement_class(const char *class_token)
+{
+  switch (*class_token)
+    {
+    case 0:
+      return FNM_SYNTAXERR;
+
+    case '!':
+      return 1;
+
+    default:
+      return 0;
+    }
+}
+
+static
+size_t
+fnmatch_match_class(const char *class,
+                    char        c)
+{
+  const size_t        complement = fnmatch_complement_class(class + 1);
+  enum fnmatch_status status;
+  size_t              pos;
+
+  if (complement == FNM_SYNTAXERR)
+    return FNM_SYNTAXERR;
+
+  status = fnmatch_not_found;
+  pos = 1 + complement;
+
+  do
+    pos += fnmatch_match_class_token(&status, class + pos, c);
+  while (class[pos] && class[pos] != ']');
+
+  if (status == fnmatch_syntax_error || ! class[pos])
+    return FNM_SYNTAXERR;
+
+  if (status == fnmatch_found)
+    return complement ? 0 : pos + 1;
+  else
+    return complement ? pos + 1 : 0;
+}
+
+static
+size_t
+fnmatch_chrcasecmp(char a,
+                   char b)
+{
+  if ('A' <= a && a <= 'Z')
+    a += 'a' - 'A';
+  if ('A' <= b && b <= 'Z')
+    b += 'a' - 'A';
+  return a == b;
+}
+
+static
+size_t
+fnmatch_match_token(const char *token,
+                    char        c,
+                    e_bool      leading,
+                    int         flags)
+{
+  if (*token == '\\' && !(flags & FNM_NOESCAPE))
+    return token[1] ? (token[1] == c ? 2 : 0) : FNM_SYNTAXERR;
+
+  if (c == '/' && (flags & FNM_PATHNAME))
+    return *token == '/';
+
+  if (c == '.' && leading && (flags & FNM_PERIOD))
+    return *token == '.';
+
+  switch (*token)
+    {
+    case '?':
+      return 1;
+
+    case '[':
+      return fnmatch_match_class(token, c);
+
+    default:
+      if (flags & FNM_CASEFOLD)
+        return fnmatch_chrcasecmp(*token, c);
+      return *token == c ? 1 : 0;
+    }
+}
+
+static
+void
+fnmatch_init_states(struct list_of_states *states)
+{
+  states->size = 1;
+  states->states[0] = 0;
+  memset(states->has, 0, states->reserved * sizeof (*states->has));
+  states->has[0] = 1;
+}
+
+static
+size_t
+fnmatch_check_finals(const char                  *pattern,
+                     const struct list_of_states *states)
+{
+   size_t i, j;
+   for (i = 0; i < states->size; ++i)
+     {
+       e_bool match = 1;
+
+       for (j = states->states[i]; pattern[j]; ++j)
+         if (pattern[j] != '*')
+           {
+             match = 0;
+             break;
+           }
+
+       if (match)
+         return 0;
+     }
+   return FNM_NOMATCH;
+}
+
+int
+fnmatch(const char *pattern,
+        const char *string,
+        int         flags)
+{
+   struct list_of_states *states;
+   struct list_of_states *new_states;
+   e_bool                 leading = 1;
+   char                  *c;
+   size_t                 r;
+
+  assert(pattern);
+  assert(string);
+
+  states = fnmatch_list_of_states_alloc(2, strlen(pattern));
+  new_states = states + 1;
+
+  if (! states)
+    return FNM_NOMEM;
+  fnmatch_init_states(states);
+
+
+  for (c = (char *)string; *c && states->size; ++c)
+    {
+       size_t i;
+      fnmatch_list_of_states_clear(new_states);
+
+      for (i = 0; i < states->size; ++i)
+        {
+          const size_t pos = states->states[i];
+
+          if (! pattern[pos])
+            {
+              if (*c == '/' && (flags & FNM_LEADING_DIR))
+                return 0;
+              continue;
+            }
+          else if (pattern[pos] == '*')
+            {
+              fnmatch_list_of_states_insert(states, pos + 1);
+              if ((*c != '/' || !(flags & FNM_PATHNAME)) &&
+                  (*c != '.' || !leading || !(flags & FNM_PERIOD)))
+                fnmatch_list_of_states_insert(new_states, pos);
+            }
+          else
+            {
+              const size_t m = fnmatch_match_token(pattern + pos, *c,
+                                                leading, flags);
+
+              if (m == FNM_SYNTAXERR)
+                return FNM_SYNTAXERR;
+              else if (m)
+                fnmatch_list_of_states_insert(new_states, pos + m);
+            }
+        }
+      {
+        struct list_of_states *tmp = states;
+
+        states = new_states;
+        new_states = tmp;
+      }
+      leading = *c == '/' && (flags & FNM_PATHNAME);
+    }
+
+  r = fnmatch_check_finals(pattern, states);
+  fnmatch_list_of_states_free(states < new_states ? states : new_states, 2);
+  return (int)r;
+}
diff --git a/src/lib/evil/evil_fnmatch_list_of_states.c b/src/lib/evil/evil_fnmatch_list_of_states.c
new file mode 100644
index 0000000000..c6cfb7fe81
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch_list_of_states.c
@@ -0,0 +1,77 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "evil_fnmatch_private.h"
+
+struct list_of_states*
+fnmatch_list_of_states_alloc(size_t n,
+                             size_t pattern_len)
+{
+  struct list_of_states *l;
+
+  const size_t  reserved        = pattern_len + 1;
+  const size_t  states_size     = sizeof (*l->states) * reserved;
+  const size_t  has_size        = sizeof (*l->has) * reserved;
+  const size_t  states_has_size = states_size + has_size;
+  const size_t  struct_size     = sizeof (*l) + states_has_size;
+
+  unsigned char *states;
+  unsigned char *has;
+  size_t         i;
+
+  l = malloc(n * struct_size);
+  if (!l)
+    return 0;
+
+  states = (unsigned char *) (l + n);
+  has = states + states_size;
+
+  for (i = 0; i < n; ++i)
+    {
+      l[i].reserved = reserved;
+      l[i].states = (size_t *) states;
+      l[i].has = (e_bool *) has;
+      states += states_has_size;
+      has += states_has_size;
+    }
+
+  return l;
+}
+
+void
+fnmatch_list_of_states_free(struct list_of_states *lists,
+                            size_t                 n)
+{
+  assert(lists);
+
+  (void) n;
+  free(lists);
+}
+
+void
+fnmatch_list_of_states_insert(struct list_of_states *list,
+                              size_t                 state)
+{
+  assert(list);
+  assert(state < list->reserved);
+
+  if (list->has[state])
+    return;
+
+  list->states[list->size++] = state;
+  list->has[state] = 1;
+}
+
+void
+fnmatch_list_of_states_clear(struct list_of_states *list)
+{
+  assert(list);
+
+  list->size = 0;
+  memset(list->has, 0, list->reserved * sizeof (*list->has));
+}
diff --git a/src/lib/evil/evil_fnmatch_private.h b/src/lib/evil/evil_fnmatch_private.h
new file mode 100644
index 0000000000..f5ced5d68f
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch_private.h
@@ -0,0 +1,24 @@
+#ifndef __EVIL_FNMATCH_PRIVATE_H__
+#define __EVIL_FNMATCH_PRIVATE_H__
+
+
+typedef int e_bool;
+
+struct list_of_states
+{
+  size_t        reserved;
+  size_t        size;
+  size_t        *states;
+  e_bool                *has;
+};
+
+struct list_of_states *fnmatch_list_of_states_alloc(size_t n, size_t pattern_len);
+
+void fnmatch_list_of_states_free(struct list_of_states *lists, size_t n);
+
+void fnmatch_list_of_states_insert(struct list_of_states *list, size_t state);
+
+void fnmatch_list_of_states_clear(struct list_of_states *list);
+
+
+#endif /* __EVIL_FNMATCH_PRIVATE_H__ */
diff --git a/src/lib/evil/evil_inet.c b/src/lib/evil/evil_inet.c
new file mode 100644
index 0000000000..99ce14edc2
--- /dev/null
+++ b/src/lib/evil/evil_inet.c
@@ -0,0 +1,648 @@
+
+/*
+ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 1996,1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Modifications: Vincent Torri, for the integration in Evil
+ * - modification of the name of some functions
+ * * modification of the management of the error
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif /* HAVE_ERRNO_H */
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include "evil_macro.h"
+#include "evil_inet.h"
+#include "evil_private.h"
+#define APICHAR char
+#include "evil_print.h"
+
+#ifndef EMSGSIZE
+# define EMSGSIZE WSAEMSGSIZE
+#endif
+
+#ifndef EAFNOSUPPORT
+# define EAFNOSUPPORT WSAEAFNOSUPPORT
+#endif
+
+#define SPRINTF(x) ((size_t)sprintf x)
+
+#define ERRNO         ((int)GetLastError())
+#define SET_ERRNO(x)  (SetLastError((DWORD)(x)))
+
+#define ISDIGIT(x)  (isdigit((int)  ((unsigned char)x)))
+#define ISXDIGIT(x) (isxdigit((int) ((unsigned char)x)))
+#define ISUPPER(x)  (isupper((int)  ((unsigned char)x)))
+
+#define NS_IN6ADDRSZ 16
+#define NS_INT16SZ 2
+#define NS_INADDRSZ sizeof(IN_ADDR)
+
+
+struct ares_in6_addr {
+  union {
+    unsigned char _S6_u8[16];
+  } _S6_un;
+};
+
+const struct ares_in6_addr ares_in6addr_any = { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } };
+
+
+/*
+ * static int
+ * inet_net_pton_ipv4(src, dst, size)
+ *      convert IPv4 network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not an IPv4 network specification.
+ * note:
+ *      network byte order assumed.  this means 192.5.5.240/28 has
+ *      0b11110000 in its fourth octet.
+ * note:
+ *      On Windows we store the error in the thread errno, not
+ *      in the winsock error code. This is to avoid loosing the
+ *      actual last winsock error. So use macro ERRNO to fetch the
+ *      errno this funtion sets when returning (-1), not SOCKERRNO.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+static int
+inet_net_pton_ipv4(const char *src, unsigned char *dst, size_t size)
+{
+  static const char xdigits[] = "0123456789abcdef";
+  static const char digits[] = "0123456789";
+  int n, ch, tmp = 0, dirty, bits;
+  const unsigned char *odst = dst;
+
+  ch = *src++;
+  if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
+      && ISXDIGIT(src[1])) {
+    /* Hexadecimal: Eat nybble string. */
+    if (!size)
+      goto emsgsize;
+    dirty = 0;
+    src++;  /* skip x or X. */
+    while ((ch = *src++) != '\0' && ISXDIGIT(ch)) {
+      if (ISUPPER(ch))
+        ch = tolower(ch);
+      n = (int)(strchr(xdigits, ch) - xdigits);
+      if (dirty == 0)
+        tmp = n;
+      else
+        tmp = (tmp << 4) | n;
+      if (++dirty == 2) {
+        if (!size--)
+          goto emsgsize;
+        *dst++ = (unsigned char) tmp;
+        dirty = 0;
+      }
+    }
+    if (dirty) {  /* Odd trailing nybble? */
+      if (!size--)
+        goto emsgsize;
+      *dst++ = (unsigned char) (tmp << 4);
+    }
+  } else if (ISDIGIT(ch)) {
+    /* Decimal: eat dotted digit string. */
+    for (;;) {
+      tmp = 0;
+      do {
+        n = (int)(strchr(digits, ch) - digits);
+        tmp *= 10;
+        tmp += n;
+        if (tmp > 255)
+          goto enoent;
+      } while ((ch = *src++) != '\0' &&
+               ISDIGIT(ch));
+      if (!size--)
+        goto emsgsize;
+      *dst++ = (unsigned char) tmp;
+      if (ch == '\0' || ch == '/')
+        break;
+      if (ch != '.')
+        goto enoent;
+      ch = *src++;
+      if (!ISDIGIT(ch))
+        goto enoent;
+    }
+  } else
+    goto enoent;
+
+  bits = -1;
+  if (ch == '/' &&
+      ISDIGIT(src[0]) && dst > odst) {
+    /* CIDR width specifier.  Nothing can follow it. */
+    ch = *src++;    /* Skip over the /. */
+    bits = 0;
+    do {
+      n = (int)(strchr(digits, ch) - digits);
+      bits *= 10;
+      bits += n;
+    } while ((ch = *src++) != '\0' && ISDIGIT(ch));
+    if (ch != '\0')
+      goto enoent;
+    if (bits > 32)
+      goto emsgsize;
+  }
+
+  /* Firey death and destruction unless we prefetched EOS. */
+  if (ch != '\0')
+    goto enoent;
+
+  /* If nothing was written to the destination, we found no address. */
+  if (dst == odst)
+    goto enoent;
+  /* If no CIDR spec was given, infer width from net class. */
+  if (bits == -1) {
+    if (*odst >= 240)       /* Class E */
+      bits = 32;
+    else if (*odst >= 224)  /* Class D */
+      bits = 8;
+    else if (*odst >= 192)  /* Class C */
+      bits = 24;
+    else if (*odst >= 128)  /* Class B */
+      bits = 16;
+    else                    /* Class A */
+      bits = 8;
+    /* If imputed mask is narrower than specified octets, widen. */
+    if (bits < ((dst - odst) * 8))
+      bits = (int)(dst - odst) * 8;
+    /*
+     * If there are no additional bits specified for a class D
+     * address adjust bits to 4.
+     */
+    if (bits == 8 && *odst == 224)
+      bits = 4;
+  }
+  /* Extend network to cover the actual mask. */
+  while (bits > ((dst - odst) * 8)) {
+    if (!size--)
+      goto emsgsize;
+    *dst++ = '\0';
+  }
+  return (bits);
+
+  enoent:
+  SET_ERRNO(ENOENT);
+  return (-1);
+
+  emsgsize:
+  SET_ERRNO(EMSGSIZE);
+  return (-1);
+}
+
+static int
+getbits(const char *src, int *bitsp)
+{
+  static const char digits[] = "0123456789";
+  int n;
+  int val;
+  char ch;
+
+  val = 0;
+  n = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    pch = strchr(digits, ch);
+    if (pch != NULL) {
+      if (n++ != 0 && val == 0)       /* no leading zeros */
+        return (0);
+      val *= 10;
+      val += (pch - digits);
+      if (val > 128)                  /* range */
+        return (0);
+      continue;
+    }
+    return (0);
+  }
+  if (n == 0)
+    return (0);
+  *bitsp = val;
+  return (1);
+}
+
+static int
+getv4(const char *src, unsigned char *dst, int *bitsp)
+{
+  static const char digits[] = "0123456789";
+  unsigned char *odst = dst;
+  int n;
+  unsigned int val;
+  char ch;
+
+  val = 0;
+  n = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    pch = strchr(digits, ch);
+    if (pch != NULL) {
+      if (n++ != 0 && val == 0)       /* no leading zeros */
+        return (0);
+      val *= 10;
+      val += (pch - digits);
+      if (val > 255)                  /* range */
+        return (0);
+      continue;
+    }
+    if (ch == '.' || ch == '/') {
+      if (dst - odst > 3)             /* too many octets? */
+        return (0);
+      *dst++ = (unsigned char)val;
+      if (ch == '/')
+        return (getbits(src, bitsp));
+      val = 0;
+      n = 0;
+      continue;
+    }
+    return (0);
+  }
+  if (n == 0)
+    return (0);
+  if (dst - odst > 3)             /* too many octets? */
+    return (0);
+  *dst++ = (unsigned char)val;
+  return (1);
+}
+
+static int
+inet_net_pton_ipv6(const char *src, unsigned char *dst, size_t size)
+{
+  static const char xdigits_l[] = "0123456789abcdef",
+    xdigits_u[] = "0123456789ABCDEF";
+  unsigned char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
+  const char *xdigits, *curtok;
+  int ch, saw_xdigit;
+  unsigned int val;
+  int digits;
+  int bits;
+  size_t bytes;
+  int words;
+  int ipv4;
+
+  memset((tp = tmp), '\0', NS_IN6ADDRSZ);
+  endp = tp + NS_IN6ADDRSZ;
+  colonp = NULL;
+  /* Leading :: requires some special handling. */
+  if (*src == ':')
+    if (*++src != ':')
+      goto enoent;
+  curtok = src;
+  saw_xdigit = 0;
+  val = 0;
+  digits = 0;
+  bits = -1;
+  ipv4 = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+      pch = strchr((xdigits = xdigits_u), ch);
+    if (pch != NULL) {
+      val <<= 4;
+      val |= (pch - xdigits);
+      if (++digits > 4)
+        goto enoent;
+      saw_xdigit = 1;
+      continue;
+    }
+    if (ch == ':') {
+      curtok = src;
+      if (!saw_xdigit) {
+        if (colonp)
+          goto enoent;
+        colonp = tp;
+        continue;
+      } else if (*src == '\0')
+        goto enoent;
+      if (tp + NS_INT16SZ > endp)
+        return (0);
+      *tp++ = (unsigned char)((val >> 8) & 0xff);
+      *tp++ = (unsigned c