noderb 0.0.2

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

@@ -0,0 +1,141 @@
+/* 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 <assert.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+void uv_req_init(uv_req_t* req) {
+  uv_counters()->req_init++;
+  req->type = UV_UNKNOWN_REQ;
+  req->error = uv_ok_;
+}
+
+
+uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
+  return CONTAINING_RECORD(overlapped, uv_req_t, overlapped);
+}
+
+
+void uv_insert_pending_req(uv_req_t* req) {
+  req->next_req = NULL;
+  if (LOOP->pending_reqs_tail) {
+    req->next_req = LOOP->pending_reqs_tail->next_req;
+    LOOP->pending_reqs_tail->next_req = req;
+    LOOP->pending_reqs_tail = req;
+  } else {
+    req->next_req = req;
+    LOOP->pending_reqs_tail = req;
+  }
+}
+
+
+static uv_req_t* uv_remove_pending_req() {
+  uv_req_t* req;
+
+  if (LOOP->pending_reqs_tail) {
+    req = LOOP->pending_reqs_tail->next_req;
+
+    if (req == LOOP->pending_reqs_tail) {
+      LOOP->pending_reqs_tail = NULL;
+    } else {
+      LOOP->pending_reqs_tail->next_req = req->next_req;
+    }
+
+    return req;
+
+  } else {
+    /* queue empty */
+    return NULL;
+  }
+}
+
+
+#define DELEGATE_STREAM_REQ(req, method, handle_at)                           \
+  do {                                                                        \
+    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
+      case UV_TCP:                                                            \
+        uv_process_tcp_##method##_req((uv_tcp_t*) ((req)->handle_at), req);   \
+        break;                                                                \
+                                                                              \
+      case UV_NAMED_PIPE:                                                     \
+        uv_process_pipe_##method##_req((uv_pipe_t*) ((req)->handle_at), req); \
+        break;                                                                \
+                                                                              \
+      default:                                                                \
+        assert(0);                                                            \
+    }                                                                         \
+  } while (0)
+
+
+void uv_process_reqs() {
+  uv_req_t* req;
+
+  while (req = uv_remove_pending_req()) {
+    switch (req->type) {
+      case UV_READ:
+        DELEGATE_STREAM_REQ(req, read, data);
+        break;
+
+      case UV_WRITE:
+        DELEGATE_STREAM_REQ((uv_write_t*) req, write, handle);
+        break;
+
+      case UV_ACCEPT:
+        DELEGATE_STREAM_REQ(req, accept, data);
+        break;
+
+      case UV_CONNECT:
+        DELEGATE_STREAM_REQ((uv_connect_t*) req, connect, handle);
+        break;
+
+      case UV_WAKEUP:
+        uv_process_async_wakeup_req((uv_async_t*) req->data, req);
+        break;
+
+      case UV_ARES_EVENT_REQ:
+        uv_process_ares_event_req((uv_ares_action_t*) req->data, req);
+        break;
+
+      case UV_ARES_CLEANUP_REQ:
+        uv_process_ares_cleanup_req((uv_ares_task_t*) req->data, req);
+        break;
+
+      case UV_GETADDRINFO_REQ:
+        uv_process_getaddrinfo_req((uv_getaddrinfo_t*) req->data, req);
+        break;
+
+      case UV_PROCESS_EXIT:
+        uv_process_proc_exit((uv_process_t*) req->data);
+        break;
+
+      case UV_PROCESS_CLOSE:
+        uv_process_proc_close((uv_process_t*) req->data);
+        break;
+
+      default:
+        assert(0);
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+/* 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 <assert.h>
+#include <string.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+static uv_pipe_t* uv_make_pipe_for_std_handle(HANDLE handle) {
+  uv_pipe_t* pipe = NULL;
+
+  pipe = (uv_pipe_t*)malloc(sizeof(uv_pipe_t));
+  if (!pipe) {
+    uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
+  }
+
+  if (uv_pipe_init_with_handle(pipe, handle)) {
+    free(pipe);
+    return NULL;
+  }
+
+  pipe->flags |= UV_HANDLE_UV_ALLOCED;
+  return pipe;
+}
+
+
+uv_stream_t* uv_std_handle(uv_std_type type) {
+  HANDLE handle;
+
+  switch (type) {
+    case UV_STDIN:
+      handle = GetStdHandle(STD_INPUT_HANDLE);
+      if (handle == INVALID_HANDLE_VALUE) {
+        return NULL;
+      }
+
+      /* Assume only named pipes for now. */
+      return (uv_stream_t*)uv_make_pipe_for_std_handle(handle);
+      break;
+
+    case UV_STDOUT:
+      return NULL;
+      break;
+
+    case UV_STDERR:
+      return NULL;
+      break;
+
+    default:
+      assert(0);
+      uv_set_error(UV_EINVAL, 0);
+      return NULL;
+  }
+}

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

@@ -0,0 +1,149 @@
+/* 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 <assert.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+void uv_stream_init(uv_stream_t* handle) {
+  handle->write_queue_size = 0;
+  handle->flags = 0;
+  handle->error = uv_ok_;
+
+  uv_counters()->handle_init++;
+  uv_counters()->stream_init++;
+
+  uv_ref();
+}
+
+
+void uv_connection_init(uv_stream_t* handle) {
+  handle->flags |= UV_HANDLE_CONNECTION;
+  handle->write_reqs_pending = 0;
+
+  uv_req_init((uv_req_t*) &(handle->read_req));
+  handle->read_req.type = UV_READ;
+  handle->read_req.data = handle;
+}
+
+
+int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
+  switch (stream->type) {
+    case UV_TCP:
+      return uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
+    case UV_NAMED_PIPE:
+      return uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
+    default:
+      assert(0);
+      return -1;
+  }
+}
+
+
+int uv_accept(uv_stream_t* server, uv_stream_t* client) {
+  assert(client->type == server->type);
+
+  switch (server->type) {
+    case UV_TCP:
+      return uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
+    case UV_NAMED_PIPE:
+      return uv_pipe_accept((uv_pipe_t*)server, (uv_pipe_t*)client);
+    default:
+      assert(0);
+      return -1;
+  }
+}
+
+
+int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb) {
+  switch (handle->type) {
+    case UV_TCP:
+      return uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
+    case UV_NAMED_PIPE:
+      return uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
+    default:
+      assert(0);
+      return -1;
+  }
+}
+
+
+int uv_read_stop(uv_stream_t* handle) {
+  handle->flags &= ~UV_HANDLE_READING;
+
+  return 0;
+}
+
+
+int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
+    uv_write_cb cb) {
+  switch (handle->type) {
+    case UV_TCP:
+      return uv_tcp_write(req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
+    case UV_NAMED_PIPE:
+      return uv_pipe_write(req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+    default:
+      assert(0);
+      uv_set_sys_error(WSAEINVAL);
+      return -1;
+  }
+}
+
+
+int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
+  if (!(handle->flags & UV_HANDLE_CONNECTION)) {
+    uv_set_sys_error(WSAEINVAL);
+    return -1;
+  }
+
+  if (handle->flags & UV_HANDLE_SHUTTING) {
+    uv_set_sys_error(WSAESHUTDOWN);
+    return -1;
+  }
+
+  uv_req_init((uv_req_t*) req);
+  req->type = UV_SHUTDOWN;
+  req->handle = handle;
+  req->cb = cb;
+
+  handle->flags |= UV_HANDLE_SHUTTING;
+  handle->shutdown_req = req;
+  handle->reqs_pending++;
+
+  uv_want_endgame((uv_handle_t*)handle);
+
+  return 0;
+}
+
+
+size_t uv_count_bufs(uv_buf_t bufs[], int count) {
+  size_t bytes = 0;
+  int i;
+
+  for (i = 0; i < count; i++) {
+    bytes += (size_t)bufs[i].len;
+  }
+
+  return bytes;
+}