Windows implementation of new request API

This changes uv-win to use the new uv_req subclasses.

It gets rid of the uv_req.flags field. There used to be only request flag
(UV_REQ_PENDING), and it was mostly obsolete; it only had a real purpose for
internal uv_read requests. Now we'll use the UV_HANDLE_READ_PENDING flag on
the handle instead.

This patch also simplifies the accept logic for named pipes on windows. We
no longer have a separate struct to store information about established
connections. Instead we just carry over the windows HANDLE from the accept
request to the client handle in uv_pipe_accept().

include/uv-win.h

@@ -42,22 +42,6 @@ typedef struct uv_buf_t {
   char* base;
 } uv_buf_t;
 
-/*
- * Private uv_pipe_instance state.
- */
-typedef enum {
-  UV_PIPEINSTANCE_CONNECTED = 0,
-  UV_PIPEINSTANCE_DISCONNECTED,
-  UV_PIPEINSTANCE_ACTIVE
-} uv_pipeinstance_state;
-
-/* Used to store active pipe instances inside a linked list. */
-typedef struct uv_pipe_instance_s {
-  HANDLE handle;
-  uv_pipeinstance_state state;
-  struct uv_pipe_instance_s* next;
-} uv_pipe_instance_t;
-
 #define UV_REQ_PRIVATE_FIELDS             \
   union {                                 \
     /* Used by I/O operations */          \
@@ -66,13 +50,21 @@ typedef struct uv_pipe_instance_s {
       size_t queued_bytes;                \
     };                                    \
   };                                      \
-  int flags;                              \
   uv_err_t error;                         \
   struct uv_req_s* next_req;
 
+#define UV_WRITE_PRIVATE_FIELDS           \
+  /* empty */
+
+#define UV_CONNECT_PRIVATE_FIELDS         \
+  /* empty */
+
+#define UV_SHUTDOWN_PRIVATE_FIELDS        \
+  /* empty */
+
 #define uv_stream_connection_fields       \
   unsigned int write_reqs_pending;        \
-  uv_req_t* shutdown_req;
+  uv_shutdown_t* shutdown_req;
 
 #define uv_stream_server_fields           \
   uv_connection_cb connection_cb;
@@ -81,7 +73,7 @@ typedef struct uv_pipe_instance_s {
   unsigned int reqs_pending;              \
   uv_alloc_cb alloc_cb;                   \
   uv_read_cb read_cb;                     \
-  struct uv_req_s read_req;               \
+  uv_req_t read_req;                      \
   union {                                 \
     struct { uv_stream_connection_fields };  \
     struct { uv_stream_server_fields     };  \
@@ -94,17 +86,19 @@ typedef struct uv_pipe_instance_s {
   };                                      \
   SOCKET accept_socket;                   \
   char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32]; \
-  struct uv_req_s accept_req;
+  struct uv_req_s accept_req;             \
 
 #define uv_pipe_server_fields             \
     char* name;                           \
-    uv_pipe_instance_t* connections;      \
-    struct uv_req_s accept_reqs[4];
+    struct uv_pipe_accept_s {             \
+      UV_REQ_FIELDS                       \
+      HANDLE pipeHandle;                  \
+      struct uv_pipe_accept_s* next_pending; \
+    } accept_reqs[4];                     \
+    struct uv_pipe_accept_s* pending_accepts;
 
 #define uv_pipe_connection_fields         \
-    uv_pipe_t* server;                    \
-    uv_pipe_instance_t* connection;       \
-    uv_pipe_instance_t clientConnection;
+  HANDLE handle;
 
 #define UV_PIPE_PRIVATE_FIELDS            \
   union {                                 \
@@ -120,6 +114,7 @@ typedef struct uv_pipe_instance_s {
 
 #define UV_ASYNC_PRIVATE_FIELDS           \
   struct uv_req_s async_req;              \
+  uv_async_cb async_cb;                   \
   /* char to avoid alignment issues */    \
   char volatile async_sent;
 

include/uv.h

@@ -291,7 +291,7 @@ struct uv_write_s {
 };
 
 int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
-    uv_write_cb);
+    uv_write_cb cb);
 
 
 /*
@@ -310,7 +310,7 @@ int uv_tcp_init(uv_tcp_t* handle);
 int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in);
 int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6);
 
-/* 
+/*
  * uv_tcp_connect, uv_tcp_connect6
  * These functions establish IPv4 and IPv6 TCP connections. Provide an
  * initialized TCP handle and an uninitialized uv_connect_t*. The callback
@@ -319,7 +319,7 @@ int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6);
 struct uv_connect_s {
   UV_REQ_FIELDS
   uv_connect_cb cb;
-  uv_tcp_t* handle;
+  uv_stream_t* handle;
   UV_CONNECT_PRIVATE_FIELDS
 };
 
@@ -336,10 +336,10 @@ int uv_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen);
 /*
  * A subclass of uv_stream_t representing a pipe stream or pipe server.
  */
-struct uv_pipe_s { 
-  UV_HANDLE_FIELDS 
-  UV_STREAM_FIELDS 
-  UV_PIPE_PRIVATE_FIELDS 
+struct uv_pipe_s {
+  UV_HANDLE_FIELDS
+  UV_STREAM_FIELDS
+  UV_PIPE_PRIVATE_FIELDS
 };
 
 int uv_pipe_init(uv_pipe_t* handle);
@@ -348,7 +348,8 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name);
 
 int uv_pipe_listen(uv_pipe_t* handle, uv_connection_cb cb);
 
-int uv_pipe_connect(uv_req_t* req, const char* name);
+int uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
+    const char* name, uv_connect_cb cb);
 
 
 /*

test/test-connection-fail.c

@@ -67,7 +67,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
 
 
 static void on_connect_with_close(uv_connect_t *req, int status) {
-  ASSERT(&tcp == req->handle);
+  ASSERT((uv_stream_t*) &tcp == req->handle);
   ASSERT(status == -1);
   ASSERT(uv_last_error().code == UV_ECONNREFUSED);
   connect_cb_calls++;

test/test-getsockname.c

@@ -29,7 +29,7 @@ static int getsocknamecount = 0;
 
 
 static uv_tcp_t tcp;
-static uv_req_t connect_req;
+static uv_connect_t connect_req;
 static uv_tcp_t tcpServer;
 
 
@@ -47,22 +47,23 @@ static void on_close(uv_handle_t* peer) {
 }
 
 
-static void after_shutdown(uv_req_t* req, int status) {
-  uv_close(req->handle, on_close);
+static void after_shutdown(uv_shutdown_t* req, int status) {
+  uv_close((uv_handle_t*) req->handle, on_close);
   free(req);
 }
 
 
 static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
-  uv_req_t* req;
+  uv_shutdown_t* req;
+  int r;
 
   if (buf.base) {
     free(buf.base);
   }
 
-  req = (uv_req_t*) malloc(sizeof *req);
-  uv_req_init(req, (uv_handle_t*)handle, (void *(*)(void *))after_shutdown);
-  uv_shutdown(req);
+  req = (uv_shutdown_t*) malloc(sizeof *req);
+  r = uv_shutdown(req, handle, after_shutdown);
+  ASSERT(r == 0);
 }
 
 
@@ -102,16 +103,18 @@ static void on_connection(uv_handle_t* server, int status) {
 }
 
 
-static void on_connect(void* req) {
+static void on_connect(uv_connect_t* req, int status) {
   struct sockaddr sockname;
   int namelen = sizeof(sockname);
-  int status;
+  int r;
 
-  status = uv_getsockname(&tcp, &sockname, &namelen);
-  if (status != 0) {
+  ASSERT(status == 0);
+
+  r = uv_getsockname(&tcp, &sockname, &namelen);
+  if (r != 0) {
     fprintf(stderr, "uv_getsockname error (connector) %d\n", uv_last_error().code);
   }
-  ASSERT(status == 0);
+  ASSERT(r == 0);
 
   getsocknamecount++;
 
@@ -162,9 +165,7 @@ static void tcp_connector() {
   tcp.data = &connect_req;
   ASSERT(!r);
 
-  uv_req_init(&connect_req, (uv_handle_t*)(&tcp), (void *(*)(void *))on_connect);
-
-  r = uv_tcp_connect(&connect_req, server_addr);
+  r = uv_tcp_connect(&connect_req, &tcp, server_addr, on_connect);
   ASSERT(!r);
 }
 

test/test-ping-pong.c

@@ -158,7 +158,7 @@ static void tcp_pinger_v6_new() {
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  r = uv_tcp_connect(&pinger->connect_req, &pinger->tcp, server_addr,
+  r = uv_tcp_connect6(&pinger->connect_req, &pinger->tcp, server_addr,
       pinger_on_connect);
   ASSERT(!r);
 }
@@ -180,10 +180,7 @@ static void tcp_pinger_new() {
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  uv_req_init(&pinger->connect_req, (uv_handle_t*)(&pinger->tcp),
-      (void *(*)(void *))pinger_on_connect);
-
-  r = uv_tcp_connect(&pinger->connect_req, server_addr);
+  r = uv_tcp_connect(&pinger->connect_req, &pinger->tcp, server_addr, pinger_on_connect);
   ASSERT(!r);
 }
 
@@ -204,8 +201,7 @@ static void pipe_pinger_new() {
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
 
-  r = uv_tcp_connect6(&pinger->connect_req, &pinger->tcp, server_addr,
-      pinger_on_connect);
+  r = uv_pipe_connect(&pinger->connect_req, &pinger->pipe, TEST_PIPENAME, pinger_on_connect);
   ASSERT(!r);
 }