noderb 0.0.4 → 0.0.6

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

@@ -32,63 +32,75 @@
 
 
 /* The only event loop we support right now */
-uv_loop_t uv_main_loop_;
+static uv_loop_t uv_default_loop_;
+static int uv_default_loop_initialized_ = 0;
 
 
-static void uv_loop_init() {
+static void uv_loop_init(uv_loop_t* loop) {
   /* Create an I/O completion port */
-  LOOP->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
-  if (LOOP->iocp == NULL) {
+  loop->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
+  if (loop->iocp == NULL) {
     uv_fatal_error(GetLastError(), "CreateIoCompletionPort");
   }
 
-  LOOP->refs = 0;
+  loop->refs = 0;
 
-  uv_update_time();
+  uv_update_time(loop);
 
-  LOOP->pending_reqs_tail = NULL;
+  loop->pending_reqs_tail = NULL;
 
-  LOOP->endgame_handles = NULL;
+  loop->endgame_handles = NULL;
 
-  RB_INIT(&LOOP->timers);
+  RB_INIT(&loop->timers);
 
-  LOOP->check_handles = NULL;
-  LOOP->prepare_handles = NULL;
-  LOOP->idle_handles = NULL;
+  loop->check_handles = NULL;
+  loop->prepare_handles = NULL;
+  loop->idle_handles = NULL;
 
-  LOOP->next_prepare_handle = NULL;
-  LOOP->next_check_handle = NULL;
-  LOOP->next_idle_handle = NULL;
+  loop->next_prepare_handle = NULL;
+  loop->next_check_handle = NULL;
+  loop->next_idle_handle = NULL;
 
-  LOOP->last_error = uv_ok_;
+  loop->ares_active_sockets = 0;
+  loop->ares_channel = NULL;
 
-  LOOP->err_str = NULL;
+  loop->last_error = uv_ok_;
+}
+
+
+uv_loop_t* uv_default_loop() {
+  if (!uv_default_loop_initialized_) {
+    uv_loop_init(&uv_default_loop_);
+    uv_default_loop_initialized_ = 1;
+  }
+
+  return &uv_default_loop_;
 }
 
 
 void uv_init() {
   /* Initialize winsock */
-  uv_winsock_startup();
+  uv_winsock_init();
 
   /* Fetch winapi function pointers */
   uv_winapi_init();
 
-  /* Intialize event loop */
-  uv_loop_init();
+  /* Initialize FS */
+  uv_fs_init();
 }
 
 
-void uv_ref() {
-  LOOP->refs++;
+void uv_ref(uv_loop_t* loop) {
+  loop->refs++;
 }
 
 
-void uv_unref() {
-  LOOP->refs--;
+void uv_unref(uv_loop_t* loop) {
+  loop->refs--;
 }
 
 
-static void uv_poll(int block) {
+static void uv_poll(uv_loop_t* loop, int block) {
   BOOL success;
   DWORD bytes, timeout;
   ULONG_PTR key;
@@ -96,12 +108,12 @@ static void uv_poll(int block) {
   uv_req_t* req;
 
   if (block) {
-    timeout = uv_get_poll_timeout();
+    timeout = uv_get_poll_timeout(loop);
   } else {
     timeout = 0;
   }
 
-  success = GetQueuedCompletionStatus(LOOP->iocp,
+  success = GetQueuedCompletionStatus(loop->iocp,
                                       &bytes,
                                       &key,
                                       &overlapped,
@@ -111,11 +123,7 @@ static void uv_poll(int block) {
     /* Package was dequeued */
     req = uv_overlapped_to_req(overlapped);
 
-    if (!success) {
-      req->error = uv_new_sys_error(GetLastError());
-    }
-
-    uv_insert_pending_req(req);
+    uv_insert_pending_req(loop, req);
 
   } else if (GetLastError() != WAIT_TIMEOUT) {
     /* Serious error */
@@ -124,35 +132,79 @@ static void uv_poll(int block) {
 }
 
 
-int uv_run() {
-  while (LOOP->refs > 0) {
-    uv_update_time();
-    uv_process_timers();
+static void uv_poll_ex(uv_loop_t* loop, int block) {
+  BOOL success;
+  DWORD timeout;
+  uv_req_t* req;
+  OVERLAPPED_ENTRY overlappeds[64];
+  ULONG count;
+  ULONG i;
 
-    /* Call idle callbacks if nothing to do. */
-    if (LOOP->pending_reqs_tail == NULL && LOOP->endgame_handles == NULL) {
-      uv_idle_invoke();
-    }
+  if (block) {
+    timeout = uv_get_poll_timeout(loop);
+  } else {
+    timeout = 0;
+  }
 
-    /* Completely flush all pending reqs and endgames. */
-    /* We do even when we just called the idle callbacks because those may */
-    /* have closed handles or started requests that short-circuited. */
-    while (LOOP->pending_reqs_tail || LOOP->endgame_handles) {
-      uv_process_endgames();
-      uv_process_reqs();
+  assert(pGetQueuedCompletionStatusEx);
+
+  success = pGetQueuedCompletionStatusEx(loop->iocp,
+                                         overlappeds,
+                                         COUNTOF(overlappeds),
+                                         &count,
+                                         timeout,
+                                         FALSE);
+  if (success) {
+    for (i = 0; i < count; i++) {
+      /* Package was dequeued */
+      req = uv_overlapped_to_req(overlappeds[i].lpOverlapped);
+      uv_insert_pending_req(loop, req);
     }
+  } else if (GetLastError() != WAIT_TIMEOUT) {
+    /* Serious error */
+    uv_fatal_error(GetLastError(), "GetQueuedCompletionStatusEx");
+  }
+}
 
-    if (LOOP->refs <= 0) {
-      break;
-    }
 
-    uv_prepare_invoke();
+#define UV_LOOP(loop, poll)                                                   \
+  while ((loop)->refs > 0) {                                                  \
+    uv_update_time((loop));                                                   \
+    uv_process_timers((loop));                                                \
+                                                                              \
+    /* Call idle callbacks if nothing to do. */                               \
+    if ((loop)->pending_reqs_tail == NULL &&                                  \
+        (loop)->endgame_handles == NULL) {                                    \
+      uv_idle_invoke((loop));                                                 \
+    }                                                                         \
+                                                                              \
+    /* Completely flush all pending reqs and endgames. */                     \
+    /* We do even when we just called the idle callbacks because those may */ \
+    /* have closed handles or started requests that short-circuited. */       \
+    while ((loop)->pending_reqs_tail || (loop)->endgame_handles) {            \
+      uv_process_endgames((loop));                                            \
+      uv_process_reqs((loop));                                                \
+    }                                                                         \
+                                                                              \
+    if ((loop)->refs <= 0) {                                                  \
+      break;                                                                  \
+    }                                                                         \
+                                                                              \
+    uv_prepare_invoke((loop));                                                \
+                                                                              \
+    poll((loop), (loop)->idle_handles == NULL && (loop)->refs > 0);           \
+                                                                              \
+    uv_check_invoke((loop));                                                  \
+  }
 
-    uv_poll(LOOP->idle_handles == NULL && LOOP->refs > 0);
 
-    uv_check_invoke();
+int uv_run(uv_loop_t* loop) {
+  if (pGetQueuedCompletionStatusEx) {
+    UV_LOOP(loop, uv_poll_ex);
+  } else {
+    UV_LOOP(loop, uv_poll);
   }
 
-  assert(LOOP->refs == 0);
+  assert(loop->refs == 0);
   return 0;
 }

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

@@ -67,22 +67,26 @@ void uv_fatal_error(const int errorno, const char* syscall) {
 }
 
 
-uv_err_t uv_last_error() {
-  return LOOP->last_error;
+uv_err_t uv_last_error(uv_loop_t* loop) {
+  return loop->last_error;
 }
 
 
+/* TODO: thread safety */
+static char* last_err_str_ = NULL;
+
 char* uv_strerror(uv_err_t err) {
-  if (LOOP->err_str != NULL) {
-    LocalFree(LOOP->err_str);
+  if (last_err_str_ != NULL) {
+    LocalFree(last_err_str_);
   }
 
   FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
       FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err.sys_errno_,
-      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&LOOP->err_str, 0, NULL);
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &last_err_str_, 0,
+      NULL);
 
-  if (LOOP->err_str) {
-    return LOOP->err_str;
+  if (last_err_str_) {
+    return last_err_str_;
   } else {
     return "Unknown error";
   }
@@ -97,15 +101,21 @@ uv_err_code uv_translate_sys_error(int sys_errno) {
     case ERROR_ADDRESS_ALREADY_ASSOCIATED:  return UV_EADDRINUSE;
     case WSAEADDRINUSE:                     return UV_EADDRINUSE;
     case WSAEADDRNOTAVAIL:                  return UV_EADDRNOTAVAIL;
+    case WSAEAFNOSUPPORT:                   return UV_EAFNOSUPPORT;
     case WSAEWOULDBLOCK:                    return UV_EAGAIN;
     case WSAEALREADY:                       return UV_EALREADY;
     case ERROR_CONNECTION_REFUSED:          return UV_ECONNREFUSED;
     case WSAECONNREFUSED:                   return UV_ECONNREFUSED;
     case WSAEFAULT:                         return UV_EFAULT;
+    case ERROR_HOST_UNREACHABLE:            return UV_EHOSTUNREACH;
+    case WSAEHOSTUNREACH:                   return UV_EHOSTUNREACH;
     case ERROR_INVALID_DATA:                return UV_EINVAL;
     case WSAEINVAL:                         return UV_EINVAL;
     case ERROR_TOO_MANY_OPEN_FILES:         return UV_EMFILE;
     case WSAEMFILE:                         return UV_EMFILE;
+    case WSAEMSGSIZE:                       return UV_EMSGSIZE;
+    case ERROR_NETWORK_UNREACHABLE:         return UV_ENETUNREACH;
+    case WSAENETUNREACH:                    return UV_ENETUNREACH;
     case ERROR_OUTOFMEMORY:                 return UV_ENOMEM;
     case ERROR_NOT_SUPPORTED:               return UV_ENOTSUP;
     case ERROR_INSUFFICIENT_BUFFER:         return UV_EINVAL;
@@ -128,13 +138,13 @@ uv_err_t uv_new_sys_error(int sys_errno) {
 }
 
 
-void uv_set_sys_error(int sys_errno) {
-  LOOP->last_error.code = uv_translate_sys_error(sys_errno);
-  LOOP->last_error.sys_errno_ = sys_errno;
+void uv_set_sys_error(uv_loop_t* loop, int sys_errno) {
+  loop->last_error.code = uv_translate_sys_error(sys_errno);
+  loop->last_error.sys_errno_ = sys_errno;
 }
 
 
-void uv_set_error(uv_err_code code, int sys_errno) {
-  LOOP->last_error.code = code;
-  LOOP->last_error.sys_errno_ = sys_errno;
+void uv_set_error(uv_loop_t* loop, uv_err_code code, int sys_errno) {
+  loop->last_error.code = code;
+  loop->last_error.sys_errno_ = sys_errno;
 }