noderb 0.0.8 → 0.0.9

data/ext/noderb_extension/libuv/src/unix/internal.h

@@ -25,6 +25,32 @@
 #include "uv-common.h"
 #include "uv-eio.h"
 
+#if defined(__linux__)
+
+#include <linux/version.h>
+#include <features.h>
+
+#undef HAVE_FUTIMES
+#undef HAVE_PIPE2
+#undef HAVE_ACCEPT4
+
+/* futimes() requires linux >= 2.6.22 and glib >= 2.6 */
+#if LINUX_VERSION_CODE >= 0x20616 && __GLIBC_PREREQ(2, 6)
+#define HAVE_FUTIMES
+#endif
+
+/* pipe2() requires linux >= 2.6.27 and glibc >= 2.9 */
+#if LINUX_VERSION_CODE >= 0x2061B && __GLIBC_PREREQ(2, 9)
+#define HAVE_PIPE2
+#endif
+
+/* accept4() requires linux >= 2.6.28 and glib >= 2.10 */
+#if LINUX_VERSION_CODE >= 0x2061C && __GLIBC_PREREQ(2, 10)
+#define HAVE_ACCEPT4
+#endif
+
+#endif /* __linux__ */
+
 /* flags */
 enum {
   UV_CLOSING  = 0x00000001, /* uv_close() called but not finished. */
@@ -48,12 +74,16 @@ int uv__cloexec(int fd, int set) __attribute__((unused));
 int uv__socket(int domain, int type, int protocol);
 
 /* error */
+uv_err_code uv_translate_sys_error(int sys_errno);
 uv_err_t uv_err_new(uv_loop_t* loop, int sys_error);
 uv_err_t uv_err_new_artificial(uv_loop_t* loop, int code);
 void uv_fatal_error(const int errorno, const char* syscall);
 
 /* stream */
+void uv__stream_init(uv_loop_t* loop, uv_stream_t* stream,
+    uv_handle_type type);
 int uv__stream_open(uv_stream_t*, int fd, int flags);
+void uv__stream_destroy(uv_stream_t* stream);
 void uv__stream_io(EV_P_ ev_io* watcher, int revents);
 void uv__server_io(EV_P_ ev_io* watcher, int revents);
 int uv__accept(int sockfd, struct sockaddr* saddr, socklen_t len);

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

@@ -0,0 +1,68 @@
+/* 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 <string.h>
+#include <time.h>
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+#include <unistd.h>
+
+#undef NANOSEC
+#define NANOSEC 1000000000
+
+uint64_t uv_hrtime(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (ts.tv_sec * NANOSEC + ts.tv_nsec);
+}
+
+
+int uv_exepath(char* buffer, size_t* size) {
+  uint32_t usize;
+  int result;
+  char* path;
+  char* fullpath;
+  int mib[4];
+  size_t cb;
+  pid_t mypid;
+
+  if (!buffer || !size) {
+    return -1;
+  }
+
+  mypid = getpid();
+  mib[0] = CTL_KERN;
+  mib[1] = KERN_PROC_ARGS;
+  mib[2] = mypid;
+  mib[3] = KERN_PROC_ARGV;
+
+  cb = *size;
+  if (sysctl(mib, 4, buffer, &cb, NULL, 0) < 0) {
+    *size = 0;
+    return -1;
+  }
+  *size = strlen(buffer);
+
+  return 0;
+}

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

@@ -30,30 +30,15 @@
 #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);
+  uv__stream_init(loop, (uv_stream_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);
-
+  handle->pipe_fname = NULL;
   return 0;
 }
 
 
 int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
-  struct sockaddr_un sun;
+  struct sockaddr_un saddr;
   const char* pipe_fname;
   int saved_errno;
   int sockfd;
@@ -86,11 +71,11 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
     goto out;
   }
 
-  memset(&sun, 0, sizeof sun);
-  uv__strlcpy(sun.sun_path, pipe_fname, sizeof(sun.sun_path));
-  sun.sun_family = AF_UNIX;
+  memset(&saddr, 0, sizeof saddr);
+  uv__strlcpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path));
+  saddr.sun_family = AF_UNIX;
 
-  if (bind(sockfd, (struct sockaddr*)&sun, sizeof sun) == -1) {
+  if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr) == -1) {
     /* On EADDRINUSE:
      *
      * We hold the file lock so there is no other process listening
@@ -101,7 +86,7 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
      */
     if (errno != EADDRINUSE
         || unlink(pipe_fname) == -1
-        || bind(sockfd, (struct sockaddr*)&sun, sizeof sun) == -1) {
+        || bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr) == -1) {
       /* Convert ENOENT to EACCES for compatibility with Windows. */
       uv_err_new(handle->loop, (errno == ENOENT) ? EACCES : errno);
       goto out;
@@ -185,11 +170,16 @@ int uv_pipe_cleanup(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);
+}
+
+
 int uv_pipe_connect(uv_connect_t* req,
                     uv_pipe_t* handle,
                     const char* name,
                     uv_connect_cb cb) {
-  struct sockaddr_un sun;
+  struct sockaddr_un saddr;
   int saved_errno;
   int sockfd;
   int status;
@@ -204,15 +194,15 @@ int uv_pipe_connect(uv_connect_t* req,
     goto out;
   }
 
-  memset(&sun, 0, sizeof sun);
-  uv__strlcpy(sun.sun_path, name, sizeof(sun.sun_path));
-  sun.sun_family = AF_UNIX;
+  memset(&saddr, 0, sizeof saddr);
+  uv__strlcpy(saddr.sun_path, name, sizeof(saddr.sun_path));
+  saddr.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);
+    r = connect(sockfd, (struct sockaddr*)&saddr, sizeof saddr);
   }
   while (r == -1 && errno == EINTR);
 
@@ -251,7 +241,7 @@ out:
 
 /* TODO merge with uv__server_io()? */
 void uv__pipe_accept(EV_P_ ev_io* watcher, int revents) {
-  struct sockaddr_un sun;
+  struct sockaddr_un saddr;
   uv_pipe_t* pipe;
   int saved_errno;
   int sockfd;
@@ -262,7 +252,7 @@ void uv__pipe_accept(EV_P_ ev_io* watcher, int revents) {
   assert(pipe->type == UV_NAMED_PIPE);
   assert(pipe->pipe_fname != NULL);
 
-  sockfd = uv__accept(pipe->fd, (struct sockaddr *)&sun, sizeof sun);
+  sockfd = uv__accept(pipe->fd, (struct sockaddr *)&saddr, sizeof saddr);
   if (sockfd == -1) {
     if (errno == EAGAIN || errno == EWOULDBLOCK) {
       assert(0 && "EAGAIN on uv__accept(pipefd)");

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

@@ -26,6 +26,7 @@
 #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>
@@ -178,16 +179,28 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     if (stdin_pipe[0] >= 0) {
       uv__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);
     }
 
     if (stdout_pipe[1] >= 0) {
       uv__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) {
       uv__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)) {

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

@@ -26,11 +26,12 @@
 #include <errno.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/uio.h>
 
 
 static void uv__stream_connect(uv_stream_t*);
-static uv_write_t* uv__write(uv_stream_t* stream);
+static void uv__write(uv_stream_t* stream);
 static void uv__read(uv_stream_t* stream);
 
 
@@ -46,6 +47,34 @@ static size_t uv__buf_count(uv_buf_t bufs[], int bufcnt) {
 }
 
 
+void uv__stream_init(uv_loop_t* loop,
+                     uv_stream_t* stream,
+                     uv_handle_type type) {
+  uv__handle_init(loop, (uv_handle_t*)stream, type);
+
+  stream->alloc_cb = NULL;
+  stream->close_cb = NULL;
+  stream->connection_cb = NULL;
+  stream->connect_req = NULL;
+  stream->accepted_fd = -1;
+  stream->fd = -1;
+  stream->delayed_error = 0;
+  ngx_queue_init(&stream->write_queue);
+  ngx_queue_init(&stream->write_completed_queue);
+  stream->write_queue_size = 0;
+
+  ev_init(&stream->read_watcher, uv__stream_io);
+  stream->read_watcher.data = stream;
+
+  ev_init(&stream->write_watcher, uv__stream_io);
+  stream->write_watcher.data = stream;
+
+  assert(ngx_queue_empty(&stream->write_queue));
+  assert(ngx_queue_empty(&stream->write_completed_queue));
+  assert(stream->write_queue_size == 0);
+}
+
+
 int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
   socklen_t yes;
 
@@ -74,6 +103,39 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
 }
 
 
+void uv__stream_destroy(uv_stream_t* stream) {
+  uv_write_t* req;
+  ngx_queue_t* q;
+
+  assert(stream->flags & UV_CLOSED);
+
+  while (!ngx_queue_empty(&stream->write_queue)) {
+    q = ngx_queue_head(&stream->write_queue);
+    ngx_queue_remove(q);
+
+    req = ngx_queue_data(q, uv_write_t, queue);
+    if (req->bufs != req->bufsml)
+      free(req->bufs);
+
+    if (req->cb) {
+      uv_err_new_artificial(req->handle->loop, UV_EINTR);
+      req->cb(req, -1);
+    }
+  }
+
+  while (!ngx_queue_empty(&stream->write_completed_queue)) {
+    q = ngx_queue_head(&stream->write_completed_queue);
+    ngx_queue_remove(q);
+
+    req = ngx_queue_data(q, uv_write_t, queue);
+    if (req->cb) {
+      uv_err_new_artificial(req->handle->loop, UV_OK);
+      req->cb(req, 0);
+    }
+  }
+}
+
+
 void uv__server_io(EV_P_ ev_io* watcher, int revents) {
   int fd;
   struct sockaddr_storage addr;
@@ -225,10 +287,28 @@ static void uv__drain(uv_stream_t* stream) {
 }
 
 
+static void uv__write_req_finish(uv_write_t* req) {
+  uv_stream_t* stream = req->handle;
+
+  /* Pop the req off tcp->write_queue. */
+  ngx_queue_remove(&req->queue);
+  if (req->bufs != req->bufsml) {
+    free(req->bufs);
+  }
+  req->bufs = NULL;
+
+  /* Add it to the write_completed_queue where it will have its
+   * callback called in the near future.
+   */
+  ngx_queue_insert_tail(&stream->write_completed_queue, &req->queue);
+  ev_feed_event(stream->loop->ev, &stream->write_watcher, EV_WRITE);
+}
+
+
 /* On success returns NULL. On error returns a pointer to the write request
  * which had the error.
  */
-static uv_write_t* uv__write(uv_stream_t* stream) {
+static void uv__write(uv_stream_t* stream) {
   uv_write_t* req;
   struct iovec* iov;
   int iovcnt;
@@ -242,7 +322,7 @@ static uv_write_t* uv__write(uv_stream_t* stream) {
   req = uv_write_queue_head(stream);
   if (!req) {
     assert(stream->write_queue_size == 0);
-    return NULL;
+    return;
   }
 
   assert(req->handle == stream);
@@ -270,8 +350,9 @@ static uv_write_t* uv__write(uv_stream_t* stream) {
   if (n < 0) {
     if (errno != EAGAIN) {
       /* Error */
-      uv_err_new(stream->loop, errno);
-      return req;
+      req->error = errno;
+      uv__write_req_finish(req);
+      return;
     }
   } else {
     /* Successful write */
@@ -305,21 +386,9 @@ static uv_write_t* uv__write(uv_stream_t* stream) {
         if (req->write_index == req->bufcnt) {
           /* Then we're done! */
           assert(n == 0);
-
-          /* Pop the req off tcp->write_queue. */
-          ngx_queue_remove(&req->queue);
-          if (req->bufs != req->bufsml) {
-            free(req->bufs);
-          }
-          req->bufs = NULL;
-
-          /* Add it to the write_completed_queue where it will have its
-           * callback called in the near future.
-           * TODO: start trying to write the next request.
-           */
-          ngx_queue_insert_tail(&stream->write_completed_queue, &req->queue);
-          ev_feed_event(stream->loop->ev, &stream->write_watcher, EV_WRITE);
-          return NULL;
+          uv__write_req_finish(req);
+          /* TODO: start trying to write the next request. */
+          return;
         }
       }
     }
@@ -330,8 +399,6 @@ static uv_write_t* uv__write(uv_stream_t* stream) {
 
   /* We're not done. */
   ev_io_start(stream->loop->ev, &stream->write_watcher);
-
-  return NULL;
 }
 
 
@@ -349,7 +416,8 @@ static void uv__write_callbacks(uv_stream_t* stream) {
 
     /* NOTE: call callback AFTER freeing the request data. */
     if (req->cb) {
-      req->cb(req, 0);
+      uv_err_new_artificial(stream->loop, req->error);
+      req->cb(req, req->error ? -1 : 0);
     }
 
     callbacks_made++;
@@ -466,15 +534,8 @@ void uv__stream_io(EV_P_ ev_io* watcher, int revents) {
     }
 
     if (revents & EV_WRITE) {
-      uv_write_t* req = uv__write(stream);
-      if (req) {
-        /* Error. Notify the user. */
-        if (req->cb) {
-          req->cb(req, -1);
-        }
-      } else {
-        uv__write_callbacks(stream);
-      }
+      uv__write(stream);
+      uv__write_callbacks(stream);
     }
   }
 }
@@ -602,34 +663,29 @@ int uv__connect(uv_connect_t* req, uv_stream_t* stream, struct sockaddr* addr,
 /* The buffers to be written must remain valid until the callback is called.
  * This is not required for the uv_buf_t array.
  */
-int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
+int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt,
     uv_write_cb cb) {
-  uv_stream_t* stream;
   int empty_queue;
 
-  stream = (uv_stream_t*)handle;
-
-  /* Initialize the req */
-  uv__req_init((uv_req_t*) req);
-  req->cb = cb;
-  req->handle = handle;
-  ngx_queue_init(&req->queue);
-
-  assert((handle->type == UV_TCP || handle->type == UV_NAMED_PIPE)
+  assert((stream->type == UV_TCP || stream->type == UV_NAMED_PIPE)
       && "uv_write (unix) does not yet support other types of streams");
 
-  empty_queue = (stream->write_queue_size == 0);
-
   if (stream->fd < 0) {
     uv_err_new(stream->loop, EBADF);
     return -1;
   }
 
-  ngx_queue_init(&req->queue);
-  req->type = UV_WRITE;
+  empty_queue = (stream->write_queue_size == 0);
 
+  /* Initialize the req */
+  uv__req_init((uv_req_t*) req);
+  req->cb = cb;
+  req->handle = stream;
+  req->error = 0;
+  req->type = UV_WRITE;
+  ngx_queue_init(&req->queue);
 
-  if (bufcnt < UV_REQ_BUFSML_SIZE) {
+  if (bufcnt <= UV_REQ_BUFSML_SIZE) {
     req->bufs = req->bufsml;
   }
   else {
@@ -659,22 +715,8 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
    * for the fd to become writable.
    */
   if (empty_queue) {
-    if (uv__write(stream)) {
-      /* Error. uv_last_error has been set. */
-      return -1;
-    }
-  }
-
-  /* If the queue is now empty - we've flushed the request already. That
-   * means we need to make the callback. The callback can only be done on a
-   * fresh stack so we feed the event loop in order to service it.
-   */
-  if (ngx_queue_empty(&stream->write_queue)) {
-    ev_feed_event(stream->loop->ev, &stream->write_watcher, EV_WRITE);
+    uv__write(stream);
   } else {
-    /* Otherwise there is data to write - so we should wait for the file
-     * descriptor to become writable.
-     */
     ev_io_start(stream->loop->ev, &stream->write_watcher);
   }