rev 0.2.0 → 0.2.1

data/ext/http11_client/http11_parser.rl

@@ -88,7 +88,7 @@
   chunk_extension = (";" chunk_ext_name >start_field %write_field %start_value ("=" chunk_ext_val >start_value)? %write_value )*;
   last_chunk = "0"? chunk_extension :> (CRLF @last_chunk @done);
   chunk_size = xdigit+;
-  chunk = chunk_size >mark %chunk_size chunk_extension :> (CRLF @done);
+  chunk = chunk_size >mark %chunk_size chunk_extension space* :> (CRLF @done);
   Chunked_Header = (chunk | last_chunk);
 
   main := Response | Chunked_Header;

data/ext/libev/Changes

@@ -1,4 +1,42 @@
-Revision history for libev, a high-performance and full-featured event loop
+Revision history for libev, a high-performance and full-featured event loop.
+
+3.31 Wed Apr 16 20:45:04 CEST 2008
+	- added last minute fix for ev_poll.c by Brandon Black.
+
+3.3  Wed Apr 16 19:04:10 CEST 2008
+        - event_base_loopexit should return 0 on success
+          (W.C.A. Wijngaards).
+	- added linux eventfd support.
+        - try to autodetect epoll and inotify support
+          by libc header version if not using autoconf.
+        - new symbols: EV_DEFAULT_UC and EV_DEFAULT_UC_.
+        - declare functions defined in ev.h as inline if
+          C99 or gcc are available.
+        - enable inlining with gcc versions 2 and 3.
+        - work around broken poll implementations potentially
+          not clearing revents field in ev_poll (Brandon Black)
+          (no such systems are known at this time).
+        - work around a bug in realloc on openbsd and darwin,
+          also makes the errornous valgrind complaints
+          go away (noted by various people).
+        - fix ev_async_pending, add c++ wrapper for ev_async
+          (based on patch sent by Johannes Deisenhofer.
+        - add sensible set method to ev::embed.
+        - made integer constants type int in ev.h.
+
+3.2  Wed Apr  2 17:11:19 CEST 2008
+	- fix a 64 bit overflow issue in the select backend,
+          by using fd_mask instead of int for the mask.
+        - rename internal sighandler to avoid clash with very old perls.
+        - entering ev_loop will not clear the ONESHOT or NONBLOCKING
+          flags of any outer loops anymore.
+        - add ev_async_pending.
+
+3.1  Thu Mar 13 13:45:22 CET 2008
+	- implement ev_async watchers.
+        - only initialise signal pipe on demand.
+	- make use of sig_atomic_t configurable.
+        - improved documentation.
 
 3.0  Mon Jan 28 13:14:47 CET 2008
 	- API/ABI bump to version 3.0.

data/ext/libev/ev.c

@@ -1,7 +1,7 @@
 /*
  * libev event processing core, watcher management
  *
- * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * 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-
@@ -41,6 +41,7 @@
 extern "C" {
 #endif
 
+/* this big block deduces configuration from config.h */
 #ifndef EV_STANDALONE
 # ifdef EV_CONFIG_H
 #  include EV_CONFIG_H
@@ -120,6 +121,14 @@ extern "C" {
 #  endif
 # endif
 
+# ifndef EV_USE_EVENTFD
+#  if HAVE_EVENTFD
+#   define EV_USE_EVENTFD 1
+#  else
+#   define EV_USE_EVENTFD 0
+#  endif
+# endif
+   
 #endif
 
 #include <math.h>
@@ -154,7 +163,7 @@ extern "C" {
 # endif
 #endif
 
-/**/
+/* this block tries to deduce configuration from header-defined symbols and defaults */
 
 #ifndef EV_USE_MONOTONIC
 # define EV_USE_MONOTONIC 0
@@ -181,7 +190,11 @@ extern "C" {
 #endif
 
 #ifndef EV_USE_EPOLL
-# define EV_USE_EPOLL 0
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
+#  define EV_USE_EPOLL 1
+# else
+#  define EV_USE_EPOLL 0
+# endif
 #endif
 
 #ifndef EV_USE_KQUEUE
@@ -193,7 +206,11 @@ extern "C" {
 #endif
 
 #ifndef EV_USE_INOTIFY
-# define EV_USE_INOTIFY 0
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
+#  define EV_USE_INOTIFY 1
+# else
+#  define EV_USE_INOTIFY 0
+# endif
 #endif
 
 #ifndef EV_PID_HASHSIZE
@@ -212,7 +229,15 @@ extern "C" {
 # endif
 #endif
 
-/**/
+#ifndef EV_USE_EVENTFD
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
+#  define EV_USE_EVENTFD 1
+# else
+#  define EV_USE_EVENTFD 0
+# endif
+#endif
+
+/* this block fixes any misconfiguration where we know we run into trouble otherwise */
 
 #ifndef CLOCK_MONOTONIC
 # undef EV_USE_MONOTONIC
@@ -243,6 +268,18 @@ extern "C" {
 # include <winsock.h>
 #endif
 
+#if EV_USE_EVENTFD
+/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
+# include <stdint.h>
+# ifdef __cplusplus
+extern "C" {
+# endif
+int eventfd (unsigned int initval, int flags);
+# ifdef __cplusplus
+}
+# endif
+#endif
+
 /**/
 
 /*
@@ -265,7 +302,7 @@ extern "C" {
 #else
 # define expect(expr,value)         (expr)
 # define noinline
-# if __STDC_VERSION__ < 199901L
+# if __STDC_VERSION__ < 199901L && __GNUC__ < 2
 #  define inline
 # endif
 #endif
@@ -293,7 +330,7 @@ typedef ev_watcher_time *WT;
 #if EV_USE_MONOTONIC
 /* sig_atomic_t is used to avoid per-thread variables or locking but still */
 /* giving it a reasonably high chance of working on typical architetcures */
-static sig_atomic_t have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
+static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 #endif
 
 #ifdef _WIN32
@@ -325,7 +362,22 @@ syserr (const char *msg)
     }
 }
 
-static void *(*alloc)(void *ptr, long size);
+static void *
+ev_realloc_emul (void *ptr, long size)
+{
+  /* some systems, notably openbsd and darwin, fail to properly
+   * implement realloc (x, 0) (as required by both ansi c-98 and
+   * the single unix specification, so work around them here.
+   */
+
+  if (size)
+    return realloc (ptr, size);
+
+  free (ptr);
+  return 0;
+}
+
+static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
 
 void
 ev_set_allocator (void *(*cb)(void *ptr, long size))
@@ -336,7 +388,7 @@ ev_set_allocator (void *(*cb)(void *ptr, long size))
 inline_speed void *
 ev_realloc (void *ptr, long size)
 {
-  ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
+  ptr = alloc (ptr, size);
 
   if (!ptr && size)
     {
@@ -453,7 +505,7 @@ ev_sleep (ev_tstamp delay)
 
       nanosleep (&ts, 0);
 #elif defined(_WIN32)
-      Sleep (delay * 1e3);
+      Sleep ((unsigned long)(delay * 1e3));
 #else
       struct timeval tv;
 
@@ -765,15 +817,13 @@ adjustheap (WT *heap, int N, int k)
 typedef struct
 {
   WL head;
-  sig_atomic_t volatile gotsig;
+  EV_ATOMIC_T gotsig;
 } ANSIG;
 
 static ANSIG *signals;
 static int signalmax;
 
-static int sigpipe [2];
-static sig_atomic_t volatile gotsig;
-static ev_io sigev;
+static EV_ATOMIC_T gotsig;
 
 void inline_size
 signals_init (ANSIG *base, int count)
@@ -787,78 +837,148 @@ signals_init (ANSIG *base, int count)
     }
 }
 
-static void
-sighandler (int signum)
+/*****************************************************************************/
+
+void inline_speed
+fd_intern (int fd)
 {
-#if _WIN32
-  signal (signum, sighandler);
+#ifdef _WIN32
+  int arg = 1;
+  ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
+#else
+  fcntl (fd, F_SETFD, FD_CLOEXEC);
+  fcntl (fd, F_SETFL, O_NONBLOCK);
 #endif
+}
 
-  signals [signum - 1].gotsig = 1;
+static void noinline
+evpipe_init (EV_P)
+{
+  if (!ev_is_active (&pipeev))
+    {
+#if EV_USE_EVENTFD
+      if ((evfd = eventfd (0, 0)) >= 0)
+        {
+          evpipe [0] = -1;
+          fd_intern (evfd);
+          ev_io_set (&pipeev, evfd, EV_READ);
+        }
+      else
+#endif
+        {
+          while (pipe (evpipe))
+            syserr ("(libev) error creating signal/async pipe");
 
-  if (!gotsig)
+          fd_intern (evpipe [0]);
+          fd_intern (evpipe [1]);
+          ev_io_set (&pipeev, evpipe [0], EV_READ);
+        }
+
+      ev_io_start (EV_A_ &pipeev);
+      ev_unref (EV_A); /* watcher should not keep loop alive */
+    }
+}
+
+void inline_size
+evpipe_write (EV_P_ EV_ATOMIC_T *flag)
+{
+  if (!*flag)
     {
-      int old_errno = errno;
-      gotsig = 1;
-      write (sigpipe [1], &signum, 1);
+      int old_errno = errno; /* save errno because write might clobber it */
+
+      *flag = 1;
+
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        {
+          uint64_t counter = 1;
+          write (evfd, &counter, sizeof (uint64_t));
+        }
+      else
+#endif
+        write (evpipe [1], &old_errno, 1);
+
       errno = old_errno;
     }
 }
 
-void noinline
-ev_feed_signal_event (EV_P_ int signum)
+static void
+pipecb (EV_P_ ev_io *iow, int revents)
 {
-  WL w;
-
-#if EV_MULTIPLICITY
-  assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
+#if EV_USE_EVENTFD
+  if (evfd >= 0)
+    {
+      uint64_t counter = 1;
+      read (evfd, &counter, sizeof (uint64_t));
+    }
+  else
 #endif
+    {
+      char dummy;
+      read (evpipe [0], &dummy, 1);
+    }
 
-  --signum;
+  if (gotsig && ev_is_default_loop (EV_A))
+    {    
+      int signum;
+      gotsig = 0;
 
-  if (signum < 0 || signum >= signalmax)
-    return;
+      for (signum = signalmax; signum--; )
+        if (signals [signum].gotsig)
+          ev_feed_signal_event (EV_A_ signum + 1);
+    }
 
-  signals [signum].gotsig = 0;
+#if EV_ASYNC_ENABLE
+  if (gotasync)
+    {
+      int i;
+      gotasync = 0;
 
-  for (w = signals [signum].head; w; w = w->next)
-    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
+      for (i = asynccnt; i--; )
+        if (asyncs [i]->sent)
+          {
+            asyncs [i]->sent = 0;
+            ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
+          }
+    }
+#endif
 }
 
+/*****************************************************************************/
+
 static void
-sigcb (EV_P_ ev_io *iow, int revents)
+ev_sighandler (int signum)
 {
-  int signum;
+#if EV_MULTIPLICITY
+  struct ev_loop *loop = &default_loop_struct;
+#endif
 
-  read (sigpipe [0], &revents, 1);
-  gotsig = 0;
+#if _WIN32
+  signal (signum, ev_sighandler);
+#endif
 
-  for (signum = signalmax; signum--; )
-    if (signals [signum].gotsig)
-      ev_feed_signal_event (EV_A_ signum + 1);
+  signals [signum - 1].gotsig = 1;
+  evpipe_write (EV_A_ &gotsig);
 }
 
-void inline_speed
-fd_intern (int fd)
+void noinline
+ev_feed_signal_event (EV_P_ int signum)
 {
-#ifdef _WIN32
-  int arg = 1;
-  ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
-#else
-  fcntl (fd, F_SETFD, FD_CLOEXEC);
-  fcntl (fd, F_SETFL, O_NONBLOCK);
+  WL w;
+
+#if EV_MULTIPLICITY
+  assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
 #endif
-}
 
-static void noinline
-siginit (EV_P)
-{
-  fd_intern (sigpipe [0]);
-  fd_intern (sigpipe [1]);
+  --signum;
 
-  ev_io_set (&sigev, sigpipe [0], EV_READ);
-  ev_io_start (EV_A_ &sigev);
-  ev_unref (EV_A); /* child watcher should not keep loop alive */
+  if (signum < 0 || signum >= signalmax)
+    return;
+
+  signals [signum].gotsig = 0;
+
+  for (w = signals [signum].head; w; w = w->next)
+    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 }
 
 /*****************************************************************************/
@@ -874,7 +994,7 @@ static ev_signal childev;
 #endif
 
 void inline_speed
-child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
+child_reap (EV_P_ int chain, int pid, int status)
 {
   ev_child *w;
   int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
@@ -884,7 +1004,7 @@ child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
       if ((w->pid == pid || !w->pid)
           && (!traced || (w->flags & 1)))
         {
-          ev_set_priority (w, ev_priority (sw)); /* need to do it *now* */
+          ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
           w->rpid    = pid;
           w->rstatus = status;
           ev_feed_event (EV_A_ (W)w, EV_CHILD);
@@ -908,13 +1028,13 @@ childcb (EV_P_ ev_signal *sw, int revents)
         || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
       return;
 
-  /* make sure we are called again until all childs have been reaped */
+  /* make sure we are called again until all children have been reaped */
   /* we need to do it this way so that the callback gets called before we continue */
   ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 
-  child_reap (EV_A_ sw, pid, pid, status);
+  child_reap (EV_A_ pid, pid, status);
   if (EV_PID_HASHSIZE > 1)
-    child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
+    child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
 }
 
 #endif
@@ -1042,13 +1162,19 @@ loop_init (EV_P_ unsigned int flags)
       }
 #endif
 
-      ev_rt_now = ev_time ();
-      mn_now    = get_clock ();
-      now_floor = mn_now;
-      rtmn_diff = ev_rt_now - mn_now;
+      ev_rt_now         = ev_time ();
+      mn_now            = get_clock ();
+      now_floor         = mn_now;
+      rtmn_diff         = ev_rt_now - mn_now;
 
       io_blocktime      = 0.;
       timeout_blocktime = 0.;
+      backend           = 0;
+      backend_fd        = -1;
+      gotasync          = 0;
+#if EV_USE_INOTIFY
+      fs_fd             = -2;
+#endif
 
       /* pid check not overridable via env */
 #ifndef _WIN32
@@ -1061,15 +1187,9 @@ loop_init (EV_P_ unsigned int flags)
           && getenv ("LIBEV_FLAGS"))
         flags = atoi (getenv ("LIBEV_FLAGS"));
 
-      if (!(flags & 0x0000ffffUL))
+      if (!(flags & 0x0000ffffU))
         flags |= ev_recommended_backends ();
 
-      backend = 0;
-      backend_fd = -1;
-#if EV_USE_INOTIFY
-      fs_fd = -2;
-#endif
-
 #if EV_USE_PORT
       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
 #endif
@@ -1086,8 +1206,8 @@ loop_init (EV_P_ unsigned int flags)
       if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
 #endif
 
-      ev_init (&sigev, sigcb);
-      ev_set_priority (&sigev, EV_MAXPRI);
+      ev_init (&pipeev, pipecb);
+      ev_set_priority (&pipeev, EV_MAXPRI);
     }
 }
 
@@ -1096,6 +1216,23 @@ loop_destroy (EV_P)
 {
   int i;
 
+  if (ev_is_active (&pipeev))
+    {
+      ev_ref (EV_A); /* signal watcher */
+      ev_io_stop (EV_A_ &pipeev);
+
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        close (evfd);
+#endif
+
+      if (evpipe [0] >= 0)
+        {
+          close (evpipe [0]);
+          close (evpipe [1]);
+        }
+    }
+
 #if EV_USE_INOTIFY
   if (fs_fd >= 0)
     close (fs_fd);
@@ -1141,6 +1278,9 @@ loop_destroy (EV_P)
 #endif
   array_free (prepare, EMPTY);
   array_free (check, EMPTY);
+#if EV_ASYNC_ENABLE
+  array_free (async, EMPTY);
+#endif
 
   backend = 0;
 }
@@ -1163,20 +1303,32 @@ loop_fork (EV_P)
   infy_fork (EV_A);
 #endif
 
-  if (ev_is_active (&sigev))
+  if (ev_is_active (&pipeev))
     {
-      /* default loop */
+      /* this "locks" the handlers against writing to the pipe */
+      /* while we modify the fd vars */
+      gotsig = 1;
+#if EV_ASYNC_ENABLE
+      gotasync = 1;
+#endif
 
       ev_ref (EV_A);
-      ev_io_stop (EV_A_ &sigev);
-      close (sigpipe [0]);
-      close (sigpipe [1]);
+      ev_io_stop (EV_A_ &pipeev);
+
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        close (evfd);
+#endif
 
-      while (pipe (sigpipe))
-        syserr ("(libev) error creating pipe");
+      if (evpipe [0] >= 0)
+        {
+          close (evpipe [0]);
+          close (evpipe [1]);
+        }
 
-      siginit (EV_A);
-      sigcb (EV_A_ &sigev, EV_READ);
+      evpipe_init (EV_A);
+      /* now iterate over everything, in case we missed something */
+      pipecb (EV_A_ &pipeev, EV_READ);
     }
 
   postfork = 0;
@@ -1221,10 +1373,6 @@ int
 ev_default_loop (unsigned int flags)
 #endif
 {
-  if (sigpipe [0] == sigpipe [1])
-    if (pipe (sigpipe))
-      return 0;
-
   if (!ev_default_loop_ptr)
     {
 #if EV_MULTIPLICITY
@@ -1237,8 +1385,6 @@ ev_default_loop (unsigned int flags)
 
       if (ev_backend (EV_A))
         {
-          siginit (EV_A);
-
 #ifndef _WIN32
           ev_signal_init (&childev, childcb, SIGCHLD);
           ev_set_priority (&childev, EV_MAXPRI);
@@ -1265,12 +1411,6 @@ ev_default_destroy (void)
   ev_signal_stop (EV_A_ &childev);
 #endif
 
-  ev_ref (EV_A); /* signal watcher */
-  ev_io_stop (EV_A_ &sigev);
-
-  close (sigpipe [0]); sigpipe [0] = 0;
-  close (sigpipe [1]); sigpipe [1] = 0;
-
   loop_destroy (EV_A);
 }
 
@@ -1501,9 +1641,7 @@ static int loop_done;
 void
 ev_loop (EV_P_ int flags)
 {
-  loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)
-            ? EVUNLOOP_ONE
-            : EVUNLOOP_CANCEL;
+  loop_done = EVUNLOOP_CANCEL;
 
   call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */
 
@@ -1609,9 +1747,12 @@ ev_loop (EV_P_ int flags)
         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
 
       call_pending (EV_A);
-
     }
-  while (expect_true (activecnt && !loop_done));
+  while (expect_true (
+    activecnt
+    && !loop_done
+    && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
+  ));
 
   if (loop_done == EVUNLOOP_ONE)
     loop_done = EVUNLOOP_CANCEL;
@@ -1867,6 +2008,8 @@ ev_signal_start (EV_P_ ev_signal *w)
 
   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
 
+  evpipe_init (EV_A);
+
   {
 #ifndef _WIN32
     sigset_t full, prev;
@@ -1887,10 +2030,10 @@ ev_signal_start (EV_P_ ev_signal *w)
   if (!((WL)w)->next)
     {
 #if _WIN32
-      signal (w->signum, sighandler);
+      signal (w->signum, ev_sighandler);
 #else
       struct sigaction sa;
-      sa.sa_handler = sighandler;
+      sa.sa_handler = ev_sighandler;
       sigfillset (&sa.sa_mask);
       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
       sigaction (w->signum, &sa, 0);
@@ -2389,6 +2532,44 @@ ev_fork_stop (EV_P_ ev_fork *w)
 }
 #endif
 
+#if EV_ASYNC_ENABLE
+void
+ev_async_start (EV_P_ ev_async *w)
+{
+  if (expect_false (ev_is_active (w)))
+    return;
+
+  evpipe_init (EV_A);
+
+  ev_start (EV_A_ (W)w, ++asynccnt);
+  array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
+  asyncs [asynccnt - 1] = w;
+}
+
+void
+ev_async_stop (EV_P_ ev_async *w)
+{
+  clear_pending (EV_A_ (W)w);
+  if (expect_false (!ev_is_active (w)))
+    return;
+
+  {
+    int active = ((W)w)->active;
+    asyncs [active - 1] = asyncs [--asynccnt];
+    ((W)asyncs [active - 1])->active = active;
+  }
+
+  ev_stop (EV_A_ (W)w);
+}
+
+void
+ev_async_send (EV_P_ ev_async *w)
+{
+  w->sent = 1;
+  evpipe_write (EV_A_ &gotasync);
+}
+#endif
+
 /*****************************************************************************/
 
 struct ev_once