asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/unix/netbsd.c

@@ -32,7 +32,7 @@
 #include <time.h>
 
 #undef NANOSEC
-#define NANOSEC 1000000000
+#define NANOSEC ((uint64_t) 1e9)
 
 
 uint64_t uv_hrtime(void) {

data/ext/asyncengine/libuv/src/unix/openbsd.c

@@ -37,7 +37,7 @@
 #include <unistd.h>
 
 #undef NANOSEC
-#define NANOSEC 1000000000
+#define NANOSEC ((uint64_t) 1e9)
 
 
 static char *process_title;

data/ext/asyncengine/libuv/src/unix/pipe.c

@@ -29,10 +29,14 @@
 #include <unistd.h>
 #include <stdlib.h>
 
+static void uv__pipe_accept(uv_loop_t* loop, uv__io_t* w, int events);
+
 
 int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
   uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
   loop->counters.pipe_init++;
+  handle->shutdown_req = NULL;
+  handle->connect_req = NULL;
   handle->pipe_fname = NULL;
   handle->ipc = ipc;
   return 0;
@@ -77,22 +81,10 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
   uv_strlcpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path));
   saddr.sun_family = AF_UNIX;
 
-  if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr) == -1) {
-    /* On EADDRINUSE:
-     *
-     * We hold the file lock so there is no other process listening
-     * on the socket. Ergo, it's stale - remove it.
-     *
-     * This assumes that the other process uses locking too
-     * but that's a good enough assumption for now.
-     */
-    if (errno != EADDRINUSE
-        || unlink(pipe_fname) == -1
-        || bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr) == -1) {
-      /* Convert ENOENT to EACCES for compatibility with Windows. */
-      uv__set_sys_error(handle->loop, (errno == ENOENT) ? EACCES : errno);
-      goto out;
-    }
+  if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr)) {
+    /* Convert ENOENT to EACCES for compatibility with Windows. */
+    uv__set_sys_error(handle->loop, (errno == ENOENT) ? EACCES : errno);
+    goto out;
   }
   bound = 1;
 
@@ -136,8 +128,11 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
     uv__set_sys_error(handle->loop, errno);
   } else {
     handle->connection_cb = cb;
-    ev_io_init(&handle->read_watcher, uv__pipe_accept, handle->fd, EV_READ);
-    ev_io_start(handle->loop->ev, &handle->read_watcher);
+    uv__io_init(&handle->read_watcher,
+                uv__pipe_accept,
+                handle->fd,
+                UV__IO_READ);
+    uv__io_start(handle->loop, &handle->read_watcher);
   }
 
 out:
@@ -163,7 +158,9 @@ void uv__pipe_close(uv_pipe_t* handle) {
 
 
 void uv_pipe_open(uv_pipe_t* handle, uv_file fd) {
-  uv__stream_open((uv_stream_t*)handle, fd, UV_READABLE | UV_WRITABLE);
+  uv__stream_open((uv_stream_t*)handle,
+                  fd,
+                  UV_STREAM_READABLE | UV_STREAM_WRITABLE);
 }
 
 
@@ -204,24 +201,24 @@ void uv_pipe_connect(uv_connect_t* req,
     goto out;
   }
 
-  uv__stream_open((uv_stream_t*)handle, sockfd, UV_READABLE | UV_WRITABLE);
-
-  ev_io_start(handle->loop->ev, &handle->read_watcher);
-  ev_io_start(handle->loop->ev, &handle->write_watcher);
-
+  uv__stream_open((uv_stream_t*)handle,
+                  sockfd,
+                  UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+  uv__io_start(handle->loop, &handle->read_watcher);
+  uv__io_start(handle->loop, &handle->write_watcher);
   status = 0;
 
 out:
   handle->delayed_error = status; /* Passed to callback. */
   handle->connect_req = req;
+
+  uv__req_init(handle->loop, req, UV_CONNECT);
   req->handle = (uv_stream_t*)handle;
-  req->type = UV_CONNECT;
   req->cb = cb;
   ngx_queue_init(&req->queue);
 
   /* Run callback on next tick. */
-  ev_feed_event(handle->loop->ev, &handle->read_watcher, EV_CUSTOM);
-  assert(ev_is_pending(&handle->read_watcher));
+  uv__io_feed(handle->loop, &handle->write_watcher, UV__IO_WRITE);
 
   /* Mimic the Windows pipe implementation, always
    * return 0 and let the callback handle errors.
@@ -231,30 +228,28 @@ out:
 
 
 /* TODO merge with uv__server_io()? */
-void uv__pipe_accept(EV_P_ ev_io* watcher, int revents) {
-  struct sockaddr_un saddr;
+static void uv__pipe_accept(uv_loop_t* loop, uv__io_t* w, int events) {
   uv_pipe_t* pipe;
   int saved_errno;
   int sockfd;
 
   saved_errno = errno;
-  pipe = watcher->data;
+  pipe = container_of(w, uv_pipe_t, read_watcher);
 
   assert(pipe->type == UV_NAMED_PIPE);
 
-  sockfd = uv__accept(pipe->fd, (struct sockaddr *)&saddr, sizeof saddr);
+  sockfd = uv__accept(pipe->fd);
   if (sockfd == -1) {
-    if (errno == EAGAIN || errno == EWOULDBLOCK) {
-      assert(0 && "EAGAIN on uv__accept(pipefd)");
-    } else {
+    if (errno != EAGAIN && errno != EWOULDBLOCK) {
       uv__set_sys_error(pipe->loop, errno);
+      pipe->connection_cb((uv_stream_t*)pipe, -1);
     }
   } else {
     pipe->accepted_fd = sockfd;
     pipe->connection_cb((uv_stream_t*)pipe, 0);
     if (pipe->accepted_fd == sockfd) {
-      /* The user hasn't yet accepted called uv_accept() */
-      ev_io_stop(pipe->loop->ev, &pipe->read_watcher);
+      /* The user hasn't called uv_accept() yet */
+      uv__io_stop(pipe->loop, &pipe->read_watcher);
     }
   }
 

data/ext/asyncengine/libuv/src/unix/poll.c

@@ -0,0 +1,116 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "uv.h"
+#include "internal.h"
+
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+
+
+static void uv__poll_io(uv_loop_t* loop, uv__io_t* w, int events) {
+  uv_poll_t* handle;
+  int pevents;
+
+  handle = container_of(w, uv_poll_t, io_watcher);
+
+  if (events & UV__IO_ERROR) {
+    /* An error happened. Libev has implicitly stopped the watcher, but we */
+    /* need to fix the refcount. */
+    uv__handle_stop(handle);
+    uv__set_sys_error(handle->loop, EBADF);
+    handle->poll_cb(handle, -1, 0);
+    return;
+  }
+
+  pevents = 0;
+  if (events & UV__IO_READ)
+    pevents |= UV_READABLE;
+  if (events & UV__IO_WRITE)
+    pevents |= UV_WRITABLE;
+
+  handle->poll_cb(handle, 0, pevents);
+}
+
+
+int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {
+  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
+  loop->counters.poll_init++;
+
+  handle->fd = fd;
+  handle->poll_cb = NULL;
+  uv__io_init(&handle->io_watcher, uv__poll_io, fd, 0);
+
+  return 0;
+}
+
+
+int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
+    uv_os_sock_t socket) {
+  return uv_poll_init(loop, handle, socket);
+}
+
+
+static void uv__poll_stop(uv_poll_t* handle) {
+  uv__io_stop(handle->loop, &handle->io_watcher);
+  uv__handle_stop(handle);
+}
+
+
+int uv_poll_stop(uv_poll_t* handle) {
+  assert(!(handle->flags & (UV_CLOSING | UV_CLOSED)));
+  uv__poll_stop(handle);
+  return 0;
+}
+
+
+int uv_poll_start(uv_poll_t* handle, int pevents, uv_poll_cb poll_cb) {
+  int events;
+
+  assert((pevents & ~(UV_READABLE | UV_WRITABLE)) == 0);
+  assert(!(handle->flags & (UV_CLOSING | UV_CLOSED)));
+
+  if (pevents == 0) {
+    uv__poll_stop(handle);
+    return 0;
+  }
+
+  events = 0;
+  if (pevents & UV_READABLE)
+    events |= UV__IO_READ;
+  if (pevents & UV_WRITABLE)
+    events |= UV__IO_WRITE;
+
+  uv__io_stop(handle->loop, &handle->io_watcher);
+  uv__io_set(&handle->io_watcher, uv__poll_io, handle->fd, events);
+  uv__io_start(handle->loop, &handle->io_watcher);
+
+  handle->poll_cb = poll_cb;
+  uv__handle_start(handle);
+
+  return 0;
+}
+
+
+void uv__poll_close(uv_poll_t* handle) {
+  uv__poll_stop(handle);
+}

data/ext/asyncengine/libuv/src/unix/process.c

@@ -25,10 +25,10 @@
 #include <assert.h>
 #include <errno.h>
 #include <sys/wait.h>
-#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK */
 #include <poll.h>
 #include <unistd.h>
 #include <stdio.h>
+#include <fcntl.h>
 
 #ifdef __APPLE__
 # include <TargetConditionals.h>
@@ -68,25 +68,15 @@ static void uv__chld(EV_P_ ev_child* watcher, int revents) {
 
 
 int uv__make_socketpair(int fds[2], int flags) {
-#ifdef SOCK_NONBLOCK
-  int fl;
-
-  fl = SOCK_CLOEXEC;
-
-  if (flags & UV__F_NONBLOCK)
-    fl |= SOCK_NONBLOCK;
-
-  if (socketpair(AF_UNIX, SOCK_STREAM|fl, 0, fds) == 0)
+#if __linux__
+  if (socketpair(AF_UNIX, SOCK_STREAM | UV__SOCK_CLOEXEC | flags, 0, fds) == 0)
     return 0;
 
+  /* Retry on EINVAL, it means SOCK_CLOEXEC is not supported.
+   * Anything else is a genuine error.
+   */
   if (errno != EINVAL)
     return -1;
-
-  /* errno == EINVAL so maybe the kernel headers lied about
-   * the availability of SOCK_NONBLOCK. This can happen if people
-   * build libuv against newer kernel headers than the kernel
-   * they actually run the software on.
-   */
 #endif
 
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
@@ -106,14 +96,7 @@ int uv__make_socketpair(int fds[2], int flags) {
 
 int uv__make_pipe(int fds[2], int flags) {
 #if __linux__
-  int fl;
-
-  fl = O_CLOEXEC;
-
-  if (flags & UV__F_NONBLOCK)
-    fl |= O_NONBLOCK;
-
-  if (uv__pipe2(fds, fl) == 0)
+  if (uv__pipe2(fds, flags | UV__O_CLOEXEC) == 0)
     return 0;
 
   if (errno != ENOSYS)
@@ -139,16 +122,146 @@ int uv__make_pipe(int fds[2], int flags) {
  * Used for initializing stdio streams like options.stdin_stream. Returns
  * zero on success.
  */
-static int uv__process_init_pipe(uv_pipe_t* handle, int fds[2], int flags) {
-  if (handle->type != UV_NAMED_PIPE) {
-    errno = EINVAL;
-    return -1;
+static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2],
+                                  int writable) {
+  int fd = -1;
+  switch (container->flags & (UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD |
+                              UV_INHERIT_STREAM)) {
+    case UV_IGNORE:
+      return 0;
+    case UV_CREATE_PIPE:
+      assert(container->data.stream != NULL);
+
+      if (container->data.stream->type != UV_NAMED_PIPE) {
+        errno = EINVAL;
+        return -1;
+      }
+
+      return uv__make_socketpair(fds, 0);
+    case UV_INHERIT_FD:
+    case UV_INHERIT_STREAM:
+      if (container->flags & UV_INHERIT_FD) {
+        fd = container->data.fd;
+      } else {
+        fd = container->data.stream->fd;
+      }
+
+      if (fd == -1) {
+        errno = EINVAL;
+        return -1;
+      }
+
+      fds[writable ? 1 : 0] = fd;
+
+      return 0;
+    default:
+      assert(0 && "Unexpected flags");
+      return -1;
   }
+}
+
 
-  if (handle->ipc)
-    return uv__make_socketpair(fds, flags);
-  else
-    return uv__make_pipe(fds, flags);
+static int uv__process_stdio_flags(uv_stdio_container_t* container,
+                                   int writable) {
+  if (container->data.stream->type == UV_NAMED_PIPE &&
+      ((uv_pipe_t*)container->data.stream)->ipc) {
+    return UV_STREAM_READABLE | UV_STREAM_WRITABLE;
+  } else if (writable) {
+    return UV_STREAM_WRITABLE;
+  } else {
+    return UV_STREAM_READABLE;
+  }
+}
+
+
+static int uv__process_open_stream(uv_stdio_container_t* container, int fds[2],
+                                   int writable) {
+  int fd = fds[writable ? 1 : 0];
+  int child_fd = fds[writable ? 0 : 1];
+  int flags;
+
+  /* No need to create stream */
+  if (!(container->flags & UV_CREATE_PIPE) || fd < 0) {
+    return 0;
+  }
+
+  assert(child_fd >= 0);
+  close(child_fd);
+
+  uv__nonblock(fd, 1);
+  flags = uv__process_stdio_flags(container, writable);
+
+  return uv__stream_open((uv_stream_t*)container->data.stream, fd, flags);
+}
+
+
+static void uv__process_close_stream(uv_stdio_container_t* container) {
+  if (!(container->flags & UV_CREATE_PIPE)) return;
+
+  uv__stream_close((uv_stream_t*)container->data.stream);
+}
+
+
+static void uv__process_child_init(uv_process_options_t options,
+                                   int stdio_count,
+                                   int* pipes) {
+  int i;
+
+  if (options.flags & UV_PROCESS_DETACHED) {
+    setsid();
+  }
+
+  /* Dup fds */
+  for (i = 0; i < stdio_count; i++) {
+    /*
+     * stdin has swapped ends of pipe
+     * (it's the only one readable stream)
+     */
+    int close_fd = i == 0 ? pipes[i * 2 + 1] : pipes[i * 2];
+    int use_fd = i == 0 ? pipes[i * 2] : pipes[i * 2 + 1];
+
+    if (use_fd >= 0) {
+      close(close_fd);
+    } else if (i < 3) {
+      /* `/dev/null` stdin, stdout, stderr even if they've flag UV_IGNORE */
+      use_fd = open("/dev/null", i == 0 ? O_RDONLY : O_RDWR);
+
+      if (use_fd < 0) {
+        perror("failed to open stdio");
+        _exit(127);
+      }
+    } else {
+      continue;
+    }
+
+    if (i != use_fd) {
+      dup2(use_fd, i);
+      close(use_fd);
+    } else {
+      uv__cloexec(use_fd, 0);
+    }
+  }
+
+  if (options.cwd && chdir(options.cwd)) {
+    perror("chdir()");
+    _exit(127);
+  }
+
+  if ((options.flags & UV_PROCESS_SETGID) && setgid(options.gid)) {
+    perror("setgid()");
+    _exit(127);
+  }
+
+  if ((options.flags & UV_PROCESS_SETUID) && setuid(options.uid)) {
+    perror("setuid()");
+    _exit(127);
+  }
+
+  environ = options.env;
+
+  execvp(options.file, options.args);
+  perror("execvp()");
+  _exit(127);
 }
 
 
@@ -163,35 +276,47 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
    * by the child process.
    */
   char** save_our_env = environ;
-  int stdin_pipe[2] = { -1, -1 };
-  int stdout_pipe[2] = { -1, -1 };
-  int stderr_pipe[2] = { -1, -1 };
+
+  int stdio_count = options.stdio_count < 3 ? 3 : options.stdio_count;
+  int* pipes = malloc(2 * stdio_count * sizeof(int));
+
 #if SPAWN_WAIT_EXEC
   int signal_pipe[2] = { -1, -1 };
   struct pollfd pfd;
 #endif
   int status;
   pid_t pid;
-  int flags;
+  int i;
+
+  if (pipes == NULL) {
+    errno = ENOMEM;
+    goto error;
+  }
+
+  assert(options.file != NULL);
+  assert(!(options.flags & ~(UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS |
+                             UV_PROCESS_DETACHED |
+                             UV_PROCESS_SETGID |
+                             UV_PROCESS_SETUID)));
+
 
   uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
   loop->counters.process_init++;
+  uv__handle_start(process);
 
   process->exit_cb = options.exit_cb;
 
-  if (options.stdin_stream &&
-      uv__process_init_pipe(options.stdin_stream, stdin_pipe, 0)) {
-    goto error;
-  }
-
-  if (options.stdout_stream &&
-      uv__process_init_pipe(options.stdout_stream, stdout_pipe, 0)) {
-    goto error;
+  /* Init pipe pairs */
+  for (i = 0; i < stdio_count; i++) {
+    pipes[i * 2] = -1;
+    pipes[i * 2 + 1] = -1;
   }
 
-  if (options.stderr_stream &&
-      uv__process_init_pipe(options.stderr_stream, stderr_pipe, 0)) {
-    goto error;
+  /* Create socketpairs/pipes, or use raw fd */
+  for (i = 0; i < options.stdio_count; i++) {
+    if (uv__process_init_stdio(&options.stdio[i], pipes + i * 2, i != 0)) {
+      goto error;
+    }
   }
 
   /* This pipe is used by the parent to wait until
@@ -231,43 +356,9 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
   }
 
   if (pid == 0) {
-    if (stdin_pipe[0] >= 0) {
-      close(stdin_pipe[1]);
-      dup2(stdin_pipe[0],  STDIN_FILENO);
-    } else {
-      /* Reset flags that might be set by Node */
-      uv__cloexec(STDIN_FILENO, 0);
-      uv__nonblock(STDIN_FILENO, 0);
-    }
+    /* Child */
+    uv__process_child_init(options, stdio_count, pipes);
 
-    if (stdout_pipe[1] >= 0) {
-      close(stdout_pipe[0]);
-      dup2(stdout_pipe[1], STDOUT_FILENO);
-    } else {
-      /* Reset flags that might be set by Node */
-      uv__cloexec(STDOUT_FILENO, 0);
-      uv__nonblock(STDOUT_FILENO, 0);
-    }
-
-    if (stderr_pipe[1] >= 0) {
-      close(stderr_pipe[0]);
-      dup2(stderr_pipe[1], STDERR_FILENO);
-    } else {
-      /* Reset flags that might be set by Node */
-      uv__cloexec(STDERR_FILENO, 0);
-      uv__nonblock(STDERR_FILENO, 0);
-    }
-
-    if (options.cwd && chdir(options.cwd)) {
-      perror("chdir()");
-      _exit(127);
-    }
-
-    environ = options.env;
-
-    execvp(options.file, options.args);
-    perror("execvp()");
-    _exit(127);
     /* Execution never reaches here. */
   }
 
@@ -297,46 +388,32 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
   ev_child_start(process->loop->ev, &process->child_watcher);
   process->child_watcher.data = process;
 
-  if (stdin_pipe[1] >= 0) {
-    assert(options.stdin_stream);
-    assert(stdin_pipe[0] >= 0);
-    close(stdin_pipe[0]);
-    uv__nonblock(stdin_pipe[1], 1);
-    flags = UV_WRITABLE | (options.stdin_stream->ipc ? UV_READABLE : 0);
-    uv__stream_open((uv_stream_t*)options.stdin_stream, stdin_pipe[1],
-        flags);
-  }
+  for (i = 0; i < options.stdio_count; i++) {
+    if (uv__process_open_stream(&options.stdio[i], pipes + i * 2, i == 0)) {
+      int j;
+      /* Close all opened streams */
+      for (j = 0; j < i; j++) {
+        uv__process_close_stream(&options.stdio[j]);
+      }
 
-  if (stdout_pipe[0] >= 0) {
-    assert(options.stdout_stream);
-    assert(stdout_pipe[1] >= 0);
-    close(stdout_pipe[1]);
-    uv__nonblock(stdout_pipe[0], 1);
-    flags = UV_READABLE | (options.stdout_stream->ipc ? UV_WRITABLE : 0);
-    uv__stream_open((uv_stream_t*)options.stdout_stream, stdout_pipe[0],
-        flags);
+      goto error;
+    }
   }
 
-  if (stderr_pipe[0] >= 0) {
-    assert(options.stderr_stream);
-    assert(stderr_pipe[1] >= 0);
-    close(stderr_pipe[1]);
-    uv__nonblock(stderr_pipe[0], 1);
-    flags = UV_READABLE | (options.stderr_stream->ipc ? UV_WRITABLE : 0);
-    uv__stream_open((uv_stream_t*)options.stderr_stream, stderr_pipe[0],
-        flags);
-  }
+  free(pipes);
 
   return 0;
 
 error:
   uv__set_sys_error(process->loop, errno);
-  close(stdin_pipe[0]);
-  close(stdin_pipe[1]);
-  close(stdout_pipe[0]);
-  close(stdout_pipe[1]);
-  close(stderr_pipe[0]);
-  close(stderr_pipe[1]);
+
+  for (i = 0; i < stdio_count; i++) {
+    close(pipes[i * 2]);
+    close(pipes[i * 2 + 1]);
+  }
+
+  free(pipes);
+
   return -1;
 }
 
@@ -366,4 +443,5 @@ uv_err_t uv_kill(int pid, int signum) {
 
 void uv__process_close(uv_process_t* handle) {
   ev_child_stop(handle->loop->ev, &handle->child_watcher);
+  uv__handle_stop(handle);
 }