ebb 0.2.1 → 0.3.0

data/libev/ev.c

@@ -156,6 +156,7 @@ extern "C" {
 # include <sys/wait.h>
 # include <unistd.h>
 #else
+# include <io.h>
 # define WIN32_LEAN_AND_MEAN
 # include <windows.h>
 # ifndef EV_SELECT_IS_WINSOCKET
@@ -166,7 +167,11 @@ extern "C" {
 /* this block tries to deduce configuration from header-defined symbols and defaults */
 
 #ifndef EV_USE_MONOTONIC
-# define EV_USE_MONOTONIC 0
+# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
+#  define EV_USE_MONOTONIC 1
+# else
+#  define EV_USE_MONOTONIC 0
+# endif
 #endif
 
 #ifndef EV_USE_REALTIME
@@ -174,7 +179,11 @@ extern "C" {
 #endif
 
 #ifndef EV_USE_NANOSLEEP
-# define EV_USE_NANOSLEEP 0
+# if _POSIX_C_SOURCE >= 199309L
+#  define EV_USE_NANOSLEEP 1
+# else
+#  define EV_USE_NANOSLEEP 0
+# endif
 #endif
 
 #ifndef EV_USE_SELECT
@@ -558,6 +567,9 @@ ev_sleep (ev_tstamp delay)
       tv.tv_sec  = (time_t)delay;
       tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
 
+      /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
+      /* somehting nto guaranteed by newer posix versions, but guaranteed */
+      /* by older ones */
       select (0, 0, 0, 0, &tv);
 #endif
     }
@@ -701,13 +713,13 @@ fd_reify (EV_P)
 #if EV_SELECT_IS_WINSOCKET
       if (events)
         {
-          unsigned long argp;
+          unsigned long arg;
           #ifdef EV_FD_TO_WIN32_HANDLE
             anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
           #else
             anfd->handle = _get_osfhandle (fd);
           #endif
-          assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &argp) == 0));
+          assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
         }
 #endif
 
@@ -770,7 +782,7 @@ fd_ebadf (EV_P)
 
   for (fd = 0; fd < anfdmax; ++fd)
     if (anfds [fd].events)
-      if (!fd_valid (fd) == -1 && errno == EBADF)
+      if (!fd_valid (fd) && errno == EBADF)
         fd_kill (EV_A_ fd);
 }
 
@@ -977,7 +989,7 @@ void inline_speed
 fd_intern (int fd)
 {
 #ifdef _WIN32
-  int arg = 1;
+  unsigned long arg = 1;
   ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
 #else
   fcntl (fd, F_SETFD, FD_CLOEXEC);
@@ -2563,6 +2575,12 @@ infy_fork (EV_P)
 
 #endif
 
+#ifdef _WIN32
+# define EV_LSTAT(p,b) _stati64 (p, b)
+#else
+# define EV_LSTAT(p,b) lstat (p, b)
+#endif
+
 void
 ev_stat_stat (EV_P_ ev_stat *w)
 {

data/libev/ev.h

@@ -90,6 +90,10 @@ typedef double ev_tstamp;
 /*****************************************************************************/
 
 #if EV_STAT_ENABLE
+# ifdef _WIN32
+#  include <time.h>
+#  include <sys/types.h>
+# endif
 # include <sys/stat.h>
 #endif
 

data/libev/ev_select.c

@@ -54,6 +54,8 @@
 #if EV_SELECT_IS_WINSOCKET
 # undef EV_SELECT_USE_FD_SET
 # define EV_SELECT_USE_FD_SET 1
+# undef NFDBITS
+# define NFDBITS 0
 #endif
 
 #if !EV_SELECT_USE_FD_SET
@@ -77,15 +79,24 @@ select_modify (EV_P_ int fd, int oev, int nev)
     int handle = fd;
     #endif
 
-    if (nev & EV_READ)
-      FD_SET (handle, (fd_set *)vec_ri);
-    else
-      FD_CLR (handle, (fd_set *)vec_ri);
+    /* FD_SET is broken on windows (it adds the fd to a set twice or more,
+     * which eventually leads to overflows). Need to call it only on changes.
+     */
+    #if EV_SELECT_IS_WINSOCKET
+    if ((oev ^ nev) & EV_READ)
+    #endif
+      if (nev & EV_READ)
+        FD_SET (handle, (fd_set *)vec_ri);
+      else
+        FD_CLR (handle, (fd_set *)vec_ri);
 
-    if (nev & EV_WRITE)
-      FD_SET (handle, (fd_set *)vec_wi);
-    else
-      FD_CLR (handle, (fd_set *)vec_wi);
+    #if EV_SELECT_IS_WINSOCKET
+    if ((oev ^ nev) & EV_WRITE)
+    #endif
+      if (nev & EV_WRITE)
+        FD_SET (handle, (fd_set *)vec_wi);
+      else
+        FD_CLR (handle, (fd_set *)vec_wi);
 
 #else
 
@@ -100,6 +111,9 @@ select_modify (EV_P_ int fd, int oev, int nev)
         vec_ro = ev_realloc (vec_ro, new_max * NFDBYTES); /* could free/malloc */
         vec_wi = ev_realloc (vec_wi, new_max * NFDBYTES);
         vec_wo = ev_realloc (vec_wo, new_max * NFDBYTES); /* could free/malloc */
+        #ifdef _WIN32
+        vec_eo = ev_realloc (vec_eo, new_max * NFDBYTES); /* could free/malloc */
+        #endif
 
         for (; vec_max < new_max; ++vec_max)
           ((fd_mask *)vec_ri) [vec_max] =
@@ -122,19 +136,31 @@ select_poll (EV_P_ ev_tstamp timeout)
 {
   struct timeval tv;
   int res;
+  int fd_setsize;
+
+  tv.tv_sec  = (long)timeout;
+  tv.tv_usec = (long)((timeout - (ev_tstamp)tv.tv_sec) * 1e6);
 
 #if EV_SELECT_USE_FD_SET
-  memcpy (vec_ro, vec_ri, sizeof (fd_set));
-  memcpy (vec_wo, vec_wi, sizeof (fd_set));
+  fd_setsize = sizeof (fd_set);
 #else
-  memcpy (vec_ro, vec_ri, vec_max * NFDBYTES);
-  memcpy (vec_wo, vec_wi, vec_max * NFDBYTES);
+  fd_setsize = vec_max * NFDBYTES;
 #endif
 
-  tv.tv_sec  = (long)timeout;
-  tv.tv_usec = (long)((timeout - (ev_tstamp)tv.tv_sec) * 1e6);
-
+  memcpy (vec_ro, vec_ri, fd_setsize);
+  memcpy (vec_wo, vec_wi, fd_setsize);
+
+#ifdef _WIN32
+  /* pass in the write set as except set.
+   * the idea behind this is to work around a windows bug that causes
+   * errors to be reported as an exception and not by setting
+   * the writable bit. this is so uncontrollably lame.
+   */
+  memcpy (vec_eo, vec_wi, fd_setsize);
+  res = select (vec_max * NFDBITS, (fd_set *)vec_ro, (fd_set *)vec_wo, (fd_set *)vec_eo, &tv);
+#else
   res = select (vec_max * NFDBITS, (fd_set *)vec_ro, (fd_set *)vec_wo, 0, &tv);
+#endif
 
   if (expect_false (res < 0))
     {
@@ -192,6 +218,9 @@ select_poll (EV_P_ ev_tstamp timeout)
 
           if (FD_ISSET (handle, (fd_set *)vec_ro)) events |= EV_READ;
           if (FD_ISSET (handle, (fd_set *)vec_wo)) events |= EV_WRITE;
+          #ifdef _WIN32
+          if (FD_ISSET (handle, (fd_set *)vec_eo)) events |= EV_WRITE;
+          #endif
 
           if (expect_true (events))
             fd_event (EV_A_ fd, events);
@@ -206,6 +235,9 @@ select_poll (EV_P_ ev_tstamp timeout)
       {
         fd_mask word_r = ((fd_mask *)vec_ro) [word];
         fd_mask word_w = ((fd_mask *)vec_wo) [word];
+        #ifdef _WIN32
+        word_w |= ((fd_mask *)vec_eo) [word];
+        #endif
 
         if (word_r || word_w)
           for (bit = NFDBITS; bit--; )
@@ -238,6 +270,9 @@ select_init (EV_P_ int flags)
   vec_ro  = ev_malloc (sizeof (fd_set));
   vec_wi  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_wi);
   vec_wo  = ev_malloc (sizeof (fd_set));
+  #ifdef _WIN32
+  vec_eo  = ev_malloc (sizeof (fd_set));
+  #endif
 #else
   vec_max = 0;
   vec_ri  = 0; 

data/libev/ev_vars.h

@@ -72,6 +72,9 @@ VARx(void *, vec_ri)
 VARx(void *, vec_ro)
 VARx(void *, vec_wi)
 VARx(void *, vec_wo)
+#if defined(_WIN32) || EV_GENWRAP
+VARx(void *, vec_eo)
+#endif
 VARx(int, vec_max)
 #endif
 

data/libev/ev_win32.c

@@ -39,10 +39,13 @@
 
 #ifdef _WIN32
 
+/* timeb.h is actually xsi legacy functionality */
 #include <sys/timeb.h>
 
 /* note: the comment below could not be substantiated, but what would I care */
 /* MSDN says this is required to handle SIGFPE */
+/* my wild guess would be that using something floating-pointy is required */
+/* for the crt to do something about it */
 volatile double SIGFPE_REQ = 0.0f; 
 
 /* oh, the humanity! */

data/libev/ev_wrap.h

@@ -22,6 +22,7 @@
 #define vec_ro ((loop)->vec_ro)
 #define vec_wi ((loop)->vec_wi)
 #define vec_wo ((loop)->vec_wo)
+#define vec_eo ((loop)->vec_eo)
 #define vec_max ((loop)->vec_max)
 #define polls ((loop)->polls)
 #define pollmax ((loop)->pollmax)
@@ -94,6 +95,7 @@
 #undef vec_ro
 #undef vec_wi
 #undef vec_wo
+#undef vec_eo
 #undef vec_max
 #undef polls
 #undef pollmax

data/libev/event.c

@@ -0,0 +1,403 @@
+/*
+ * libevent compatibility layer
+ *
+ * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ *   1.  Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ * 
+ *   2.  Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#ifndef WIN32
+# include <sys/time.h>
+#endif
+
+#ifdef EV_EVENT_H
+# include EV_EVENT_H
+#else
+# include "event.h"
+#endif
+
+#if EV_MULTIPLICITY
+# define dLOOPev struct ev_loop *loop = (struct ev_loop *)ev->ev_base
+# define dLOOPbase struct ev_loop *loop = (struct ev_loop *)base
+#else
+# define dLOOPev
+# define dLOOPbase
+#endif
+
+/* never accessed, will always be cast from/to ev_loop */
+struct event_base
+{
+  int dummy;
+};
+
+static struct event_base *x_cur;
+
+static void
+tv_set (struct timeval *tv, ev_tstamp at)
+{
+  tv->tv_sec  = (long)at;
+  tv->tv_usec = (long)((at - (ev_tstamp)tv->tv_sec) * 1e6);
+}
+
+static ev_tstamp
+tv_get (struct timeval *tv)
+{
+  if (tv)
+    return tv->tv_sec + tv->tv_usec * 1e-6;
+  else
+    return -1.;
+}
+
+#define EVENT_VERSION(a,b) # a "." # b
+
+const char *event_get_version (void)
+{
+  return EVENT_VERSION (EV_VERSION_MAJOR, EV_VERSION_MINOR);
+}
+
+const char *event_get_method (void)
+{
+  return "libev";
+}
+
+void *event_init (void)
+{
+#if EV_MULTIPLICITY
+  if (x_cur)
+    x_cur = (struct event_base *)ev_loop_new (EVFLAG_AUTO);
+  else
+    x_cur = (struct event_base *)ev_default_loop (EVFLAG_AUTO);
+#else
+  assert (("multiple event bases not supported when not compiled with EV_MULTIPLICITY", !x_cur));
+
+  x_cur = (struct event_base *)(long)ev_default_loop (EVFLAG_AUTO);
+#endif
+
+  return x_cur;
+}
+
+void event_base_free (struct event_base *base)
+{
+  dLOOPbase;
+
+#if EV_MULTIPLICITY
+  if (ev_default_loop (EVFLAG_AUTO) != loop)
+    ev_loop_destroy (loop);
+#endif
+}
+
+int event_dispatch (void)
+{
+  return event_base_dispatch (x_cur);
+}
+
+#ifdef EV_STANDALONE
+void event_set_log_callback (event_log_cb cb)
+{
+  /* nop */
+}
+#endif
+
+int event_loop (int flags)
+{
+  return event_base_loop (x_cur, flags);
+}
+
+int event_loopexit (struct timeval *tv)
+{
+  return event_base_loopexit (x_cur, tv);
+}
+
+static void
+x_cb (struct event *ev, int revents)
+{
+  revents &= EV_READ | EV_WRITE | EV_TIMEOUT | EV_SIGNAL;
+
+  ev->ev_res = revents;
+  ev->ev_callback (ev->ev_fd, (short)revents, ev->ev_arg);
+}
+
+static void
+x_cb_sig (EV_P_ struct ev_signal *w, int revents)
+{
+  struct event *ev = (struct event *)(((char *)w) - offsetof (struct event, iosig.sig));
+
+  if (revents & EV_ERROR)
+    event_del (ev);
+
+  x_cb (ev, revents);
+}
+
+static void
+x_cb_io (EV_P_ struct ev_io *w, int revents)
+{
+  struct event *ev = (struct event *)(((char *)w) - offsetof (struct event, iosig.io));
+
+  if ((revents & EV_ERROR) || !(ev->ev_events & EV_PERSIST))
+    event_del (ev);
+
+  x_cb (ev, revents);
+}
+
+static void
+x_cb_to (EV_P_ struct ev_timer *w, int revents)
+{
+  struct event *ev = (struct event *)(((char *)w) - offsetof (struct event, to));
+
+  event_del (ev);
+
+  x_cb (ev, revents);
+}
+
+void event_set (struct event *ev, int fd, short events, void (*cb)(int, short, void *), void *arg)
+{
+  if (events & EV_SIGNAL)
+    ev_init (&ev->iosig.sig, x_cb_sig);
+  else
+    ev_init (&ev->iosig.io, x_cb_io);
+
+  ev_init (&ev->to, x_cb_to);
+
+  ev->ev_base     = x_cur; /* not threadsafe, but its like libevent works */
+  ev->ev_fd       = fd;
+  ev->ev_events   = events;
+  ev->ev_pri      = 0;
+  ev->ev_callback = cb;
+  ev->ev_arg      = arg;
+  ev->ev_res      = 0;
+  ev->ev_flags    = EVLIST_INIT;
+}
+
+int event_once (int fd, short events, void (*cb)(int, short, void *), void *arg, struct timeval *tv)
+{
+  return event_base_once (x_cur, fd, events, cb, arg, tv);
+}
+
+int event_add (struct event *ev, struct timeval *tv)
+{
+  dLOOPev;
+
+  if (ev->ev_events & EV_SIGNAL)
+    {
+      if (!ev_is_active (&ev->iosig.sig))
+        {
+          ev_signal_set (&ev->iosig.sig, ev->ev_fd);
+          ev_signal_start (EV_A_ &ev->iosig.sig);
+
+          ev->ev_flags |= EVLIST_SIGNAL;
+        }
+    }
+  else if (ev->ev_events & (EV_READ | EV_WRITE))
+    {
+      if (!ev_is_active (&ev->iosig.io))
+        {
+          ev_io_set (&ev->iosig.io, ev->ev_fd, ev->ev_events & (EV_READ | EV_WRITE));
+          ev_io_start (EV_A_ &ev->iosig.io);
+
+          ev->ev_flags |= EVLIST_INSERTED;
+        }
+    }
+
+  if (tv)
+    {
+      ev->to.repeat = tv_get (tv);
+      ev_timer_again (EV_A_ &ev->to);
+      ev->ev_flags |= EVLIST_TIMEOUT;
+    }
+  else
+    {
+      ev_timer_stop (EV_A_ &ev->to);
+      ev->ev_flags &= ~EVLIST_TIMEOUT;
+    }
+
+  ev->ev_flags |= EVLIST_ACTIVE;
+
+  return 0;
+}
+
+int event_del (struct event *ev)
+{
+  dLOOPev;
+
+  if (ev->ev_events & EV_SIGNAL)
+    ev_signal_stop (EV_A_ &ev->iosig.sig);
+  else if (ev->ev_events & (EV_READ | EV_WRITE))
+    ev_io_stop (EV_A_ &ev->iosig.io);
+
+  if (ev_is_active (&ev->to))
+    ev_timer_stop (EV_A_ &ev->to);
+
+  ev->ev_flags = EVLIST_INIT;
+
+  return 0;
+}
+
+void event_active (struct event *ev, int res, short ncalls)
+{
+  dLOOPev;
+
+  if (res & EV_TIMEOUT)
+    ev_feed_event (EV_A_ &ev->to, res & EV_TIMEOUT);
+
+  if (res & EV_SIGNAL)
+    ev_feed_event (EV_A_ &ev->iosig.sig, res & EV_SIGNAL);
+
+  if (res & (EV_READ | EV_WRITE))
+    ev_feed_event (EV_A_ &ev->iosig.io, res & (EV_READ | EV_WRITE));
+}
+
+int event_pending (struct event *ev, short events, struct timeval *tv)
+{
+  short revents = 0;
+  dLOOPev;
+
+  if (ev->ev_events & EV_SIGNAL)
+    {
+      /* sig */
+      if (ev_is_active (&ev->iosig.sig) || ev_is_pending (&ev->iosig.sig))
+        revents |= EV_SIGNAL;
+    }
+  else if (ev->ev_events & (EV_READ | EV_WRITE))
+    {
+      /* io */
+      if (ev_is_active (&ev->iosig.io) || ev_is_pending (&ev->iosig.io))
+        revents |= ev->ev_events & (EV_READ | EV_WRITE);
+    }
+
+  if (ev->ev_events & EV_TIMEOUT || ev_is_active (&ev->to) || ev_is_pending (&ev->to))
+    {
+      revents |= EV_TIMEOUT;
+
+      if (tv)
+        tv_set (tv, ev_now (EV_A)); /* not sure if this is right :) */
+    }
+
+  return events & revents;
+}
+
+int event_priority_init (int npri)
+{
+  return event_base_priority_init (x_cur, npri);
+}
+
+int event_priority_set (struct event *ev, int pri)
+{
+  ev->ev_pri = pri;
+
+  return 0;
+}
+
+int event_base_set (struct event_base *base, struct event *ev)
+{
+  ev->ev_base = base;
+
+  return 0;
+}
+
+int event_base_loop (struct event_base *base, int flags)
+{
+  dLOOPbase;
+
+  ev_loop (EV_A_ flags);
+
+  return 0;
+}
+
+int event_base_dispatch (struct event_base *base)
+{
+  return event_base_loop (base, 0);
+}
+
+static void
+x_loopexit_cb (int revents, void *base)
+{
+  dLOOPbase;
+
+  ev_unloop (EV_A_ EVUNLOOP_ONE);
+}
+
+int event_base_loopexit (struct event_base *base, struct timeval *tv)
+{
+  ev_tstamp after = tv_get (tv);
+  dLOOPbase;
+
+  ev_once (EV_A_ -1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);
+
+  return 0;
+}
+
+struct x_once
+{
+  int fd;
+  void (*cb)(int, short, void *);
+  void *arg;
+};
+
+static void
+x_once_cb (int revents, void *arg)
+{
+  struct x_once *once = (struct x_once *)arg;
+
+  once->cb (once->fd, (short)revents, once->arg);
+  free (once);
+}
+
+int event_base_once (struct event_base *base, int fd, short events, void (*cb)(int, short, void *), void *arg, struct timeval *tv)
+{
+  struct x_once *once = (struct x_once *)malloc (sizeof (struct x_once));
+  dLOOPbase;
+
+  if (!once)
+    return -1;
+
+  once->fd  = fd;
+  once->cb  = cb;
+  once->arg = arg;
+
+  ev_once (EV_A_ fd, events & (EV_READ | EV_WRITE), tv_get (tv), x_once_cb, (void *)once);
+
+  return 0;
+}
+
+int event_base_priority_init (struct event_base *base, int npri)
+{
+  /*dLOOPbase;*/
+
+  return 0;
+}
+