noderb 0.0.4 → 0.0.6

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

@@ -61,39 +61,38 @@
  */
 static uv_err_code uv_translate_eai_error(int eai_errno) {
   switch (eai_errno) {
-    case ERROR_SUCCESS:                   return UV_OK;
-    case EAI_BADFLAGS:                    return UV_EBADF;
-    case EAI_FAIL:                        return UV_EFAULT;
-    case EAI_FAMILY:                      return UV_EAIFAMNOSUPPORT;
-    case EAI_MEMORY:                      return UV_ENOMEM;
-    case EAI_NONAME:                      return UV_EAINONAME;
-    case EAI_AGAIN:                       return UV_EAGAIN;
-    case EAI_SERVICE:                     return UV_EAISERVICE;
-    case EAI_SOCKTYPE:                    return UV_EAISOCKTYPE;
-    default:                              return uv_translate_sys_error(eai_errno);
+    case ERROR_SUCCESS:               return UV_OK;
+    case EAI_BADFLAGS:                return UV_EBADF;
+    case EAI_FAIL:                    return UV_EFAULT;
+    case EAI_FAMILY:                  return UV_EAIFAMNOSUPPORT;
+    case EAI_MEMORY:                  return UV_ENOMEM;
+    case EAI_NONAME:                  return UV_EAINONAME;
+    case EAI_AGAIN:                   return UV_EAGAIN;
+    case EAI_SERVICE:                 return UV_EAISERVICE;
+    case EAI_SOCKTYPE:                return UV_EAISOCKTYPE;
+    default:                          return uv_translate_sys_error(eai_errno);
   }
 }
 
 
 /* getaddrinfo worker thread implementation */
 static DWORD WINAPI getaddrinfo_thread_proc(void* parameter) {
-  uv_getaddrinfo_t* handle = (uv_getaddrinfo_t*)parameter;
+  uv_getaddrinfo_t* handle = (uv_getaddrinfo_t*) parameter;
+  uv_loop_t* loop = handle->loop;
   int ret;
 
   assert(handle != NULL);
 
   if (handle != NULL) {
     /* call OS function on this thread */
-    ret = GetAddrInfoW(handle->node, handle->service, handle->hints, &handle->res);
+    ret = GetAddrInfoW(handle->node,
+                       handle->service,
+                       handle->hints,
+                       &handle->res);
     handle->retcode = ret;
 
     /* post getaddrinfo completed */
-    if (!PostQueuedCompletionStatus(LOOP->iocp,
-                                  0,
-                                  0,
-                                  &handle->getadddrinfo_req.overlapped)) {
-      uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-    }
+    POST_COMPLETION_FOR_REQ(loop, &handle->getadddrinfo_req);
   }
 
   return 0;
@@ -109,7 +108,8 @@ static DWORD WINAPI getaddrinfo_thread_proc(void* parameter) {
  * and copy all structs and referenced strings into the one block.
  * Each size calculation is adjusted to avoid unaligned pointers.
  */
-void uv_process_getaddrinfo_req(uv_getaddrinfo_t* handle, uv_req_t* req) {
+void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* handle,
+    uv_req_t* req) {
   int addrinfo_len = 0;
   int name_len = 0;
   size_t addrinfo_struct_len = ALIGNED_SIZE(sizeof(struct addrinfo));
@@ -131,7 +131,8 @@ void uv_process_getaddrinfo_req(uv_getaddrinfo_t* handle, uv_req_t* req) {
     /* first calculate required length */
     addrinfow_ptr = handle->res;
     while (addrinfow_ptr != NULL) {
-      addrinfo_len += addrinfo_struct_len + ALIGNED_SIZE(addrinfow_ptr->ai_addrlen);
+      addrinfo_len += addrinfo_struct_len +
+          ALIGNED_SIZE(addrinfow_ptr->ai_addrlen);
       if (addrinfow_ptr->ai_canonname != NULL) {
         name_len = uv_utf16_to_utf8(addrinfow_ptr->ai_canonname, -1, NULL, 0);
         if (name_len == 0) {
@@ -168,7 +169,8 @@ void uv_process_getaddrinfo_req(uv_getaddrinfo_t* handle, uv_req_t* req) {
 
         /* copy sockaddr */
         if (addrinfo_ptr->ai_addrlen > 0) {
-          assert(cur_ptr + addrinfo_ptr->ai_addrlen <= alloc_ptr + addrinfo_len);
+          assert(cur_ptr + addrinfo_ptr->ai_addrlen <=
+                 alloc_ptr + addrinfo_len);
           memcpy(cur_ptr, addrinfow_ptr->ai_addr, addrinfo_ptr->ai_addrlen);
           addrinfo_ptr->ai_addr = (struct sockaddr*)cur_ptr;
           cur_ptr += ALIGNED_SIZE(addrinfo_ptr->ai_addrlen);
@@ -176,10 +178,16 @@ void uv_process_getaddrinfo_req(uv_getaddrinfo_t* handle, uv_req_t* req) {
 
         /* convert canonical name to UTF-8 */
         if (addrinfow_ptr->ai_canonname != NULL) {
-          name_len = uv_utf16_to_utf8(addrinfow_ptr->ai_canonname, -1, NULL, 0);
+          name_len = uv_utf16_to_utf8(addrinfow_ptr->ai_canonname,
+                                      -1,
+                                      NULL,
+                                      0);
           assert(name_len > 0);
           assert(cur_ptr + name_len <= alloc_ptr + addrinfo_len);
-          name_len = uv_utf16_to_utf8(addrinfow_ptr->ai_canonname, -1, cur_ptr, name_len);
+          name_len = uv_utf16_to_utf8(addrinfow_ptr->ai_canonname,
+                                      -1,
+                                      cur_ptr,
+                                      name_len);
           assert(name_len > 0);
           addrinfo_ptr->ai_canonname = cur_ptr;
           cur_ptr += ALIGNED_SIZE(name_len);
@@ -213,7 +221,7 @@ complete:
     free(alloc_ptr);
   }
 
-  uv_unref();
+  uv_unref(loop);
 }
 
 
@@ -221,7 +229,8 @@ complete:
  * Entry point for getaddrinfo
  * we convert the UTF-8 strings to UNICODE
  * and save the UNICODE string pointers in the handle
- * We also copy hints so that caller does not need to keep memory until the callback.
+ * We also copy hints so that caller does not need to keep memory until the
+ * callback.
  * return UV_OK if a callback will be made
  * return error code if validation fails
  *
@@ -229,7 +238,8 @@ complete:
  * and copy all structs and referenced strings into the one block.
  * Each size calculation is adjusted to avoid unaligned pointers.
  */
-int uv_getaddrinfo(uv_getaddrinfo_t* handle,
+int uv_getaddrinfo(uv_loop_t* loop,
+                   uv_getaddrinfo_t* handle,
                    uv_getaddrinfo_cb getaddrinfo_cb,
                    const char* node,
                    const char* service,
@@ -241,27 +251,29 @@ int uv_getaddrinfo(uv_getaddrinfo_t* handle,
 
   if (handle == NULL || getaddrinfo_cb == NULL ||
      (node == NULL && service == NULL)) {
-    uv_set_sys_error(WSAEINVAL);
+    uv_set_sys_error(loop, WSAEINVAL);
     goto error;
   }
 
   handle->getaddrinfo_cb = getaddrinfo_cb;
   handle->res = NULL;
   handle->type = UV_GETADDRINFO;
+  handle->loop = loop;
 
   /* calculate required memory size for all input values */
   if (node != NULL) {
     nodesize = ALIGNED_SIZE(uv_utf8_to_utf16(node, NULL, 0) * sizeof(wchar_t));
     if (nodesize == 0) {
-      uv_set_sys_error(GetLastError());
+      uv_set_sys_error(loop, GetLastError());
       goto error;
     }
   }
 
   if (service != NULL) {
-    servicesize = ALIGNED_SIZE(uv_utf8_to_utf16(service, NULL, 0) * sizeof(wchar_t));
+    servicesize = ALIGNED_SIZE(uv_utf8_to_utf16(service, NULL, 0) *
+                               sizeof(wchar_t));
     if (servicesize == 0) {
-      uv_set_sys_error(GetLastError());
+      uv_set_sys_error(loop, GetLastError());
       goto error;
     }
   }
@@ -272,18 +284,21 @@ int uv_getaddrinfo(uv_getaddrinfo_t* handle,
   /* allocate memory for inputs, and partition it as needed */
   alloc_ptr = (char*)malloc(nodesize + servicesize + hintssize);
   if (!alloc_ptr) {
-    uv_set_sys_error(WSAENOBUFS);
+    uv_set_sys_error(loop, WSAENOBUFS);
     goto error;
   }
 
   /* save alloc_ptr now so we can free if error */
   handle->alloc = (void*)alloc_ptr;
 
-  /* convert node string to UTF16 into allocated memory and save pointer in handle */
+  /* convert node string to UTF16 into allocated memory and save pointer in */
+  /* handle */
   if (node != NULL) {
     handle->node = (wchar_t*)alloc_ptr;
-    if (uv_utf8_to_utf16(node, (wchar_t*)alloc_ptr, nodesize / sizeof(wchar_t)) == 0) {
-      uv_set_sys_error(GetLastError());
+    if (uv_utf8_to_utf16(node,
+                         (wchar_t*) alloc_ptr,
+                         nodesize / sizeof(wchar_t)) == 0) {
+      uv_set_sys_error(loop, GetLastError());
       goto error;
     }
     alloc_ptr += nodesize;
@@ -291,11 +306,14 @@ int uv_getaddrinfo(uv_getaddrinfo_t* handle,
     handle->node = NULL;
   }
 
-  /* convert service string to UTF16 into allocated memory and save pointer in handle */
+  /* convert service string to UTF16 into allocated memory and save pointer */
+  /* in handle */
   if (service != NULL) {
     handle->service = (wchar_t*)alloc_ptr;
-    if (uv_utf8_to_utf16(service, (wchar_t*)alloc_ptr, servicesize / sizeof(wchar_t)) == 0) {
-      uv_set_sys_error(GetLastError());
+    if (uv_utf8_to_utf16(service,
+                         (wchar_t*) alloc_ptr,
+                         servicesize / sizeof(wchar_t)) == 0) {
+      uv_set_sys_error(loop, GetLastError());
       goto error;
     }
     alloc_ptr += servicesize;
@@ -319,17 +337,19 @@ int uv_getaddrinfo(uv_getaddrinfo_t* handle,
   }
 
   /* init request for Post handling */
-  uv_req_init(&handle->getadddrinfo_req);
+  uv_req_init(loop, &handle->getadddrinfo_req);
   handle->getadddrinfo_req.data = handle;
   handle->getadddrinfo_req.type = UV_GETADDRINFO_REQ;
 
   /* Ask thread to run. Treat this as a long operation */
-  if (QueueUserWorkItem(&getaddrinfo_thread_proc, handle, WT_EXECUTELONGFUNCTION) == 0) {
-    uv_set_sys_error(GetLastError());
+  if (QueueUserWorkItem(&getaddrinfo_thread_proc,
+                        handle,
+                        WT_EXECUTELONGFUNCTION) == 0) {
+    uv_set_sys_error(loop, GetLastError());
     goto error;
   }
 
-  uv_ref();
+  uv_ref(loop);
 
   return 0;
 

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

@@ -39,18 +39,37 @@ int uv_is_active(uv_handle_t* handle) {
 }
 
 
-/* TODO: integrate this with uv_close. */
-static void uv_close_error(uv_handle_t* handle, uv_err_t e) {
+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;
+  uv_udp_t* udp;
   uv_process_t* process;
 
+  uv_loop_t* loop = handle->loop;
+
   if (handle->flags & UV_HANDLE_CLOSING) {
     return;
   }
 
-  handle->error = e;
   handle->flags |= UV_HANDLE_CLOSING;
+  handle->close_cb = cb;
 
   /* Handle-specific close actions */
   switch (handle->type) {
@@ -65,7 +84,7 @@ static void uv_close_error(uv_handle_t* handle, uv_err_t e) {
       tcp->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING);
       closesocket(tcp->socket);
       if (tcp->reqs_pending == 0) {
-        uv_want_endgame(handle);
+        uv_want_endgame(loop, handle);
       }
       return;
 
@@ -74,39 +93,48 @@ static void uv_close_error(uv_handle_t* handle, uv_err_t e) {
       pipe->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING);
       close_pipe(pipe, NULL, NULL);
       if (pipe->reqs_pending == 0) {
-        uv_want_endgame(handle);
+        uv_want_endgame(loop, handle);
+      }
+      return;
+
+    case UV_UDP:
+      udp = (uv_udp_t*) handle;
+      uv_udp_recv_stop(udp);
+      closesocket(udp->socket);
+      if (udp->reqs_pending == 0) {
+        uv_want_endgame(loop, handle);
       }
       return;
 
     case UV_TIMER:
       uv_timer_stop((uv_timer_t*)handle);
-      uv_want_endgame(handle);
+      uv_want_endgame(loop, handle);
       return;
 
     case UV_PREPARE:
       uv_prepare_stop((uv_prepare_t*)handle);
-      uv_want_endgame(handle);
+      uv_want_endgame(loop, handle);
       return;
 
     case UV_CHECK:
       uv_check_stop((uv_check_t*)handle);
-      uv_want_endgame(handle);
+      uv_want_endgame(loop, handle);
       return;
 
     case UV_IDLE:
       uv_idle_stop((uv_idle_t*)handle);
-      uv_want_endgame(handle);
+      uv_want_endgame(loop, handle);
       return;
 
     case UV_ASYNC:
       if (!((uv_async_t*)handle)->async_sent) {
-        uv_want_endgame(handle);
+        uv_want_endgame(loop, handle);
       }
       return;
 
     case UV_PROCESS:
       process = (uv_process_t*)handle;
-      uv_process_close(process);
+      uv_process_close(loop, process);
       return;
 
     default:
@@ -116,56 +144,54 @@ static void uv_close_error(uv_handle_t* handle, uv_err_t e) {
 }
 
 
-void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
-  handle->close_cb = close_cb;
-  uv_close_error(handle, uv_ok_);
-}
-
-
-void uv_want_endgame(uv_handle_t* handle) {
+void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle) {
   if (!(handle->flags & UV_HANDLE_ENDGAME_QUEUED)) {
     handle->flags |= UV_HANDLE_ENDGAME_QUEUED;
 
-    handle->endgame_next = LOOP->endgame_handles;
-    LOOP->endgame_handles = handle;
+    handle->endgame_next = loop->endgame_handles;
+    loop->endgame_handles = handle;
   }
 }
 
 
-void uv_process_endgames() {
+void uv_process_endgames(uv_loop_t* loop) {
   uv_handle_t* handle;
 
-  while (LOOP->endgame_handles) {
-    handle = LOOP->endgame_handles;
-    LOOP->endgame_handles = handle->endgame_next;
+  while (loop->endgame_handles) {
+    handle = loop->endgame_handles;
+    loop->endgame_handles = handle->endgame_next;
 
     handle->flags &= ~UV_HANDLE_ENDGAME_QUEUED;
 
     switch (handle->type) {
       case UV_TCP:
-        uv_tcp_endgame((uv_tcp_t*)handle);
+        uv_tcp_endgame(loop, (uv_tcp_t*) handle);
         break;
 
       case UV_NAMED_PIPE:
-        uv_pipe_endgame((uv_pipe_t*)handle);
+        uv_pipe_endgame(loop, (uv_pipe_t*) handle);
+        break;
+
+      case UV_UDP:
+        uv_udp_endgame(loop, (uv_udp_t*) handle);
         break;
 
       case UV_TIMER:
-        uv_timer_endgame((uv_timer_t*)handle);
+        uv_timer_endgame(loop, (uv_timer_t*) handle);
         break;
 
       case UV_PREPARE:
       case UV_CHECK:
       case UV_IDLE:
-        uv_loop_watcher_endgame(handle);
+        uv_loop_watcher_endgame(loop, handle);
         break;
 
       case UV_ASYNC:
-        uv_async_endgame((uv_async_t*)handle);
+        uv_async_endgame(loop, (uv_async_t*) handle);
         break;
 
       case UV_PROCESS:
-        uv_process_endgame((uv_process_t*)handle);
+        uv_process_endgame(loop, (uv_process_t*) handle);
         break;
 
       default: