noderb 0.0.4 → 0.0.6

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

@@ -26,10 +26,10 @@
 #include "internal.h"
 
 
-void uv_req_init(uv_req_t* req) {
-  uv_counters()->req_init++;
+void uv_req_init(uv_loop_t* loop, uv_req_t* req) {
+  loop->counters.req_init++;
   req->type = UV_UNKNOWN_REQ;
-  req->error = uv_ok_;
+  SET_REQ_SUCCESS(req);
 }
 
 
@@ -38,29 +38,29 @@ uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
 }
 
 
-void uv_insert_pending_req(uv_req_t* req) {
+void uv_insert_pending_req(uv_loop_t* loop, 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;
+  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;
+    loop->pending_reqs_tail = req;
   }
 }
 
 
-static uv_req_t* uv_remove_pending_req() {
+static uv_req_t* uv_remove_pending_req(uv_loop_t* loop) {
   uv_req_t* req;
 
-  if (LOOP->pending_reqs_tail) {
-    req = LOOP->pending_reqs_tail->next_req;
+  if (loop->pending_reqs_tail) {
+    req = loop->pending_reqs_tail->next_req;
 
-    if (req == LOOP->pending_reqs_tail) {
-      LOOP->pending_reqs_tail = NULL;
+    if (req == loop->pending_reqs_tail) {
+      loop->pending_reqs_tail = NULL;
     } else {
-      LOOP->pending_reqs_tail->next_req = req->next_req;
+      loop->pending_reqs_tail->next_req = req->next_req;
     }
 
     return req;
@@ -72,15 +72,19 @@ static uv_req_t* uv_remove_pending_req() {
 }
 
 
-#define DELEGATE_STREAM_REQ(req, method, handle_at)                           \
+#define DELEGATE_STREAM_REQ(loop, 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);   \
+        uv_process_tcp_##method##_req(loop,                                   \
+                                      (uv_tcp_t*) ((req)->handle_at),         \
+                                      req);                                   \
         break;                                                                \
                                                                               \
       case UV_NAMED_PIPE:                                                     \
-        uv_process_pipe_##method##_req((uv_pipe_t*) ((req)->handle_at), req); \
+        uv_process_pipe_##method##_req(loop,                                  \
+                                       (uv_pipe_t*) ((req)->handle_at),       \
+                                       req);                                  \
         break;                                                                \
                                                                               \
       default:                                                                \
@@ -89,56 +93,76 @@ static uv_req_t* uv_remove_pending_req() {
   } while (0)
 
 
-void uv_process_reqs() {
+void uv_process_reqs(uv_loop_t* loop) {
   uv_req_t* req;
 
-  while (req = uv_remove_pending_req()) {
+  while (req = uv_remove_pending_req(loop)) {
     switch (req->type) {
       case UV_READ:
-        DELEGATE_STREAM_REQ(req, read, data);
+        DELEGATE_STREAM_REQ(loop, req, read, data);
         break;
 
       case UV_WRITE:
-        DELEGATE_STREAM_REQ((uv_write_t*) req, write, handle);
+        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
         break;
 
       case UV_ACCEPT:
-        DELEGATE_STREAM_REQ(req, accept, data);
+        DELEGATE_STREAM_REQ(loop, req, accept, data);
         break;
 
       case UV_CONNECT:
-        DELEGATE_STREAM_REQ((uv_connect_t*) req, connect, handle);
+        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
         break;
 
       case UV_SHUTDOWN:
         /* Tcp shutdown requests don't come here. */
         assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
         uv_process_pipe_shutdown_req(
-            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle, req);
+            loop,
+            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle,
+            (uv_shutdown_t*) req);
+        break;
+
+      case UV_UDP_RECV:
+        uv_process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
+        break;
+
+      case UV_UDP_SEND:
+        uv_process_udp_send_req(loop,
+                                ((uv_udp_send_t*) req)->handle,
+                                (uv_udp_send_t*) req);
         break;
 
       case UV_WAKEUP:
-        uv_process_async_wakeup_req((uv_async_t*) req->data, req);
+        uv_process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
         break;
 
       case UV_ARES_EVENT_REQ:
-        uv_process_ares_event_req((uv_ares_action_t*) req->data, req);
+        uv_process_ares_event_req(loop, (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);
+        uv_process_ares_cleanup_req(loop, (uv_ares_task_t*) req->data, req);
         break;
 
       case UV_GETADDRINFO_REQ:
-        uv_process_getaddrinfo_req((uv_getaddrinfo_t*) req->data, req);
+        uv_process_getaddrinfo_req(loop, (uv_getaddrinfo_t*) req->data, req);
         break;
 
       case UV_PROCESS_EXIT:
-        uv_process_proc_exit((uv_process_t*) req->data);
+        uv_process_proc_exit(loop, (uv_process_t*) req->data);
         break;
 
       case UV_PROCESS_CLOSE:
-        uv_process_proc_close((uv_process_t*) req->data);
+        uv_process_proc_close(loop, (uv_process_t*) req->data);
+        break;
+
+      case UV_FS:
+        uv_process_fs_req(loop, (uv_fs_t*) req);
+        break;
+
+      case UV_WORK:
+        uv_process_work_req(loop, (uv_work_t*) req);
         break;
 
       default:

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

@@ -27,7 +27,7 @@
 #include "internal.h"
 
 
-static uv_pipe_t* uv_make_pipe_for_std_handle(HANDLE handle) {
+static uv_pipe_t* uv_make_pipe_for_std_handle(uv_loop_t* loop, HANDLE handle) {
   uv_pipe_t* pipe = NULL;
 
   pipe = (uv_pipe_t*)malloc(sizeof(uv_pipe_t));
@@ -35,7 +35,7 @@ static uv_pipe_t* uv_make_pipe_for_std_handle(HANDLE handle) {
     uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
   }
 
-  if (uv_pipe_init_with_handle(pipe, handle)) {
+  if (uv_pipe_init_with_handle(loop, pipe, handle)) {
     free(pipe);
     return NULL;
   }
@@ -45,7 +45,7 @@ static uv_pipe_t* uv_make_pipe_for_std_handle(HANDLE handle) {
 }
 
 
-uv_stream_t* uv_std_handle(uv_std_type type) {
+uv_stream_t* uv_std_handle(uv_loop_t* loop, uv_std_type type) {
   HANDLE handle;
 
   switch (type) {
@@ -56,7 +56,7 @@ uv_stream_t* uv_std_handle(uv_std_type type) {
       }
 
       /* Assume only named pipes for now. */
-      return (uv_stream_t*)uv_make_pipe_for_std_handle(handle);
+      return (uv_stream_t*)uv_make_pipe_for_std_handle(loop, handle);
       break;
 
     case UV_STDOUT:
@@ -69,7 +69,7 @@ uv_stream_t* uv_std_handle(uv_std_type type) {
 
     default:
       assert(0);
-      uv_set_error(UV_EINVAL, 0);
+      uv_set_error(loop, UV_EINVAL, 0);
       return NULL;
   }
 }

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

@@ -26,15 +26,15 @@
 #include "internal.h"
 
 
-void uv_stream_init(uv_stream_t* handle) {
+void uv_stream_init(uv_loop_t* loop, uv_stream_t* handle) {
   handle->write_queue_size = 0;
+  handle->loop = loop;
   handle->flags = 0;
-  handle->error = uv_ok_;
 
-  uv_counters()->handle_init++;
-  uv_counters()->stream_init++;
+  loop->counters.handle_init++;
+  loop->counters.stream_init++;
 
-  uv_ref();
+  uv_ref(loop);
 }
 
 
@@ -42,7 +42,7 @@ 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));
+  uv_req_init(handle->loop, (uv_req_t*) &(handle->read_req));
   handle->read_req.type = UV_READ;
   handle->read_req.data = handle;
 }
@@ -76,7 +76,8 @@ int uv_accept(uv_stream_t* server, uv_stream_t* client) {
 }
 
 
-int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb) {
+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);
@@ -98,31 +99,35 @@ int uv_read_stop(uv_stream_t* handle) {
 
 int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
     uv_write_cb cb) {
+  uv_loop_t* loop = handle->loop;
+
   switch (handle->type) {
     case UV_TCP:
-      return uv_tcp_write(req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
+      return uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
     case UV_NAMED_PIPE:
-      return uv_pipe_write(req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+      return uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
     default:
       assert(0);
-      uv_set_sys_error(WSAEINVAL);
+      uv_set_sys_error(loop, WSAEINVAL);
       return -1;
   }
 }
 
 
 int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
+  uv_loop_t* loop = handle->loop;
+
   if (!(handle->flags & UV_HANDLE_CONNECTION)) {
-    uv_set_sys_error(WSAEINVAL);
+    uv_set_sys_error(loop, WSAEINVAL);
     return -1;
   }
 
   if (handle->flags & UV_HANDLE_SHUTTING) {
-    uv_set_sys_error(WSAESHUTDOWN);
+    uv_set_sys_error(loop, WSAESHUTDOWN);
     return -1;
   }
 
-  uv_req_init((uv_req_t*) req);
+  uv_req_init(loop, (uv_req_t*) req);
   req->type = UV_SHUTDOWN;
   req->handle = handle;
   req->cb = cb;
@@ -131,7 +136,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
   handle->shutdown_req = req;
   handle->reqs_pending++;
 
-  uv_want_endgame((uv_handle_t*)handle);
+  uv_want_endgame(loop, (uv_handle_t*)handle);
 
   return 0;
 }