noderb 0.0.4 → 0.0.6

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

@@ -25,271 +25,93 @@
 #include "../uv-common.h"
 #include "internal.h"
 
+
 /*
- * Guids and typedefs for winsock extension functions
- * Mingw32 doesn't have these :-(
+ * Threshold of active tcp streams for which to preallocate tcp read buffers.
+ * (Due to node slab allocator performing poorly under this pattern,
+ *  the optimization is temporarily disabled (threshold=0).  This will be
+ *  revisited once node allocator is improved.)
  */
-#ifndef WSAID_ACCEPTEX
-# define WSAID_ACCEPTEX                                        \
-         {0xb5367df1, 0xcbac, 0x11cf,                          \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-# define WSAID_CONNECTEX                                       \
-         {0x25a207b9, 0xddf3, 0x4660,                          \
-         {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}
-
-# define WSAID_GETACCEPTEXSOCKADDRS                            \
-         {0xb5367df2, 0xcbac, 0x11cf,                          \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-# define WSAID_DISCONNECTEX                                    \
-         {0x7fda2e11, 0x8630, 0x436f,                          \
-         {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}
-
-# define WSAID_TRANSMITFILE                                    \
-         {0xb5367df0, 0xcbac, 0x11cf,                          \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-  typedef BOOL PASCAL (*LPFN_ACCEPTEX)
-                      (SOCKET sListenSocket,
-                       SOCKET sAcceptSocket,
-                       PVOID lpOutputBuffer,
-                       DWORD dwReceiveDataLength,
-                       DWORD dwLocalAddressLength,
-                       DWORD dwRemoteAddressLength,
-                       LPDWORD lpdwBytesReceived,
-                       LPOVERLAPPED lpOverlapped);
-
-  typedef BOOL PASCAL (*LPFN_CONNECTEX)
-                      (SOCKET s,
-                       const struct sockaddr* name,
-                       int namelen,
-                       PVOID lpSendBuffer,
-                       DWORD dwSendDataLength,
-                       LPDWORD lpdwBytesSent,
-                       LPOVERLAPPED lpOverlapped);
-
-  typedef void PASCAL (*LPFN_GETACCEPTEXSOCKADDRS)
-                      (PVOID lpOutputBuffer,
-                       DWORD dwReceiveDataLength,
-                       DWORD dwLocalAddressLength,
-                       DWORD dwRemoteAddressLength,
-                       LPSOCKADDR* LocalSockaddr,
-                       LPINT LocalSockaddrLength,
-                       LPSOCKADDR* RemoteSockaddr,
-                       LPINT RemoteSockaddrLength);
-
-  typedef BOOL PASCAL (*LPFN_DISCONNECTEX)
-                      (SOCKET hSocket,
-                       LPOVERLAPPED lpOverlapped,
-                       DWORD dwFlags,
-                       DWORD reserved);
-
-  typedef BOOL PASCAL (*LPFN_TRANSMITFILE)
-                      (SOCKET hSocket,
-                       HANDLE hFile,
-                       DWORD nNumberOfBytesToWrite,
-                       DWORD nNumberOfBytesPerSend,
-                       LPOVERLAPPED lpOverlapped,
-                       LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
-                       DWORD dwFlags);
-#endif
+const unsigned int uv_active_tcp_streams_threshold = 0;
 
 /*
- * MinGW is missing this too
+ * Number of simultaneous pending AcceptEx calls.
  */
-#ifndef SO_UPDATE_CONNECT_CONTEXT
-# define SO_UPDATE_CONNECT_CONTEXT   0x7010
-#endif
-
-
-/* Pointers to winsock extension functions to be retrieved dynamically */
-static LPFN_CONNECTEX               pConnectEx;
-static LPFN_ACCEPTEX                pAcceptEx;
-static LPFN_GETACCEPTEXSOCKADDRS    pGetAcceptExSockAddrs;
-static LPFN_DISCONNECTEX            pDisconnectEx;
-static LPFN_TRANSMITFILE            pTransmitFile;
-
-/* IPv6 version of these extension functions */
-static LPFN_CONNECTEX               pConnectEx6;
-static LPFN_ACCEPTEX                pAcceptEx6;
-static LPFN_GETACCEPTEXSOCKADDRS    pGetAcceptExSockAddrs6;
-static LPFN_DISCONNECTEX            pDisconnectEx6;
-static LPFN_TRANSMITFILE            pTransmitFile6;
-
-/* Ip address used to bind to any port at any interface */
-static struct sockaddr_in uv_addr_ip4_any_;
-static struct sockaddr_in6 uv_addr_ip6_any_;
+const unsigned int uv_simultaneous_server_accepts = 32;
 
 /* A zero-size buffer for use by uv_tcp_read */
 static char uv_zero_[] = "";
 
-/* mark if IPv6 sockets are supported */
-static BOOL uv_allow_ipv6 = FALSE;
-
-
-/*
- * Retrieves the pointer to a winsock extension function.
- */
-static BOOL uv_get_extension_function(SOCKET socket, GUID guid,
-    void **target) {
-  DWORD result, bytes;
-
-  result = WSAIoctl(socket,
-                    SIO_GET_EXTENSION_FUNCTION_POINTER,
-                    &guid,
-                    sizeof(guid),
-                    (void*)target,
-                    sizeof(*target),
-                    &bytes,
-                    NULL,
-                    NULL);
-
-  if (result == SOCKET_ERROR) {
-    *target = NULL;
-    return FALSE;
-  } else {
-    return TRUE;
-  }
-}
-
+/* Counter to keep track of active tcp streams */
+static unsigned int active_tcp_streams = 0;
 
-/*
- * Setup tcp subsystem
- */
-void uv_winsock_startup() {
-  const GUID wsaid_connectex            = WSAID_CONNECTEX;
-  const GUID wsaid_acceptex             = WSAID_ACCEPTEX;
-  const GUID wsaid_getacceptexsockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
-  const GUID wsaid_disconnectex         = WSAID_DISCONNECTEX;
-  const GUID wsaid_transmitfile         = WSAID_TRANSMITFILE;
-
-  WSADATA wsa_data;
-  int errorno;
-  SOCKET dummy;
-  SOCKET dummy6;
-
-  /* Initialize winsock */
-  errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
-  if (errorno != 0) {
-    uv_fatal_error(errorno, "WSAStartup");
-  }
-
-  /* Set implicit binding address used by connectEx */
-  uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0);
-  uv_addr_ip6_any_ = uv_ip6_addr("::1", 0);
-
-  /* Retrieve the needed winsock extension function pointers. */
-  dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
-  if (dummy == INVALID_SOCKET) {
-    uv_fatal_error(WSAGetLastError(), "socket");
-  }
-
-  if (!uv_get_extension_function(dummy,
-                            wsaid_connectex,
-                            (void**)&pConnectEx) ||
-      !uv_get_extension_function(dummy,
-                            wsaid_acceptex,
-                            (void**)&pAcceptEx) ||
-      !uv_get_extension_function(dummy,
-                            wsaid_getacceptexsockaddrs,
-                            (void**)&pGetAcceptExSockAddrs) ||
-      !uv_get_extension_function(dummy,
-                            wsaid_disconnectex,
-                            (void**)&pDisconnectEx) ||
-      !uv_get_extension_function(dummy,
-                            wsaid_transmitfile,
-                            (void**)&pTransmitFile)) {
-    uv_fatal_error(WSAGetLastError(),
-                   "WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)");
-  }
-
-  if (closesocket(dummy) == SOCKET_ERROR) {
-    uv_fatal_error(WSAGetLastError(), "closesocket");
-  }
-
-  /* optional IPv6 versions of winsock extension functions */
-  dummy6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
-  if (dummy6 != INVALID_SOCKET) {
-    uv_allow_ipv6 = TRUE;
-
-    if (!uv_get_extension_function(dummy6,
-                              wsaid_connectex,
-                              (void**)&pConnectEx6) ||
-        !uv_get_extension_function(dummy6,
-                              wsaid_acceptex,
-                              (void**)&pAcceptEx6) ||
-        !uv_get_extension_function(dummy6,
-                              wsaid_getacceptexsockaddrs,
-                              (void**)&pGetAcceptExSockAddrs6) ||
-        !uv_get_extension_function(dummy6,
-                              wsaid_disconnectex,
-                              (void**)&pDisconnectEx6) ||
-        !uv_get_extension_function(dummy6,
-                              wsaid_transmitfile,
-                              (void**)&pTransmitFile6)) {
-      uv_allow_ipv6 = FALSE;
-    }
 
-    if (closesocket(dummy6) == SOCKET_ERROR) {
-      uv_fatal_error(WSAGetLastError(), "closesocket");
-    }
-  }
-}
-
-
-static int uv_tcp_set_socket(uv_tcp_t* handle, SOCKET socket) {
+static int uv_tcp_set_socket(uv_loop_t* loop, uv_tcp_t* handle,
+    SOCKET socket) {
   DWORD yes = 1;
 
   assert(handle->socket == INVALID_SOCKET);
 
   /* Set the socket to nonblocking mode */
   if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
-    uv_set_sys_error(WSAGetLastError());
+    uv_set_sys_error(loop, WSAGetLastError());
     return -1;
   }
 
   /* Make the socket non-inheritable */
   if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
-    uv_set_sys_error(GetLastError());
+    uv_set_sys_error(loop, GetLastError());
     return -1;
   }
 
   /* Associate it with the I/O completion port. */
   /* Use uv_handle_t pointer as completion key. */
   if (CreateIoCompletionPort((HANDLE)socket,
-                             LOOP->iocp,
+                             loop->iocp,
                              (ULONG_PTR)socket,
                              0) == NULL) {
-    uv_set_sys_error(GetLastError());
+    uv_set_sys_error(loop, GetLastError());
     return -1;
   }
 
+  if (pSetFileCompletionNotificationModes) {
+    if (pSetFileCompletionNotificationModes((HANDLE) socket,
+        FILE_SKIP_SET_EVENT_ON_HANDLE |
+        FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
+      handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
+    } else if (GetLastError() != ERROR_INVALID_FUNCTION) {
+      uv_set_sys_error(loop, GetLastError());
+      return -1;
+    }
+  }
+
   handle->socket = socket;
 
   return 0;
 }
 
 
-int uv_tcp_init(uv_tcp_t* handle) {
-  uv_stream_init((uv_stream_t*)handle);
+int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* handle) {
+  uv_stream_init(loop, (uv_stream_t*)handle);
 
+  handle->accept_reqs = NULL;
+  handle->pending_accepts = NULL;
   handle->socket = INVALID_SOCKET;
   handle->type = UV_TCP;
   handle->reqs_pending = 0;
-  handle->accept_socket = INVALID_SOCKET;
 
-  uv_counters()->tcp_init++;
+  loop->counters.tcp_init++;
 
   return 0;
 }
 
 
-void uv_tcp_endgame(uv_tcp_t* handle) {
+void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
   uv_err_t err;
   int status;
 
-  if (handle->flags & UV_HANDLE_SHUTTING &&
+  if (handle->flags & UV_HANDLE_CONNECTION &&
+      handle->flags & UV_HANDLE_SHUTTING &&
       !(handle->flags & UV_HANDLE_SHUT) &&
       handle->write_reqs_pending == 0) {
 
@@ -302,7 +124,7 @@ void uv_tcp_endgame(uv_tcp_t* handle) {
     }
     if (handle->shutdown_req->cb) {
       if (status == -1) {
-        LOOP->last_error = err;
+        loop->last_error = err;
       }
       handle->shutdown_req->cb(handle->shutdown_req, status);
     }
@@ -314,16 +136,24 @@ void uv_tcp_endgame(uv_tcp_t* handle) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     handle->flags |= UV_HANDLE_CLOSED;
 
+    if (!(handle->flags & UV_HANDLE_CONNECTION) && handle->accept_reqs) {
+      free(handle->accept_reqs);
+      handle->accept_reqs = NULL;
+    }
+
     if (handle->close_cb) {
       handle->close_cb((uv_handle_t*)handle);
     }
 
-    uv_unref();
+    active_tcp_streams--;
+
+    uv_unref(loop);
   }
 }
 
 
-static int uv__bind(uv_tcp_t* handle, int domain, struct sockaddr* addr, int addrsize) {
+static int uv__bind(uv_loop_t* loop, uv_tcp_t* handle, int domain,
+    struct sockaddr* addr, int addrsize) {
   DWORD err;
   int r;
   SOCKET sock;
@@ -331,11 +161,11 @@ static int uv__bind(uv_tcp_t* handle, int domain, struct sockaddr* addr, int add
   if (handle->socket == INVALID_SOCKET) {
     sock = socket(domain, SOCK_STREAM, 0);
     if (sock == INVALID_SOCKET) {
-      uv_set_sys_error(WSAGetLastError());
+      uv_set_sys_error(loop, WSAGetLastError());
       return -1;
     }
 
-    if (uv_tcp_set_socket(handle, sock) == -1) {
+    if (uv_tcp_set_socket(loop, handle, sock) == -1) {
       closesocket(sock);
       return -1;
     }
@@ -347,10 +177,10 @@ static int uv__bind(uv_tcp_t* handle, int domain, struct sockaddr* addr, int add
     err = WSAGetLastError();
     if (err == WSAEADDRINUSE) {
       /* Some errors are not to be reported until connect() or listen() */
-      handle->error = uv_new_sys_error(err);
+      handle->bind_error = uv_new_sys_error(err);
       handle->flags |= UV_HANDLE_BIND_ERROR;
     } else {
-      uv_set_sys_error(err);
+      uv_set_sys_error(loop, err);
       return -1;
     }
   }
@@ -362,32 +192,46 @@ static int uv__bind(uv_tcp_t* handle, int domain, struct sockaddr* addr, int add
 
 
 int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
+  uv_loop_t* loop = handle->loop;
+
   if (addr.sin_family != AF_INET) {
-    uv_set_sys_error(WSAEFAULT);
+    uv_set_sys_error(loop, WSAEFAULT);
     return -1;
   }
 
-  return uv__bind(handle, AF_INET, (struct sockaddr*)&addr, sizeof(struct sockaddr_in));
+  return uv__bind(loop,
+                  handle,
+                  AF_INET,
+                  (struct sockaddr*)&addr,
+                  sizeof(struct sockaddr_in));
 }
 
 
 int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
+  uv_loop_t* loop = handle->loop;
+
   if (addr.sin6_family != AF_INET6) {
-    uv_set_sys_error(WSAEFAULT);
+    uv_set_sys_error(loop, WSAEFAULT);
     return -1;
   }
+
   if (uv_allow_ipv6) {
     handle->flags |= UV_HANDLE_IPV6;
-    return uv__bind(handle, AF_INET6, (struct sockaddr*)&addr, sizeof(struct sockaddr_in6));
+    return uv__bind(loop,
+                    handle,
+                    AF_INET6,
+                    (struct sockaddr*)&addr,
+                    sizeof(struct sockaddr_in6));
+
   } else {
-    uv_new_sys_error(UV_EAFNOSUPPORT);
+    uv_set_sys_error(loop, WSAEAFNOSUPPORT);
     return -1;
   }
 }
 
 
-static void uv_tcp_queue_accept(uv_tcp_t* handle) {
-  uv_req_t* req;
+static void uv_tcp_queue_accept(uv_tcp_t* handle, uv_tcp_accept_t* req) {
+  uv_loop_t* loop = handle->loop;
   BOOL success;
   DWORD bytes;
   SOCKET accept_socket;
@@ -395,10 +239,7 @@ static void uv_tcp_queue_accept(uv_tcp_t* handle) {
   LPFN_ACCEPTEX pAcceptExFamily;
 
   assert(handle->flags & UV_HANDLE_LISTENING);
-  assert(handle->accept_socket == INVALID_SOCKET);
-
-  /* Prepare the uv_req structure. */
-  req = &handle->accept_req;
+  assert(req->accept_socket == INVALID_SOCKET);
 
   /* choose family and extension function */
   if ((handle->flags & UV_HANDLE_IPV6) != 0) {
@@ -412,8 +253,8 @@ static void uv_tcp_queue_accept(uv_tcp_t* handle) {
   /* Open a socket for the accepted connection. */
   accept_socket = socket(family, SOCK_STREAM, 0);
   if (accept_socket == INVALID_SOCKET) {
-    req->error = uv_new_sys_error(WSAGetLastError());
-    uv_insert_pending_req(req);
+    SET_REQ_ERROR(req, WSAGetLastError());
+    uv_insert_pending_req(loop, (uv_req_t*)req);
     handle->reqs_pending++;
     return;
   }
@@ -423,30 +264,34 @@ static void uv_tcp_queue_accept(uv_tcp_t* handle) {
 
   success = pAcceptExFamily(handle->socket,
                           accept_socket,
-                          (void*)&handle->accept_buffer,
+                          (void*)req->accept_buffer,
                           0,
                           sizeof(struct sockaddr_storage),
                           sizeof(struct sockaddr_storage),
                           &bytes,
                           &req->overlapped);
 
-  if (!success && WSAGetLastError() != ERROR_IO_PENDING) {
+  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
+    /* Process the req without IOCP. */
+    req->accept_socket = accept_socket;
+    handle->reqs_pending++;
+    uv_insert_pending_req(loop, (uv_req_t*)req);
+  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
+    /* The req will be processed with IOCP. */
+    req->accept_socket = accept_socket;
+    handle->reqs_pending++;
+  } else {
     /* Make this req pending reporting an error. */
-    req->error = uv_new_sys_error(WSAGetLastError());
-    uv_insert_pending_req(req);
+    SET_REQ_ERROR(req, WSAGetLastError());
+    uv_insert_pending_req(loop, (uv_req_t*)req);
     handle->reqs_pending++;
     /* Destroy the preallocated client socket. */
     closesocket(accept_socket);
-    return;
   }
-
-  handle->accept_socket = accept_socket;
-
-  handle->reqs_pending++;
 }
 
 
-static void uv_tcp_queue_read(uv_tcp_t* handle) {
+static void uv_tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) {
   uv_req_t* req;
   uv_buf_t buf;
   int result;
@@ -458,8 +303,20 @@ static void uv_tcp_queue_read(uv_tcp_t* handle) {
   req = &handle->read_req;
   memset(&req->overlapped, 0, sizeof(req->overlapped));
 
-  buf.base = (char*) &uv_zero_;
-  buf.len = 0;
+  /*
+   * Preallocate a read buffer if the number of active streams is below
+   * the threshold.
+  */
+  if (active_tcp_streams < uv_active_tcp_streams_threshold) {
+    handle->flags &= ~UV_HANDLE_ZERO_READ;
+    handle->read_buffer = handle->alloc_cb((uv_handle_t*) handle, 65536);
+    assert(handle->read_buffer.len > 0);
+    buf = handle->read_buffer;
+  } else {
+    handle->flags |= UV_HANDLE_ZERO_READ;
+    buf.base = (char*) &uv_zero_;
+    buf.len = 0;
+  }
 
   flags = 0;
   result = WSARecv(handle->socket,
@@ -469,31 +326,42 @@ static void uv_tcp_queue_read(uv_tcp_t* handle) {
                    &flags,
                    &req->overlapped,
                    NULL);
-  if (result != 0 && WSAGetLastError() != ERROR_IO_PENDING) {
+
+  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
+    /* Process the req without IOCP. */
+    handle->flags |= UV_HANDLE_READ_PENDING;
+    req->overlapped.InternalHigh = bytes;
+    handle->reqs_pending++;
+    uv_insert_pending_req(loop, req);
+  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
+    /* The req will be processed with IOCP. */
+    handle->flags |= UV_HANDLE_READ_PENDING;
+    handle->reqs_pending++;
+  } else {
     /* Make this req pending reporting an error. */
-    req->error = uv_new_sys_error(WSAGetLastError());
-    uv_insert_pending_req(req);
+    SET_REQ_ERROR(req, WSAGetLastError());
+    uv_insert_pending_req(loop, req);
     handle->reqs_pending++;
-    return;
   }
-
-  handle->flags |= UV_HANDLE_READ_PENDING;
-  handle->reqs_pending++;
 }
 
 
 int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
+  uv_loop_t* loop = handle->loop;
+  unsigned int i;
+  uv_tcp_accept_t* req;
+
   assert(backlog > 0);
 
   if (handle->flags & UV_HANDLE_BIND_ERROR) {
-    LOOP->last_error = handle->error;
+    loop->last_error = handle->bind_error;
     return -1;
   }
 
   if (handle->flags & UV_HANDLE_LISTENING ||
       handle->flags & UV_HANDLE_READING) {
     /* Already listening. */
-    uv_set_sys_error(WSAEALREADY);
+    uv_set_sys_error(loop, WSAEALREADY);
     return -1;
   }
 
@@ -502,60 +370,88 @@ int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
     return -1;
 
   if (listen(handle->socket, backlog) == SOCKET_ERROR) {
-    uv_set_sys_error(WSAGetLastError());
+    uv_set_sys_error(loop, WSAGetLastError());
     return -1;
   }
 
   handle->flags |= UV_HANDLE_LISTENING;
   handle->connection_cb = cb;
 
-  uv_req_init(&(handle->accept_req));
-  handle->accept_req.type = UV_ACCEPT;
-  handle->accept_req.data = handle;
-  uv_tcp_queue_accept(handle);
+  assert(!handle->accept_reqs);
+  handle->accept_reqs = (uv_tcp_accept_t*)
+    malloc(uv_simultaneous_server_accepts * sizeof(uv_tcp_accept_t));
+  if (!handle->accept_reqs) {
+    uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
+  }
+
+  for (i = 0; i < uv_simultaneous_server_accepts; i++) {
+    req = &handle->accept_reqs[i];
+    uv_req_init(loop, (uv_req_t*)req);
+    req->type = UV_ACCEPT;
+    req->accept_socket = INVALID_SOCKET;
+    req->data = handle;
+    uv_tcp_queue_accept(handle, req);
+  }
 
   return 0;
 }
 
 
 int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
+  uv_loop_t* loop = server->loop;
   int rv = 0;
 
-  if (server->accept_socket == INVALID_SOCKET) {
-    uv_set_sys_error(WSAENOTCONN);
+  uv_tcp_accept_t* req = server->pending_accepts;
+
+  if (!req) {
+    /* No valid connections found, so we error out. */
+    uv_set_sys_error(loop, WSAEWOULDBLOCK);
+    return -1;
+  }
+
+  if (req->accept_socket == INVALID_SOCKET) {
+    uv_set_sys_error(loop, WSAENOTCONN);
     return -1;
   }
 
-  if (uv_tcp_set_socket(client, server->accept_socket) == -1) {
-    closesocket(server->accept_socket);
+  if (uv_tcp_set_socket(client->loop, client, req->accept_socket) == -1) {
+    closesocket(req->accept_socket);
     rv = -1;
   } else {
-    uv_connection_init((uv_stream_t*)client);
+    uv_connection_init((uv_stream_t*) client);
   }
 
-  server->accept_socket = INVALID_SOCKET;
+  /* Prepare the req to pick up a new connection */
+  server->pending_accepts = req->next_pending;
+  req->next_pending = NULL;
+  req->accept_socket = INVALID_SOCKET;
 
   if (!(server->flags & UV_HANDLE_CLOSING)) {
-    uv_tcp_queue_accept(server);
+    uv_tcp_queue_accept(server, req);
   }
 
+  active_tcp_streams++;
+
   return rv;
 }
 
 
-int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb) {
+int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
+    uv_read_cb read_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_READING) {
-    uv_set_sys_error(WSAEALREADY);
+    uv_set_sys_error(loop, WSAEALREADY);
     return -1;
   }
 
   if (handle->flags & UV_HANDLE_EOF) {
-    uv_set_sys_error(WSAESHUTDOWN);
+    uv_set_sys_error(loop, WSAESHUTDOWN);
     return -1;
   }
 
@@ -566,7 +462,7 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb
   /* If reading was stopped and then started again, there could stell be a */
   /* read request pending. */
   if (!(handle->flags & UV_HANDLE_READ_PENDING))
-    uv_tcp_queue_read(handle);
+    uv_tcp_queue_read(loop, handle);
 
   return 0;
 }
@@ -574,17 +470,18 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb
 
 int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
     struct sockaddr_in address, uv_connect_cb cb) {
+  uv_loop_t* loop = handle->loop;
   int addrsize = sizeof(struct sockaddr_in);
   BOOL success;
   DWORD bytes;
 
   if (handle->flags & UV_HANDLE_BIND_ERROR) {
-    LOOP->last_error = handle->error;
+    loop->last_error = handle->bind_error;
     return -1;
   }
 
   if (address.sin_family != AF_INET) {
-    uv_set_sys_error(WSAEFAULT);
+    uv_set_sys_error(loop, WSAEFAULT);
     return -1;
   }
 
@@ -592,7 +489,7 @@ int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
       uv_tcp_bind(handle, uv_addr_ip4_any_) < 0)
     return -1;
 
-  uv_req_init((uv_req_t*) req);
+  uv_req_init(loop, (uv_req_t*) req);
   req->type = UV_CONNECT;
   req->handle = (uv_stream_t*) handle;
   req->cb = cb;
@@ -606,35 +503,41 @@ int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
                        &bytes,
                        &req->overlapped);
 
-  if (!success && WSAGetLastError() != ERROR_IO_PENDING) {
-    uv_set_sys_error(WSAGetLastError());
+  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
+    /* Process the req without IOCP. */
+    handle->reqs_pending++;
+    uv_insert_pending_req(loop, (uv_req_t*)req);
+  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
+    /* The req will be processed with IOCP. */
+    handle->reqs_pending++;
+  } else {
+    uv_set_sys_error(loop, WSAGetLastError());
     return -1;
   }
 
-  handle->reqs_pending++;
-
   return 0;
 }
 
 
 int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
     struct sockaddr_in6 address, uv_connect_cb cb) {
+  uv_loop_t* loop = handle->loop;
   int addrsize = sizeof(struct sockaddr_in6);
   BOOL success;
   DWORD bytes;
 
   if (!uv_allow_ipv6) {
-    uv_new_sys_error(UV_EAFNOSUPPORT);
+    uv_new_sys_error(WSAEAFNOSUPPORT);
     return -1;
   }
 
   if (handle->flags & UV_HANDLE_BIND_ERROR) {
-    LOOP->last_error = handle->error;
+    loop->last_error = handle->bind_error;
     return -1;
   }
 
   if (address.sin6_family != AF_INET6) {
-    uv_set_sys_error(WSAEFAULT);
+    uv_set_sys_error(loop, WSAEFAULT);
     return -1;
   }
 
@@ -642,7 +545,7 @@ int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
       uv_tcp_bind6(handle, uv_addr_ip6_any_) < 0)
     return -1;
 
-  uv_req_init((uv_req_t*) req);
+  uv_req_init(loop, (uv_req_t*) req);
   req->type = UV_CONNECT;
   req->handle = (uv_stream_t*) handle;
   req->cb = cb;
@@ -656,28 +559,32 @@ int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
                        &bytes,
                        &req->overlapped);
 
-  if (!success && WSAGetLastError() != ERROR_IO_PENDING) {
-    uv_set_sys_error(WSAGetLastError());
+  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
+    handle->reqs_pending++;
+    uv_insert_pending_req(loop, (uv_req_t*)req);
+  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
+    handle->reqs_pending++;
+  } else {
+    uv_set_sys_error(loop, WSAGetLastError());
     return -1;
   }
 
-  handle->reqs_pending++;
-
   return 0;
 }
 
 
-int uv_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen) {
+int uv_tcp_getsockname(uv_loop_t* loop, uv_tcp_t* handle,
+    struct sockaddr* name, int* namelen) {
   int result;
 
   if (handle->flags & UV_HANDLE_SHUTTING) {
-    uv_set_sys_error(WSAESHUTDOWN);
+    uv_set_sys_error(loop, WSAESHUTDOWN);
     return -1;
   }
 
   result = getsockname(handle->socket, name, namelen);
   if (result != 0) {
-    uv_set_sys_error(WSAGetLastError());
+    uv_set_sys_error(loop, WSAGetLastError());
     return -1;
   }
 
@@ -685,22 +592,22 @@ int uv_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen) {
 }
 
 
-int uv_tcp_write(uv_write_t* req, uv_tcp_t* handle, uv_buf_t bufs[], int bufcnt,
-    uv_write_cb 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 result;
-  DWORD bytes, err;
+  DWORD bytes;
 
   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_WRITE;
   req->handle = (uv_stream_t*) handle;
   req->cb = cb;
@@ -713,32 +620,31 @@ int uv_tcp_write(uv_write_t* req, uv_tcp_t* handle, uv_buf_t bufs[], int bufcnt,
                    0,
                    &req->overlapped,
                    NULL);
-  if (result != 0) {
-    err = WSAGetLastError();
-    if (err != WSA_IO_PENDING) {
-      /* Send failed due to an error. */
-      uv_set_sys_error(WSAGetLastError());
-      return -1;
-    }
-  }
 
-  if (result == 0) {
+  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
     /* Request completed immediately. */
     req->queued_bytes = 0;
-  } else {
+    handle->reqs_pending++;
+    handle->write_reqs_pending++;
+    uv_insert_pending_req(loop, (uv_req_t*) req);
+  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
     /* Request queued by the kernel. */
     req->queued_bytes = uv_count_bufs(bufs, bufcnt);
+    handle->reqs_pending++;
+    handle->write_reqs_pending++;
     handle->write_queue_size += req->queued_bytes;
+  } else {
+    /* Send failed due to an error. */
+    uv_set_sys_error(loop, WSAGetLastError());
+    return -1;
   }
 
-  handle->reqs_pending++;
-  handle->write_reqs_pending++;
-
   return 0;
 }
 
 
-void uv_process_tcp_read_req(uv_tcp_t* handle, uv_req_t* req) {
+void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
+    uv_req_t* req) {
   DWORD bytes, flags, err;
   uv_buf_t buf;
 
@@ -746,19 +652,43 @@ void uv_process_tcp_read_req(uv_tcp_t* handle, uv_req_t* req) {
 
   handle->flags &= ~UV_HANDLE_READ_PENDING;
 
-  if (req->error.code != UV_OK) {
-    /* An error occurred doing the 0-read. */
+  if (!REQ_SUCCESS(req)) {
+    /* An error occurred doing the read. */
     if ((handle->flags & UV_HANDLE_READING)) {
       handle->flags &= ~UV_HANDLE_READING;
-      LOOP->last_error = req->error;
-      buf.base = 0;
-      buf.len = 0;
+      loop->last_error = GET_REQ_UV_SOCK_ERROR(req);
+      buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
+            uv_buf_init(NULL, 0) : handle->read_buffer;
       handle->read_cb((uv_stream_t*)handle, -1, buf);
     }
   } else {
+    if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
+      /* The read was done with a non-zero buffer length. */
+      if (req->overlapped.InternalHigh > 0) {
+        /* Successful read */
+        handle->read_cb((uv_stream_t*)handle,
+                        req->overlapped.InternalHigh,
+                        handle->read_buffer);
+        /* Read again only if bytes == buf.len */
+        if (req->overlapped.InternalHigh < handle->read_buffer.len) {
+          goto done;
+        }
+      } else {
+        /* Connection closed */
+        handle->flags &= ~UV_HANDLE_READING;
+        handle->flags |= UV_HANDLE_EOF;
+        loop->last_error.code = UV_EOF;
+        loop->last_error.sys_errno_ = ERROR_SUCCESS;
+        buf.base = 0;
+        buf.len = 0;
+        handle->read_cb((uv_stream_t*)handle, -1, handle->read_buffer);
+        goto done;
+      }
+    }
+
     /* Do nonblocking reads until the buffer is empty */
     while (handle->flags & UV_HANDLE_READING) {
-      buf = handle->alloc_cb((uv_stream_t*)handle, 65536);
+      buf = handle->alloc_cb((uv_handle_t*) handle, 65536);
       assert(buf.len > 0);
       flags = 0;
       if (WSARecv(handle->socket,
@@ -779,8 +709,8 @@ void uv_process_tcp_read_req(uv_tcp_t* handle, uv_req_t* req) {
           /* Connection closed */
           handle->flags &= ~UV_HANDLE_READING;
           handle->flags |= UV_HANDLE_EOF;
-          LOOP->last_error.code = UV_EOF;
-          LOOP->last_error.sys_errno_ = ERROR_SUCCESS;
+          loop->last_error.code = UV_EOF;
+          loop->last_error.sys_errno_ = ERROR_SUCCESS;
           handle->read_cb((uv_stream_t*)handle, -1, buf);
           break;
         }
@@ -788,21 +718,23 @@ void uv_process_tcp_read_req(uv_tcp_t* handle, uv_req_t* req) {
         err = WSAGetLastError();
         if (err == WSAEWOULDBLOCK) {
           /* Read buffer was completely empty, report a 0-byte read. */
-          uv_set_sys_error(WSAEWOULDBLOCK);
+          uv_set_sys_error(loop, WSAEWOULDBLOCK);
           handle->read_cb((uv_stream_t*)handle, 0, buf);
         } else {
           /* Ouch! serious error. */
-          uv_set_sys_error(err);
+          uv_set_sys_error(loop, err);
+          handle->flags &= ~UV_HANDLE_READING;
           handle->read_cb((uv_stream_t*)handle, -1, buf);
         }
         break;
       }
     }
 
-    /* Post another 0-read if still reading and not closing. */
+done:
+    /* Post another read if still reading and not closing. */
     if ((handle->flags & UV_HANDLE_READING) &&
         !(handle->flags & UV_HANDLE_READ_PENDING)) {
-      uv_tcp_queue_read(handle);
+      uv_tcp_queue_read(loop, handle);
     }
   }
 
@@ -810,47 +742,54 @@ void uv_process_tcp_read_req(uv_tcp_t* handle, uv_req_t* req) {
 }
 
 
-void uv_process_tcp_write_req(uv_tcp_t* handle, uv_write_t* req) {
+void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
+    uv_write_t* req) {
   assert(handle->type == UV_TCP);
 
   handle->write_queue_size -= req->queued_bytes;
 
   if (req->cb) {
-    LOOP->last_error = req->error;
-    ((uv_write_cb)req->cb)(req, LOOP->last_error.code == UV_OK ? 0 : -1);
+    loop->last_error = GET_REQ_UV_SOCK_ERROR(req);
+    ((uv_write_cb)req->cb)(req, loop->last_error.code == UV_OK ? 0 : -1);
   }
 
   handle->write_reqs_pending--;
   if (handle->flags & UV_HANDLE_SHUTTING &&
       handle->write_reqs_pending == 0) {
-    uv_want_endgame((uv_handle_t*)handle);
+    uv_want_endgame(loop, (uv_handle_t*)handle);
   }
 
   DECREASE_PENDING_REQ_COUNT(handle);
 }
 
 
-void uv_process_tcp_accept_req(uv_tcp_t* handle, uv_req_t* req) {
+void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle,
+    uv_req_t* raw_req) {
+  uv_tcp_accept_t* req = (uv_tcp_accept_t*) raw_req;
+
   assert(handle->type == UV_TCP);
 
   /* If handle->accepted_socket is not a valid socket, then */
   /* uv_queue_accept must have failed. This is a serious error. We stop */
   /* accepting connections and report this error to the connection */
   /* callback. */
-  if (handle->accept_socket == INVALID_SOCKET) {
+  if (req->accept_socket == INVALID_SOCKET) {
     if (handle->flags & UV_HANDLE_LISTENING) {
       handle->flags &= ~UV_HANDLE_LISTENING;
       if (handle->connection_cb) {
-        LOOP->last_error = req->error;
+        loop->last_error = GET_REQ_UV_SOCK_ERROR(req);
         handle->connection_cb((uv_stream_t*)handle, -1);
       }
     }
-  } else if (req->error.code == UV_OK &&
-      setsockopt(handle->accept_socket,
+  } else if (REQ_SUCCESS(req) &&
+      setsockopt(req->accept_socket,
                   SOL_SOCKET,
                   SO_UPDATE_ACCEPT_CONTEXT,
                   (char*)&handle->socket,
                   sizeof(handle->socket)) == 0) {
+    req->next_pending = handle->pending_accepts;
+    handle->pending_accepts = req;
+
     /* Accept and SO_UPDATE_ACCEPT_CONTEXT were successful. */
     if (handle->connection_cb) {
       handle->connection_cb((uv_stream_t*)handle, 0);
@@ -859,9 +798,10 @@ void uv_process_tcp_accept_req(uv_tcp_t* handle, uv_req_t* req) {
     /* Error related to accepted socket is ignored because the server */
     /* socket may still be healthy. If the server socket is broken
     /* uv_queue_accept will detect it. */
-    closesocket(handle->accept_socket);
+    closesocket(req->accept_socket);
+    req->accept_socket = INVALID_SOCKET;
     if (handle->flags & UV_HANDLE_LISTENING) {
-      uv_tcp_queue_accept(handle);
+      uv_tcp_queue_accept(handle, req);
     }
   }
 
@@ -869,24 +809,26 @@ void uv_process_tcp_accept_req(uv_tcp_t* handle, uv_req_t* req) {
 }
 
 
-void uv_process_tcp_connect_req(uv_tcp_t* handle, uv_connect_t* req) {
+void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
+    uv_connect_t* req) {
   assert(handle->type == UV_TCP);
 
   if (req->cb) {
-    if (req->error.code == UV_OK) {
+    if (REQ_SUCCESS(req)) {
       if (setsockopt(handle->socket,
                       SOL_SOCKET,
                       SO_UPDATE_CONNECT_CONTEXT,
                       NULL,
                       0) == 0) {
         uv_connection_init((uv_stream_t*)handle);
+        active_tcp_streams++;
         ((uv_connect_cb)req->cb)(req, 0);
       } else {
-        uv_set_sys_error(WSAGetLastError());
+        uv_set_sys_error(loop, WSAGetLastError());
         ((uv_connect_cb)req->cb)(req, -1);
       }
     } else {
-      LOOP->last_error = req->error;
+      loop->last_error = GET_REQ_UV_SOCK_ERROR(req);
       ((uv_connect_cb)req->cb)(req, -1);
     }
   }