noderb 0.0.10 → 0.0.11

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

@@ -19,15 +19,29 @@
  */
 
 #include "uv.h"
+#include "internal.h"
 
 #include <stdint.h>
-#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+
+#include <sys/inotify.h>
 #include <unistd.h>
 #include <time.h>
 
 #undef NANOSEC
 #define NANOSEC 1000000000
 
+
+/* Don't look aghast, this is exactly how glibc's basename() works. */
+static char* basename_r(const char* path) {
+  char* s = strrchr(path, '/');
+  return s ? (s + 1) : (char*)path;
+}
+
+
 /*
  * There's probably some way to get time from Linux than gettimeofday(). What
  * it is, I don't know.
@@ -49,3 +63,121 @@ int uv_exepath(char* buffer, size_t* size) {
   buffer[*size] = '\0';
   return 0;
 }
+
+
+static int new_inotify_fd(void) {
+#if defined(IN_NONBLOCK) && defined(IN_CLOEXEC)
+  return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+#else
+  int fd;
+
+  if ((fd = inotify_init()) == -1)
+    return -1;
+
+  if (uv__cloexec(fd, 1) || uv__nonblock(fd, 1)) {
+    SAVE_ERRNO(uv__close(fd));
+    fd = -1;
+  }
+
+  return fd;
+#endif
+}
+
+
+static void uv__inotify_read(EV_P_ ev_io* w, int revents) {
+  struct inotify_event* e;
+  uv_fs_event_t* handle;
+  const char* filename;
+  ssize_t size;
+  int events;
+  char *p;
+  /* needs to be large enough for sizeof(inotify_event) + strlen(filename) */
+  char buf[4096];
+
+  handle = container_of(w, uv_fs_event_t, read_watcher);
+
+  do {
+    do {
+      size = read(handle->fd, buf, sizeof buf);
+    }
+    while (size == -1 && errno == EINTR);
+
+    if (size == -1) {
+      assert(errno == EAGAIN || errno == EWOULDBLOCK);
+      break;
+    }
+
+    assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */
+
+    /* Now we have one or more inotify_event structs. */
+    for (p = buf; p < buf + size; p += sizeof(*e) + e->len) {
+      e = (void*)p;
+
+      events = 0;
+      if (e->mask & (IN_ATTRIB|IN_MODIFY))
+        events |= UV_CHANGE;
+      if (e->mask & ~(IN_ATTRIB|IN_MODIFY))
+        events |= UV_RENAME;
+
+      /* inotify does not return the filename when monitoring a single file
+       * for modifications. Repurpose the filename for API compatibility.
+       * I'm not convinced this is a good thing, maybe it should go.
+       */
+      filename = e->len ? e->name : basename_r(handle->filename);
+
+      handle->cb(handle, filename, events, 0);
+    }
+  }
+  while (handle->fd != -1); /* handle might've been closed by callback */
+}
+
+
+int uv_fs_event_init(uv_loop_t* loop,
+                     uv_fs_event_t* handle,
+                     const char* filename,
+                     uv_fs_event_cb cb) {
+  int flags;
+  int fd;
+
+  /*
+   * TODO share a single inotify fd across the event loop?
+   * We'll run into fs.inotify.max_user_instances if we
+   * keep creating new inotify fds.
+   */
+  if ((fd = new_inotify_fd()) == -1) {
+    uv_err_new(loop, errno);
+    return -1;
+  }
+
+  flags = IN_ATTRIB
+        | IN_CREATE
+        | IN_MODIFY
+        | IN_DELETE
+        | IN_DELETE_SELF
+        | IN_MOVED_FROM
+        | IN_MOVED_TO;
+
+  if (inotify_add_watch(fd, filename, flags) == -1) {
+    uv_err_new(loop, errno);
+    uv__close(fd);
+    return -1;
+  }
+
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
+  handle->filename = strdup(filename); /* this should go! */
+  handle->cb = cb;
+  handle->fd = fd;
+
+  ev_io_init(&handle->read_watcher, uv__inotify_read, fd, EV_READ);
+  ev_io_start(loop->ev, &handle->read_watcher);
+
+  return 0;
+}
+
+
+void uv__fs_event_destroy(uv_fs_event_t* handle) {
+  ev_io_stop(handle->loop->ev, &handle->read_watcher);
+  uv__close(handle->fd);
+  handle->fd = -1;
+  free(handle->filename);
+}

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

@@ -20,17 +20,20 @@
 
 #include "uv.h"
 
+#include <assert.h>
 #include <string.h>
-#include <time.h>
+#include <errno.h>
 
 #include <sys/types.h>
 #include <sys/sysctl.h>
 
 #include <unistd.h>
+#include <time.h>
 
 #undef NANOSEC
 #define NANOSEC 1000000000
 
+
 uint64_t uv_hrtime(void) {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -66,3 +69,17 @@ int uv_exepath(char* buffer, size_t* size) {
 
   return 0;
 }
+
+
+int uv_fs_event_init(uv_loop_t* loop,
+                     uv_fs_event_t* handle,
+                     const char* filename,
+                     uv_fs_event_cb cb) {
+  uv_err_new(loop, ENOSYS);
+  return -1;
+}
+
+
+void uv__fs_event_destroy(uv_fs_event_t* handle) {
+  assert(0 && "implement me");
+}

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

@@ -129,8 +129,8 @@ void uv__stream_destroy(uv_stream_t* stream) {
 
     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);
+      uv_err_new_artificial(stream->loop, req->error);
+      req->cb(req, req->error ? -1 : 0);
     }
   }
 }
@@ -287,6 +287,17 @@ static void uv__drain(uv_stream_t* stream) {
 }
 
 
+static size_t uv__write_req_size(uv_write_t* req) {
+  size_t size;
+
+  size = uv__buf_count(req->bufs + req->write_index,
+                       req->bufcnt - req->write_index);
+  assert(req->handle->write_queue_size >= size);
+
+  return size;
+}
+
+
 static void uv__write_req_finish(uv_write_t* req) {
   uv_stream_t* stream = req->handle;
 
@@ -351,6 +362,7 @@ static void uv__write(uv_stream_t* stream) {
     if (errno != EAGAIN) {
       /* Error */
       req->error = errno;
+      stream->write_queue_size -= uv__write_req_size(req);
       uv__write_req_finish(req);
       return;
     }
@@ -517,8 +529,8 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
 void uv__stream_io(EV_P_ ev_io* watcher, int revents) {
   uv_stream_t* stream = watcher->data;
 
-  assert(stream->type == UV_TCP ||
-         stream->type == UV_NAMED_PIPE);
+  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
+      stream->type == UV_TTY);
   assert(watcher == &stream->read_watcher ||
          watcher == &stream->write_watcher);
   assert(!(stream->flags & UV_CLOSING));
@@ -667,8 +679,9 @@ int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt,
     uv_write_cb cb) {
   int empty_queue;
 
-  assert((stream->type == UV_TCP || stream->type == UV_NAMED_PIPE)
-      && "uv_write (unix) does not yet support other types of streams");
+  assert((stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
+      stream->type == UV_TTY) &&
+      "uv_write (unix) does not yet support other types of streams");
 
   if (stream->fd < 0) {
     uv_err_new(stream->loop, EBADF);
@@ -725,7 +738,8 @@ int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt,
 
 
 int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb) {
-  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE);
+  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
+      stream->type == UV_TTY);
 
   if (stream->flags & UV_CLOSING) {
     uv_err_new(stream->loop, EINVAL);

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

@@ -22,8 +22,11 @@
 
 #include <stdio.h>
 #include <stdint.h>
-#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+
 #include <sys/time.h>
+#include <unistd.h>
 
 
 uint64_t uv_hrtime() {
@@ -58,3 +61,17 @@ int uv_exepath(char* buffer, size_t* size) {
   *size = res;
   return (0);
 }
+
+
+int uv_fs_event_init(uv_loop_t* loop,
+                     uv_fs_event_t* handle,
+                     const char* filename,
+                     uv_fs_event_cb cb) {
+  uv_err_new(loop, ENOSYS);
+  return -1;
+}
+
+
+void uv__fs_event_destroy(uv_fs_event_t* handle) {
+  assert(0 && "implement me");
+}

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

@@ -23,8 +23,10 @@
 #include "internal.h"
 
 #include <assert.h>
+#include <unistd.h>
 #include <termios.h>
 #include <errno.h>
+#include <sys/ioctl.h>
 
 
 int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd) {
@@ -67,3 +69,42 @@ fatal:
   return -1;
 }
 
+
+int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
+  struct winsize ws;
+
+  if (ioctl(tty->fd, TIOCGWINSZ, &ws) < 0) {
+    uv_err_new(tty->loop, errno);
+    return -1;
+  }
+
+  *width = ws.ws_col;
+  *height = ws.ws_row;
+
+  return 0;
+}
+
+
+uv_handle_type uv_guess_handle(uv_file file) {
+  struct stat s;
+
+  if (file < 0) {
+    uv_err_new(NULL, EINVAL); /* XXX Need loop? */
+    return -1;
+  }
+
+  if (isatty(file)) {
+    return UV_TTY;
+  }
+
+  if (fstat(file, &s)) {
+    uv_err_new(NULL, errno); /* XXX Need loop? */
+    return -1;
+  }
+
+  if (!S_ISSOCK(s.st_mode) && !S_ISFIFO(s.st_mode)) {
+    return UV_FILE;
+  }
+
+  return UV_NAMED_PIPE;
+}

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

@@ -301,6 +301,7 @@ static int uv__udp_bind(uv_udp_t* handle,
 
   saved_errno = errno;
   status = -1;
+  fd = -1;
 
   /* Check for bad flags. */
   if (flags & ~UV_UDP_IPV6ONLY) {

data/ext/noderb_extension/libuv/src/win/core.c

@@ -48,6 +48,9 @@ static void uv_init(void) {
 
   /* Initialize FS */
   uv_fs_init();
+
+  /* Initialize console */
+  uv_console_init();
 }