rev 0.2.2 → 0.2.3

data/ext/libev/ev.h

@@ -1,7 +1,7 @@
 /*
  * libev native API header
  *
- * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -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
 
@@ -163,9 +167,10 @@ struct ev_loop;
 
 /*
  * struct member types:
- * private: you can look at them, but not change them, and they might not mean anything to you.
- * ro: can be read anytime, but only changed when the watcher isn't active
- * rw: can be read and modified anytime, even when the watcher is active
+ * private: you may look at them, but not change them,
+ *          and they might not mean anything to you.
+ * ro: can be read anytime, but only changed when the watcher isn't active.
+ * rw: can be read and modified anytime, even when the watcher is active.
  *
  * some internal details that might be helpful for debugging:
  *
@@ -174,7 +179,7 @@ struct ev_loop;
  *           or the array index + 1 (most other watchers)
  *           or simply 1 for watchers that aren't in some array.
  * pending is either 0, in which case the watcher isn't,
- *            or the array index + 1 in the pendings array.
+ *           or the array index + 1 in the pendings array.
  */
 
 /* shared by all watchers */
@@ -333,7 +338,7 @@ typedef struct ev_embed
   ev_timer timer;        /* unused */
   ev_periodic periodic;  /* unused */
   ev_idle idle;          /* unused */
-  ev_fork fork;          /* unused */
+  ev_fork fork;          /* private */
 } ev_embed;
 #endif
 
@@ -452,6 +457,7 @@ void ev_loop_fork (EV_P);
 void ev_loop_verify (EV_P);
 
 ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
+void ev_now_update (EV_P);
 
 #else
 
@@ -510,7 +516,7 @@ void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at lea
 void ev_ref   (EV_P);
 void ev_unref (EV_P);
 
-/* convinience function, wait for a single event, without registering an event watcher */
+/* convenience function, wait for a single event, without registering an event watcher */
 /* if timeout is < 0, do wait indefinitely */
 void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg);
 #endif

data/ext/libev/ev_epoll.c

@@ -52,7 +52,9 @@
  *
  * lots of "weird code" and complication handling in this file is due
  * to these design problems with epoll, as we try very hard to avoid
- * epoll_ctl syscalls for common usage patterns.
+ * epoll_ctl syscalls for common usage patterns and handle the breakage
+ * ensuing from receiving events for closed and otherwise long gone
+ * file descriptors.
  */
 
 #include <sys/epoll.h>
@@ -61,17 +63,25 @@ static void
 epoll_modify (EV_P_ int fd, int oev, int nev)
 {
   struct epoll_event ev;
+  unsigned char oldmask;
 
   /*
    * we handle EPOLL_CTL_DEL by ignoring it here
    * on the assumption that the fd is gone anyways
    * if that is wrong, we have to handle the spurious
    * event in epoll_poll.
+   * if the fd is added again, we try to ADD it, and, if that
+   * fails, we assume it still has the same eventmask.
    */
   if (!nev)
     return;
 
-  ev.data.u64 = fd; /* use u64 to fully initialise the struct, for nicer strace etc. */
+  oldmask = anfds [fd].emask;
+  anfds [fd].emask = nev;
+
+  /* store the generation counter in the upper 32 bits, the fd in the lower 32 bits */
+  ev.data.u64 = (uint64_t)(uint32_t)fd
+              | ((uint64_t)(uint32_t)++anfds [fd].egen << 32);
   ev.events   = (nev & EV_READ  ? EPOLLIN  : 0)
               | (nev & EV_WRITE ? EPOLLOUT : 0);
 
@@ -80,21 +90,29 @@ epoll_modify (EV_P_ int fd, int oev, int nev)
 
   if (expect_true (errno == ENOENT))
     {
-      /* on ENOENT the fd went away, so try to do the right thing */
+      /* if ENOENT then the fd went away, so try to do the right thing */
       if (!nev)
-        return;
+        goto dec_egen;
 
       if (!epoll_ctl (backend_fd, EPOLL_CTL_ADD, fd, &ev))
         return;
     }
   else if (expect_true (errno == EEXIST))
     {
-      /* on EEXIST we ignored a previous DEL */
+      /* EEXIST means we ignored a previous DEL, but the fd is still active */
+      /* if the kernel mask is the same as the new mask, we assume it hasn't changed */
+      if (oldmask == nev)
+        goto dec_egen;
+
       if (!epoll_ctl (backend_fd, EPOLL_CTL_MOD, fd, &ev))
         return;
     }
 
   fd_kill (EV_A_ fd);
+
+dec_egen:
+  /* we didn't successfully call epoll_ctl, so decrement the generation counter again */
+  --anfds [fd].egen;
 }
 
 static void
@@ -106,7 +124,7 @@ epoll_poll (EV_P_ ev_tstamp timeout)
   if (expect_false (eventcnt < 0))
     {
       if (errno != EINTR)
-        syserr ("(libev) epoll_wait");
+        ev_syserr ("(libev) epoll_wait");
 
       return;
     }
@@ -115,18 +133,33 @@ epoll_poll (EV_P_ ev_tstamp timeout)
     {
       struct epoll_event *ev = epoll_events + i;
 
-      int fd   = ev->data.u64;
+      int fd = (uint32_t)ev->data.u64; /* mask out the lower 32 bits */
+      int want = anfds [fd].events;
       int got  = (ev->events & (EPOLLOUT | EPOLLERR | EPOLLHUP) ? EV_WRITE : 0)
                | (ev->events & (EPOLLIN  | EPOLLERR | EPOLLHUP) ? EV_READ  : 0);
-      int want = anfds [fd].events;
+
+      /* check for spurious notification */
+      if (expect_false ((uint32_t)anfds [fd].egen != (uint32_t)(ev->data.u64 >> 32)))
+        {
+          /* recreate kernel state */
+          postfork = 1;
+          continue;
+        }
 
       if (expect_false (got & ~want))
         {
+          anfds [fd].emask = want;
+
           /* we received an event but are not interested in it, try mod or del */
+          /* I don't think we ever need MOD, but let's handle it anyways */
           ev->events = (want & EV_READ  ? EPOLLIN  : 0)
                      | (want & EV_WRITE ? EPOLLOUT : 0);
 
-          epoll_ctl (backend_fd, want ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, fd, ev);
+          if (epoll_ctl (backend_fd, want ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, fd, ev))
+            {
+              postfork = 1; /* an error occured, recreate kernel state */
+              continue;
+            }
         }
 
       fd_event (EV_A_ fd, got);
@@ -155,7 +188,7 @@ epoll_init (EV_P_ int flags)
   backend_modify = epoll_modify;
   backend_poll   = epoll_poll;
 
-  epoll_eventmax = 64; /* intiial number of events receivable per poll */
+  epoll_eventmax = 64; /* initial number of events receivable per poll */
   epoll_events = (struct epoll_event *)ev_malloc (sizeof (struct epoll_event) * epoll_eventmax);
 
   return EVBACKEND_EPOLL;
@@ -173,7 +206,7 @@ epoll_fork (EV_P)
   close (backend_fd);
 
   while ((backend_fd = epoll_create (256)) < 0)
-    syserr ("(libev) epoll_create");
+    ev_syserr ("(libev) epoll_create");
 
   fcntl (backend_fd, F_SETFD, FD_CLOEXEC);
 

data/ext/libev/ev_kqueue.c

@@ -101,7 +101,7 @@ kqueue_poll (EV_P_ ev_tstamp timeout)
   if (expect_false (res < 0))
     { 
       if (errno != EINTR)
-        syserr ("(libev) kevent");
+        ev_syserr ("(libev) kevent");
 
       return;
     } 
@@ -184,7 +184,7 @@ kqueue_fork (EV_P)
   close (backend_fd);
 
   while ((backend_fd = kqueue ()) < 0)
-    syserr ("(libev) kqueue");
+    ev_syserr ("(libev) kqueue");
 
   fcntl (backend_fd, F_SETFD, FD_CLOEXEC);
 

data/ext/libev/ev_poll.c

@@ -42,6 +42,8 @@
 void inline_size
 pollidx_init (int *base, int count)
 {
+  /* consider using memset (.., -1, ...), which is pratically guarenteed
+   * to work on all systems implementing poll */
   while (count--)
     *base++ = -1;
 }
@@ -96,7 +98,7 @@ poll_poll (EV_P_ ev_tstamp timeout)
       else if (errno == ENOMEM && !syserr_cb)
         fd_enomem (EV_A);
       else if (errno != EINTR)
-        syserr ("(libev) poll");
+        ev_syserr ("(libev) poll");
     }
   else
     for (p = polls; res; ++p)

data/ext/libev/ev_port.c

@@ -59,7 +59,7 @@ port_associate_and_check (EV_P_ int fd, int ev)
       if (errno == EBADFD)
         fd_kill (EV_A_ fd);
       else
-        syserr ("(libev) port_associate");
+        ev_syserr ("(libev) port_associate");
     }
 }
 
@@ -89,10 +89,10 @@ port_poll (EV_P_ ev_tstamp timeout)
   ts.tv_nsec = (long)(timeout - (ev_tstamp)ts.tv_sec) * 1e9;
   res = port_getn (backend_fd, port_events, port_eventmax, &nget, &ts);
 
-  if (res < 0)
+  if (res == -1)
     { 
       if (errno != EINTR && errno != ETIME)
-        syserr ("(libev) port_getn");
+        ev_syserr ("(libev) port_getn");
 
       return;
     } 
@@ -153,7 +153,7 @@ port_fork (EV_P)
   close (backend_fd);
 
   while ((backend_fd = port_create ()) < 0)
-    syserr ("(libev) port");
+    ev_syserr ("(libev) port");
 
   fcntl (backend_fd, F_SETFD, FD_CLOEXEC);
 

data/ext/libev/ev_select.c

@@ -1,7 +1,7 @@
 /*
  * libev select fd activity backend
  *
- * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -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,26 @@ 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);
+    assert (("libev: fd >= FD_SETSIZE passed to fd_set-based select backend", fd < FD_SETSIZE));
 
-    if (nev & EV_WRITE)
-      FD_SET (handle, (fd_set *)vec_wi);
-    else
-      FD_CLR (handle, (fd_set *)vec_wi);
+    /* 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 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 +113,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 +138,34 @@ 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);
+#elif EV_SELECT_USE_FD_SET
+  fd_setsize = anfdmax < FD_SETSIZE ? anfdmax : FD_SETSIZE;
+  res = select (fd_setsize, (fd_set *)vec_ro, (fd_set *)vec_wo, 0, &tv);
+#else
   res = select (vec_max * NFDBITS, (fd_set *)vec_ro, (fd_set *)vec_wo, 0, &tv);
+#endif
 
   if (expect_false (res < 0))
     {
@@ -153,7 +184,7 @@ select_poll (EV_P_ ev_tstamp timeout)
       #ifdef _WIN32
       /* select on windows errornously returns EINVAL when no fd sets have been
        * provided (this is documented). what microsoft doesn't tell you that this bug
-       * exists even when the fd sets are provided, so we have to check for this bug
+       * exists even when the fd sets _are_ provided, so we have to check for this bug
        * here and emulate by sleeping manually.
        * we also get EINVAL when the timeout is invalid, but we ignore this case here
        * and assume that EINVAL always means: you have to wait manually.
@@ -170,7 +201,7 @@ select_poll (EV_P_ ev_tstamp timeout)
       else if (errno == ENOMEM && !syserr_cb)
         fd_enomem (EV_A);
       else if (errno != EINTR)
-        syserr ("(libev) select");
+        ev_syserr ("(libev) select");
 
       return;
     }
@@ -192,6 +223,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 +240,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--; )
@@ -233,11 +270,13 @@ select_init (EV_P_ int flags)
   backend_poll   = select_poll;
 
 #if EV_SELECT_USE_FD_SET
-  vec_max = FD_SETSIZE / 32;
   vec_ri  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_ri);
   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/ext/libev/ev_vars.h

@@ -65,13 +65,16 @@ VARx(ev_io, pipeev)
 VARx(pid_t, curpid)
 #endif
 
-VARx(int, postfork)  /* true if we need to recreate kernel state after fork */
+VARx(char, postfork)  /* true if we need to recreate kernel state after fork */
 
 #if EV_USE_SELECT || EV_GENWRAP
 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
 
@@ -153,6 +156,7 @@ VARx(int, asynccnt)
 #if EV_USE_INOTIFY || EV_GENWRAP
 VARx(int, fs_fd)
 VARx(ev_io, fs_w)
+VARx(char, fs_2625) /* whether we are running in linux 2.6.25 or newer */
 VAR (fs_hash, ANFS fs_hash [EV_INOTIFY_HASHSIZE])
 #endif
 

data/ext/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! */
@@ -51,6 +54,8 @@ ev_pipe (int filedes [2])
 {
   struct sockaddr_in addr = { 0 };
   int addr_size = sizeof (addr);
+  struct sockaddr_in adr2;
+  int adr2_size;
   SOCKET listener;
   SOCKET sock [2] = { -1, -1 };
 
@@ -64,7 +69,7 @@ ev_pipe (int filedes [2])
   if (bind (listener, (struct sockaddr *)&addr, addr_size))
     goto fail;
 
-  if (getsockname(listener, (struct sockaddr *)&addr, &addr_size))
+  if (getsockname (listener, (struct sockaddr *)&addr, &addr_size))
     goto fail;
 
   if (listen (listener, 1))
@@ -73,10 +78,34 @@ ev_pipe (int filedes [2])
   if ((sock [0] = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
     goto fail;
 
-  if (connect (sock[0], (struct sockaddr *)&addr, addr_size))
+  if (connect (sock [0], (struct sockaddr *)&addr, addr_size))
     goto fail;
 
-  if ((sock[1] = accept (listener, 0, 0)) < 0)
+  if ((sock [1] = accept (listener, 0, 0)) < 0)
+    goto fail;
+
+  /* windows vista returns fantasy port numbers for sockets:
+   * example for two interconnected tcp sockets:
+   *
+   * (Socket::unpack_sockaddr_in getsockname $sock0)[0] == 53364
+   * (Socket::unpack_sockaddr_in getpeername $sock0)[0] == 53363
+   * (Socket::unpack_sockaddr_in getsockname $sock1)[0] == 53363
+   * (Socket::unpack_sockaddr_in getpeername $sock1)[0] == 53365
+   *
+   * wow! tridirectional sockets!
+   *
+   * this way of checking ports seems to work:
+   */
+  if (getpeername (sock [0], (struct sockaddr *)&addr, &addr_size))
+    goto fail;
+
+  if (getsockname (sock [1], (struct sockaddr *)&adr2, &adr2_size))
+    goto fail;
+
+  errno = WSAEINVAL;
+  if (addr_size != adr2_size
+      || addr.sin_addr.s_addr != adr2.sin_addr.s_addr /* just to be sure, I mean, it's windows */
+      || addr.sin_port        != adr2.sin_port)
     goto fail;
 
   closesocket (listener);