noderb 0.0.4 → 0.0.6

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

@@ -0,0 +1,282 @@
+/* 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 <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle) {
+  memset(handle, 0, sizeof *handle);
+
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_NAMED_PIPE);
+  loop->counters.pipe_init++;
+
+  handle->type = UV_NAMED_PIPE;
+  handle->pipe_fname = NULL; /* Only set by listener. */
+
+  ev_init(&handle->write_watcher, uv__stream_io);
+  ev_init(&handle->read_watcher, uv__stream_io);
+  handle->write_watcher.data = handle;
+  handle->read_watcher.data = handle;
+  handle->accepted_fd = -1;
+  handle->fd = -1;
+
+  ngx_queue_init(&handle->write_completed_queue);
+  ngx_queue_init(&handle->write_queue);
+
+  return 0;
+}
+
+
+int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
+  struct sockaddr_un sun;
+  const char* pipe_fname;
+  int saved_errno;
+  int sockfd;
+  int status;
+  int bound;
+
+  saved_errno = errno;
+  pipe_fname = NULL;
+  sockfd = -1;
+  status = -1;
+  bound = 0;
+
+  /* Already bound? */
+  if (handle->fd >= 0) {
+    uv_err_new_artificial(handle->loop, UV_EINVAL);
+    goto out;
+  }
+
+  /* Make a copy of the file name, it outlives this function's scope. */
+  if ((pipe_fname = strdup(name)) == NULL) {
+    uv_err_new(handle->loop, ENOMEM);
+    goto out;
+  }
+
+  /* We've got a copy, don't touch the original any more. */
+  name = NULL;
+
+  if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+    uv_err_new(handle->loop, errno);
+    goto out;
+  }
+
+  memset(&sun, 0, sizeof sun);
+  uv__strlcpy(sun.sun_path, pipe_fname, sizeof(sun.sun_path));
+  sun.sun_family = AF_UNIX;
+
+  if (bind(sockfd, (struct sockaddr*)&sun, sizeof sun) == -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*)&sun, sizeof sun) == -1) {
+      /* Convert ENOENT to EACCES for compatibility with Windows. */
+      uv_err_new(handle->loop, (errno == ENOENT) ? EACCES : errno);
+      goto out;
+    }
+  }
+  bound = 1;
+
+  /* Success. */
+  handle->pipe_fname = pipe_fname; /* Is a strdup'ed copy. */
+  handle->fd = sockfd;
+  status = 0;
+
+out:
+  /* Clean up on error. */
+  if (status) {
+    if (bound) {
+      /* unlink() before close() to avoid races. */
+      assert(pipe_fname != NULL);
+      unlink(pipe_fname);
+    }
+    uv__close(sockfd);
+
+    free((void*)pipe_fname);
+  }
+
+  errno = saved_errno;
+  return status;
+}
+
+
+int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
+  int saved_errno;
+  int status;
+
+  saved_errno = errno;
+  status = -1;
+
+  if (handle->fd == -1) {
+    uv_err_new_artificial(handle->loop, UV_EINVAL);
+    goto out;
+  }
+  assert(handle->fd >= 0);
+
+  if ((status = listen(handle->fd, backlog)) == -1) {
+    uv_err_new(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);
+  }
+
+out:
+  errno = saved_errno;
+  return status;
+}
+
+
+int uv_pipe_cleanup(uv_pipe_t* handle) {
+  int saved_errno;
+  int status;
+
+  saved_errno = errno;
+  status = -1;
+
+  if (handle->pipe_fname) {
+    /*
+     * Unlink the file system entity before closing the file descriptor.
+     * Doing it the other way around introduces a race where our process
+     * unlinks a socket with the same name that's just been created by
+     * another thread or process.
+     *
+     * This is less of an issue now that we attach a file lock
+     * to the socket but it's still a best practice.
+     */
+    unlink(handle->pipe_fname);
+    free((void*)handle->pipe_fname);
+  }
+
+  errno = saved_errno;
+  return status;
+}
+
+
+int uv_pipe_connect(uv_connect_t* req,
+                    uv_pipe_t* handle,
+                    const char* name,
+                    uv_connect_cb cb) {
+  struct sockaddr_un sun;
+  int saved_errno;
+  int sockfd;
+  int status;
+  int r;
+
+  saved_errno = errno;
+  sockfd = -1;
+  status = -1;
+
+  if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+    uv_err_new(handle->loop, errno);
+    goto out;
+  }
+
+  memset(&sun, 0, sizeof sun);
+  uv__strlcpy(sun.sun_path, name, sizeof(sun.sun_path));
+  sun.sun_family = AF_UNIX;
+
+  /* We don't check for EINPROGRESS. Think about it: the socket
+   * is either there or not.
+   */
+  do {
+    r = connect(sockfd, (struct sockaddr*)&sun, sizeof sun);
+  }
+  while (r == -1 && errno == EINTR);
+
+  if (r == -1) {
+    uv_err_new(handle->loop, errno);
+    uv__close(sockfd);
+    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);
+
+  status = 0;
+
+out:
+  handle->delayed_error = status; /* Passed to callback. */
+  handle->connect_req = req;
+  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));
+
+  /* Mimic the Windows pipe implementation, always
+   * return 0 and let the callback handle errors.
+   */
+  errno = saved_errno;
+  return 0;
+}
+
+
+/* TODO merge with uv__server_io()? */
+void uv__pipe_accept(EV_P_ ev_io* watcher, int revents) {
+  struct sockaddr_un sun;
+  uv_pipe_t* pipe;
+  int saved_errno;
+  int sockfd;
+
+  saved_errno = errno;
+  pipe = watcher->data;
+
+  assert(pipe->type == UV_NAMED_PIPE);
+  assert(pipe->pipe_fname != NULL);
+
+  sockfd = uv__accept(pipe->fd, (struct sockaddr *)&sun, sizeof sun);
+  if (sockfd == -1) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      assert(0 && "EAGAIN on uv__accept(pipefd)");
+    } else {
+      uv_err_new(pipe->loop, errno);
+    }
+  } 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);
+    }
+  }
+
+  errno = saved_errno;
+}

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

@@ -0,0 +1,287 @@
+
+/* 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 <assert.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <poll.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#ifdef __APPLE__
+# include <crt_externs.h>
+# define environ (*_NSGetEnviron())
+#else
+extern char **environ;
+#endif
+
+
+static void uv__chld(EV_P_ ev_child* watcher, int revents) {
+  int status = watcher->rstatus;
+  int exit_status = 0;
+  int term_signal = 0;
+  uv_process_t *process = watcher->data;
+
+  assert(&process->child_watcher == watcher);
+  assert(revents & EV_CHILD);
+
+  ev_child_stop(EV_A_ &process->child_watcher);
+
+  if (WIFEXITED(status)) {
+    exit_status = WEXITSTATUS(status);
+  }
+
+  if (WIFSIGNALED(status)) {
+    term_signal = WTERMSIG(status);
+  }
+
+  if (process->exit_cb) {
+    process->exit_cb(process, exit_status, term_signal);
+  }
+}
+
+#ifndef SPAWN_WAIT_EXEC
+# define SPAWN_WAIT_EXEC 1
+#endif
+
+int uv_spawn(uv_loop_t* loop, uv_process_t* process,
+    uv_process_options_t options) {
+  /*
+   * Save environ in the case that we get it clobbered
+   * 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 };
+#if SPAWN_WAIT_EXEC
+  int signal_pipe[2] = { -1, -1 };
+  struct pollfd pfd;
+#endif
+  int status;
+  pid_t pid;
+
+  uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
+  loop->counters.process_init++;
+
+  process->exit_cb = options.exit_cb;
+
+  if (options.stdin_stream) {
+    if (options.stdin_stream->type != UV_NAMED_PIPE) {
+      errno = EINVAL;
+      goto error;
+    }
+
+    if (pipe(stdin_pipe) < 0) {
+      goto error;
+    }
+    uv__cloexec(stdin_pipe[0], 1);
+    uv__cloexec(stdin_pipe[1], 1);
+  }
+
+  if (options.stdout_stream) {
+    if (options.stdout_stream->type != UV_NAMED_PIPE) {
+      errno = EINVAL;
+      goto error;
+    }
+
+    if (pipe(stdout_pipe) < 0) {
+      goto error;
+    }
+    uv__cloexec(stdout_pipe[0], 1);
+    uv__cloexec(stdout_pipe[1], 1);
+  }
+
+  if (options.stderr_stream) {
+    if (options.stderr_stream->type != UV_NAMED_PIPE) {
+      errno = EINVAL;
+      goto error;
+    }
+
+    if (pipe(stderr_pipe) < 0) {
+      goto error;
+    }
+    uv__cloexec(stderr_pipe[0], 1);
+    uv__cloexec(stderr_pipe[1], 1);
+  }
+
+  /* This pipe is used by the parent to wait until
+   * the child has called `execve()`. We need this
+   * to avoid the following race condition:
+   *
+   *    if ((pid = fork()) > 0) {
+   *      kill(pid, SIGTERM);
+   *    }
+   *    else if (pid == 0) {
+   *      execve("/bin/cat", argp, envp);
+   *    }
+   *
+   * The parent sends a signal immediately after forking.
+   * Since the child may not have called `execve()` yet,
+   * there is no telling what process receives the signal,
+   * our fork or /bin/cat.
+   *
+   * To avoid ambiguity, we create a pipe with both ends
+   * marked close-on-exec. Then, after the call to `fork()`,
+   * the parent polls the read end until it sees POLLHUP.
+   */
+#if SPAWN_WAIT_EXEC
+# ifdef HAVE_PIPE2
+  if (pipe2(signal_pipe, O_CLOEXEC | O_NONBLOCK) < 0) {
+    goto error;
+  }
+# else
+  if (pipe(signal_pipe) < 0) {
+    goto error;
+  }
+  uv__cloexec(signal_pipe[0], 1);
+  uv__cloexec(signal_pipe[1], 1);
+  uv__nonblock(signal_pipe[0], 1);
+  uv__nonblock(signal_pipe[1], 1);
+# endif
+#endif
+
+  pid = fork();
+
+  if (pid == -1) {
+#if SPAWN_WAIT_EXEC
+    uv__close(signal_pipe[0]);
+    uv__close(signal_pipe[1]);
+#endif
+    environ = save_our_env;
+    goto error;
+  }
+
+  if (pid == 0) {
+    if (stdin_pipe[0] >= 0) {
+      uv__close(stdin_pipe[1]);
+      dup2(stdin_pipe[0],  STDIN_FILENO);
+    }
+
+    if (stdout_pipe[1] >= 0) {
+      uv__close(stdout_pipe[0]);
+      dup2(stdout_pipe[1], STDOUT_FILENO);
+    }
+
+    if (stderr_pipe[1] >= 0) {
+      uv__close(stderr_pipe[0]);
+      dup2(stderr_pipe[1], STDERR_FILENO);
+    }
+
+    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. */
+  }
+
+  /* Parent. */
+
+  /* Restore environment. */
+  environ = save_our_env;
+
+#if SPAWN_WAIT_EXEC
+  /* POLLHUP signals child has exited or execve()'d. */
+  uv__close(signal_pipe[1]);
+  do {
+    pfd.fd = signal_pipe[0];
+    pfd.events = POLLIN|POLLHUP;
+    pfd.revents = 0;
+    errno = 0, status = poll(&pfd, 1, -1);
+  }
+  while (status == -1 && (errno == EINTR || errno == ENOMEM));
+
+  uv__close(signal_pipe[0]);
+  uv__close(signal_pipe[1]);
+
+  assert((status == 1)
+      && "poll() on pipe read end failed");
+  assert((pfd.revents & POLLHUP) == POLLHUP
+      && "no POLLHUP on pipe read end");
+#endif
+
+  process->pid = pid;
+
+  ev_child_init(&process->child_watcher, uv__chld, pid, 0);
+  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);
+    uv__close(stdin_pipe[0]);
+    uv__nonblock(stdin_pipe[1], 1);
+    uv__stream_open((uv_stream_t*)options.stdin_stream, stdin_pipe[1],
+        UV_WRITABLE);
+  }
+
+  if (stdout_pipe[0] >= 0) {
+    assert(options.stdout_stream);
+    assert(stdout_pipe[1] >= 0);
+    uv__close(stdout_pipe[1]);
+    uv__nonblock(stdout_pipe[0], 1);
+    uv__stream_open((uv_stream_t*)options.stdout_stream, stdout_pipe[0],
+        UV_READABLE);
+  }
+
+  if (stderr_pipe[0] >= 0) {
+    assert(options.stderr_stream);
+    assert(stderr_pipe[1] >= 0);
+    uv__close(stderr_pipe[1]);
+    uv__nonblock(stderr_pipe[0], 1);
+    uv__stream_open((uv_stream_t*)options.stderr_stream, stderr_pipe[0],
+        UV_READABLE);
+  }
+
+  return 0;
+
+error:
+  uv_err_new(process->loop, errno);
+  uv__close(stdin_pipe[0]);
+  uv__close(stdin_pipe[1]);
+  uv__close(stdout_pipe[0]);
+  uv__close(stdout_pipe[1]);
+  uv__close(stderr_pipe[0]);
+  uv__close(stderr_pipe[1]);
+  return -1;
+}
+
+
+int uv_process_kill(uv_process_t* process, int signum) {
+  int r = kill(process->pid, signum);
+
+  if (r) {
+    uv_err_new(process->loop, errno);
+    return -1;
+  } else {
+    return 0;
+  }
+}