noderb 0.0.8 → 0.0.9

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

@@ -29,7 +29,7 @@
 /*
  * MinGW is missing this
  */
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) && !defined(__MINGW64_VERSION_MAJOR)
   typedef struct addrinfoW {
     int ai_flags;
     int ai_family;
@@ -255,6 +255,8 @@ int uv_getaddrinfo(uv_loop_t* loop,
     goto error;
   }
 
+  uv_req_init(loop, (uv_req_t*)handle);
+
   handle->getaddrinfo_cb = getaddrinfo_cb;
   handle->res = NULL;
   handle->type = UV_GETADDRINFO;

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

@@ -39,23 +39,6 @@ int uv_is_active(uv_handle_t* handle) {
 }
 
 
-int uv_getsockname(uv_handle_t* handle, struct sockaddr* name, int* namelen) {
-  uv_loop_t* loop = handle->loop;
-
-  switch (handle->type) {
-    case UV_TCP:
-      return uv_tcp_getsockname(loop, (uv_tcp_t*) handle, name, namelen);
-
-    case UV_UDP:
-      return uv_udp_getsockname(loop, (uv_udp_t*) handle, name, namelen);
-
-    default:
-      uv_set_sys_error(loop, WSAENOTSOCK);
-      return -1;
-  }
-}
-
-
 void uv_close(uv_handle_t* handle, uv_close_cb cb) {
   uv_tcp_t* tcp;
   uv_pipe_t* pipe;

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

@@ -123,8 +123,6 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
     uv_read_cb read_cb);
 int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
     uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
-int uv_tcp_getsockname(uv_loop_t* loop, uv_tcp_t* handle,
-    struct sockaddr* name, int* namelen);
 
 void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, uv_req_t* req);
 void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
@@ -140,9 +138,6 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle);
 /*
  * UDP
  */
-int uv_udp_getsockname(uv_loop_t* loop, uv_udp_t* handle,
-    struct sockaddr* name, int* namelen);
-
 void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req);
 void uv_process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
     uv_udp_send_t* req);
@@ -284,4 +279,19 @@ void uv_winsock_init();
 int uv_ntstatus_to_winsock_error(NTSTATUS status);
 
 
+/* Threads and synchronization */
+typedef struct uv_once_s {
+  unsigned char ran;
+  /* The actual event handle must be aligned to sizeof(HANDLE), so in */
+  /* practice it might overlap padding a little. */
+  HANDLE event;
+  HANDLE padding;
+} uv_once_t;
+
+#define UV_ONCE_INIT \
+  { 0, NULL, NULL }
+
+void uv_once(uv_once_t* guard, void (*callback)(void));
+
+
 #endif /* UV_WIN_INTERNAL_H_ */

data/ext/noderb_extension/libuv/src/win/loop-watcher.c

@@ -49,7 +49,7 @@ void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle) {
     uv_ref(loop);                                                             \
                                                                               \
     loop->counters.handle_init++;                                             \
-    loop->counters.##name##_init++;                                           \
+    loop->counters.name##_init++;                                             \
                                                                               \
     return 0;                                                                 \
   }                                                                           \

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

@@ -1059,3 +1059,9 @@ static void eof_timer_close_cb(uv_handle_t* handle) {
   assert(handle->type == UV_TIMER);
   free(handle);
 }
+
+
+void uv_pipe_open(uv_pipe_t* pipe, uv_file file) {
+  assert(0 && "implement me");
+}
+

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

@@ -61,12 +61,9 @@ static void uv_process_init(uv_loop_t* loop, uv_process_t* handle) {
   handle->wait_handle = INVALID_HANDLE_VALUE;
   handle->process_handle = INVALID_HANDLE_VALUE;
   handle->close_handle = INVALID_HANDLE_VALUE;
-  handle->stdio_pipes[0].server_pipe = NULL;
-  handle->stdio_pipes[0].child_pipe = INVALID_HANDLE_VALUE;
-  handle->stdio_pipes[1].server_pipe = NULL;
-  handle->stdio_pipes[1].child_pipe = INVALID_HANDLE_VALUE;
-  handle->stdio_pipes[2].server_pipe = NULL;
-  handle->stdio_pipes[2].child_pipe = INVALID_HANDLE_VALUE;
+  handle->child_stdio[0] = INVALID_HANDLE_VALUE;
+  handle->child_stdio[1] = INVALID_HANDLE_VALUE;
+  handle->child_stdio[2] = INVALID_HANDLE_VALUE;
 
   uv_req_init(loop, (uv_req_t*)&handle->exit_req);
   handle->exit_req.type = UV_PROCESS_EXIT;
@@ -625,7 +622,7 @@ static DWORD WINAPI spawn_failure(void* data) {
   char unknown[] = "unknown error\n";
   uv_process_t* process = (uv_process_t*) data;
   uv_loop_t* loop = process->loop;
-  HANDLE child_stderr = process->stdio_pipes[2].child_pipe;
+  HANDLE child_stderr = process->child_stdio[2];
   char* buf = NULL;
   DWORD count, written;
 
@@ -657,18 +654,23 @@ static DWORD WINAPI spawn_failure(void* data) {
 }
 
 
-/* Called on main thread after a child process has exited. */
-void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
+static void close_child_stdio(uv_process_t* process) {
   int i;
-  DWORD exit_code;
+  HANDLE handle;
 
-  /* Close stdio handles. */
-  for (i = 0; i < COUNTOF(handle->stdio_pipes); i++) {
-    if (handle->stdio_pipes[i].child_pipe != INVALID_HANDLE_VALUE) {
-      CloseHandle(handle->stdio_pipes[i].child_pipe);
-      handle->stdio_pipes[i].child_pipe = INVALID_HANDLE_VALUE;
+  for (i = 0; i < COUNTOF(process->child_stdio); i++) {
+    handle = process->child_stdio[i];
+    if (handle != NULL && handle != INVALID_HANDLE_VALUE) {
+      CloseHandle(handle);
+      process->child_stdio[i] = INVALID_HANDLE_VALUE;
     }
   }
+}
+
+
+/* Called on main thread after a child process has exited. */
+void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
+  DWORD exit_code;
 
   /* Unregister from process notification. */
   if (handle->wait_handle != INVALID_HANDLE_VALUE) {
@@ -686,6 +688,10 @@ void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
     CloseHandle(handle->process_handle);
     handle->process_handle = INVALID_HANDLE_VALUE;
   } else {
+    /* We probably left the child stdio handles open to report the error */
+    /* asynchronously, so close them now. */
+    close_child_stdio(handle);
+
     /* The process never even started in the first place. */
     exit_code = 127;
   }
@@ -805,13 +811,45 @@ done:
 }
 
 
+static int duplicate_std_handle(uv_loop_t* loop, DWORD id, HANDLE* dup) {
+  HANDLE handle;
+  HANDLE current_process = GetCurrentProcess();
+  
+  handle = GetStdHandle(id);
+
+  if (handle == NULL) {
+    *dup = NULL;
+    return 0;
+  } else if (handle == INVALID_HANDLE_VALUE) {
+    *dup = INVALID_HANDLE_VALUE;
+    uv_set_sys_error(loop, GetLastError());
+    return -1;
+  }
+
+  if (!DuplicateHandle(current_process,
+                       handle,
+                       current_process,
+                       dup,
+                       0,
+                       TRUE,
+                       DUPLICATE_SAME_ACCESS)) {
+    *dup = INVALID_HANDLE_VALUE;
+    uv_set_sys_error(loop, GetLastError());
+    return -1;
+  }
+
+  return 0;
+}
+
+
 int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     uv_process_options_t options) {
-  int err = 0, i;
+  int err = 0, keep_child_stdio_open = 0;
   wchar_t* path;
   int size;
   BOOL result;
   wchar_t* application_path, *application, *arguments, *env, *cwd;
+  HANDLE* child_stdio = process->child_stdio;
   STARTUPINFOW startup;
   PROCESS_INFORMATION info;
 
@@ -864,41 +902,41 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     err = uv_create_stdio_pipe_pair(
         loop,
         options.stdin_stream,
-        &process->stdio_pipes[0].child_pipe,
+        &child_stdio[0],
         PIPE_ACCESS_OUTBOUND,
         GENERIC_READ | FILE_WRITE_ATTRIBUTES);
-    if (err) {
-      goto done;
-    }
-
-    process->stdio_pipes[0].server_pipe = options.stdin_stream;
+  } else {
+    err = duplicate_std_handle(loop, STD_INPUT_HANDLE, &child_stdio[0]);
+  }
+  if (err) {
+    goto done;
   }
 
   if (options.stdout_stream) {
     err = uv_create_stdio_pipe_pair(
         loop, options.stdout_stream,
-        &process->stdio_pipes[1].child_pipe,
+        &child_stdio[1],
         PIPE_ACCESS_INBOUND,
         GENERIC_WRITE);
-    if (err) {
-      goto done;
-    }
-
-    process->stdio_pipes[1].server_pipe = options.stdout_stream;
+  } else {
+    err = duplicate_std_handle(loop, STD_OUTPUT_HANDLE, &child_stdio[1]);
+  }
+  if (err) {
+    goto done;
   }
 
   if (options.stderr_stream) {
     err = uv_create_stdio_pipe_pair(
         loop,
         options.stderr_stream,
-        &process->stdio_pipes[2].child_pipe,
+        &child_stdio[2],
         PIPE_ACCESS_INBOUND,
         GENERIC_WRITE);
-    if (err) {
-      goto done;
-    }
-
-    process->stdio_pipes[2].server_pipe = options.stderr_stream;
+  } else {
+    err = duplicate_std_handle(loop, STD_ERROR_HANDLE, &child_stdio[2]);
+  }
+  if (err) {
+    goto done;
   }
 
   startup.cb = sizeof(startup);
@@ -908,9 +946,9 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
   startup.dwFlags = STARTF_USESTDHANDLES;
   startup.cbReserved2 = 0;
   startup.lpReserved2 = NULL;
-  startup.hStdInput = process->stdio_pipes[0].child_pipe;
-  startup.hStdOutput = process->stdio_pipes[1].child_pipe;
-  startup.hStdError = process->stdio_pipes[2].child_pipe;
+  startup.hStdInput = child_stdio[0];
+  startup.hStdOutput = child_stdio[1];
+  startup.hStdError = child_stdio[2];
 
   if (CreateProcessW(application_path,
                      arguments,
@@ -942,6 +980,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     /* succeeded, and start a thread instead that prints an error */
     /* to the child's intended stderr. */
     process->spawn_errno = GetLastError();
+    keep_child_stdio_open = 1;
     if (!QueueUserWorkItem(spawn_failure, process, WT_EXECUTEDEFAULT)) {
       uv_fatal_error(GetLastError(), "QueueUserWorkItem");
     }
@@ -957,14 +996,22 @@ done:
   free(env);
   free(path);
 
-  if (err) {
-    for (i = 0; i < COUNTOF(process->stdio_pipes); i++) {
-      if (process->stdio_pipes[i].child_pipe != INVALID_HANDLE_VALUE) {
-        CloseHandle(process->stdio_pipes[i].child_pipe);
-        process->stdio_pipes[i].child_pipe = INVALID_HANDLE_VALUE;
-      }
+  /* Under normal circumstances we should close the stdio handles now - */
+  /* the child now has its own duplicates, or something went horribly wrong. */
+  /* The only exception is when CreateProcess has failed, then we actually */
+  /* need to keep the stdio handles to report the error asynchronously. */
+  if (!keep_child_stdio_open) {
+    close_child_stdio(process);
+  } else {
+    /* We're keeping the handles open, the thread pool is going to have */
+    /* it's way with them. But at least make them noninheritable. */
+    int i;
+    for (i = 0; i < COUNTOF(process->child_stdio); i++) {
+      SetHandleInformation(child_stdio[i], HANDLE_FLAG_INHERIT, 0);
     }
+  }
 
+  if (err) {
     if (process->wait_handle != INVALID_HANDLE_VALUE) {
       UnregisterWait(process->wait_handle);
       process->wait_handle = INVALID_HANDLE_VALUE;

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

@@ -419,6 +419,8 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
     rv = -1;
   } else {
     uv_connection_init((uv_stream_t*) client);
+    /* AcceptEx() implicitly binds the accepted socket. */
+    client->flags |= UV_HANDLE_BOUND;
   }
 
   /* Prepare the req to pick up a new connection */
@@ -573,12 +575,18 @@ int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
 }
 
 
-int uv_tcp_getsockname(uv_loop_t* loop, uv_tcp_t* handle,
-    struct sockaddr* name, int* namelen) {
+int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
+    int* namelen) {
+  uv_loop_t* loop = handle->loop;
   int result;
 
-  if (handle->flags & UV_HANDLE_SHUTTING) {
-    uv_set_sys_error(loop, WSAESHUTDOWN);
+  if (!(handle->flags & UV_HANDLE_BOUND)) {
+    uv_set_sys_error(loop, WSAEINVAL);
+    return -1;
+  }
+
+  if (handle->flags & UV_HANDLE_BIND_ERROR) {
+    loop->last_error = handle->bind_error;
     return -1;
   }
 
@@ -592,6 +600,31 @@ int uv_tcp_getsockname(uv_loop_t* loop, uv_tcp_t* handle,
 }
 
 
+int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
+    int* namelen) {
+  uv_loop_t* loop = handle->loop;
+  int result;
+
+  if (!(handle->flags & UV_HANDLE_BOUND)) {
+    uv_set_sys_error(loop, WSAEINVAL);
+    return -1;
+  }
+
+  if (handle->flags & UV_HANDLE_BIND_ERROR) {
+    loop->last_error = handle->bind_error;
+    return -1;
+  }
+
+  result = getpeername(handle->socket, name, namelen);
+  if (result != 0) {
+    uv_set_sys_error(loop, WSAGetLastError());
+    return -1;
+  }
+
+  return 0;
+}
+
+
 int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
     uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
   int result;

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

@@ -0,0 +1,81 @@
+/* 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"
+
+
+#ifdef _MSC_VER /* msvc */
+# define NOINLINE __declspec (noinline)
+#else  /* gcc */
+# define NOINLINE __attribute__ ((noinline))
+#endif
+
+
+static NOINLINE void uv__once_inner(uv_once_t* guard,
+    void (*callback)(void)) {
+  DWORD result;
+  HANDLE existing_event, created_event;
+  HANDLE* event_ptr;
+
+  /* Fetch and align event_ptr */
+  event_ptr = (HANDLE*) (((uintptr_t) &guard->event + (sizeof(HANDLE) - 1)) &
+    ~(sizeof(HANDLE) - 1));
+
+  created_event = CreateEvent(NULL, 1, 0, NULL);
+  if (created_event == 0) {
+    /* Could fail in a low-memory situation? */
+    uv_fatal_error(GetLastError(), "CreateEvent");
+  }
+
+  existing_event = InterlockedCompareExchangePointer(event_ptr,
+                                                     created_event,
+                                                     NULL);
+
+  if (existing_event == NULL) {
+    /* We won the race */
+    callback();
+
+    result = SetEvent(created_event);
+    assert(result);
+    guard->ran = 1;
+
+  } else {
+    /* We lost the race. Destroy the event we created and wait for the */
+    /* existing one to become signaled. */
+    CloseHandle(created_event);
+    result = WaitForSingleObject(existing_event, INFINITE);
+    assert(result == WAIT_OBJECT_0);
+  }
+}
+
+
+void uv_once(uv_once_t* guard, void (*callback)(void)) {
+  /* Fast case - avoid WaitForSingleObject. */
+  if (guard->ran) {
+    return;
+  }
+
+  uv__once_inner(guard, callback);
+}