Upgrade libuv to 2c0fca9a41

deps/uv/common.gypi

@@ -32,6 +32,11 @@
             'LinkIncremental': 2, # enable incremental linking
           },
         },
+        'conditions': [
+          ['OS != "win"', {
+            'defines': [ 'EV_VERIFY=2' ],
+          }],
+        ]
       },
       'Release': {
         'defines': [ 'NDEBUG' ],

deps/uv/include/uv-private/uv-win.h

@@ -117,6 +117,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
     HANDLE pipeHandle;                    \
     struct uv_pipe_accept_s* next_pending; \
   } uv_pipe_accept_t;                     \
+                                          \
   typedef struct uv_tcp_accept_s {        \
     UV_REQ_FIELDS                         \
     SOCKET accept_socket;                 \
@@ -181,6 +182,31 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
     struct { uv_pipe_connection_fields }; \
   };
 
+/* TODO: put the parser states in an union - TTY handles are always */
+/* half-duplex so read-state can safely overlap write-state. */
+#define UV_TTY_PRIVATE_FIELDS             \
+  HANDLE handle;                          \
+  HANDLE read_line_handle;                \
+  uv_buf_t read_line_buffer;              \
+  HANDLE read_raw_wait;                   \
+  DWORD original_console_mode;            \
+  /* Fields used for translating win */   \
+  /* keystrokes into vt100 characters */  \
+  char last_key[8];                       \
+  unsigned char last_key_offset;          \
+  unsigned char last_key_len;             \
+  INPUT_RECORD last_input_record;         \
+  WCHAR last_utf16_high_surrogate;        \
+  /* utf8-to-utf16 conversion state */    \
+  unsigned char utf8_bytes_left;          \
+  unsigned int utf8_codepoint;            \
+  /* eol conversion state */              \
+  unsigned char previous_eol;             \
+  /* ansi parser state */                 \
+  unsigned char ansi_parser_state;        \
+  unsigned char ansi_csi_argc;            \
+  unsigned short ansi_csi_argv[4];
+
 #define UV_TIMER_PRIVATE_FIELDS           \
   RB_ENTRY(uv_timer_s) tree_entry;        \
   int64_t due;                            \
@@ -273,8 +299,6 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
   int is_path_dir;                        \
   char* buffer;
 
-#define UV_TTY_PRIVATE_FIELDS /* empty */
-
 int uv_utf16_to_utf8(const wchar_t* utf16Buffer, size_t utf16Size,
     char* utf8Buffer, size_t utf8Size);
 int uv_utf8_to_utf16(const char* utf8Buffer, wchar_t* utf16Buffer,

deps/uv/src/unix/cares.c

@@ -67,6 +67,7 @@ static uv_ares_task_t* uv__ares_task_create(int fd) {
 
   if (h == NULL) {
     uv_fatal_error(ENOMEM, "malloc");
+    return NULL;
   }
 
   h->sock = fd;

deps/uv/src/unix/fs.c

@@ -149,19 +149,20 @@ static int uv__fs_after(eio_req* eio) {
     case UV_FS_READLINK:
       if (req->result == -1) {
         req->ptr = NULL;
-      } else {
-        assert(req->result > 0);
-
-        if ((name = realloc(req->eio->ptr2, req->result + 1)) == NULL) {
-          /* Not enough memory. Reuse buffer, chop off last byte. */
-          name = req->eio->ptr2;
-          req->result--;
+        break;
       }
+      assert(req->result > 0);
 
+      /* Make zero-terminated copy of req->eio->ptr2 */
+      if ((req->ptr = name = malloc(req->result + 1))) {
+        memcpy(name, req->eio->ptr2, req->result);
         name[req->result] = '\0';
-        req->ptr = name;
         req->result = 0;
       }
+      else {
+        req->errorno = ENOMEM;
+        req->result = -1;
+      }
       break;
 
     default:

deps/uv/src/unix/udp.c

@@ -301,6 +301,7 @@ static int uv__udp_bind(uv_udp_t* handle,
 
   saved_errno = errno;
   status = -1;
+  fd = -1;
 
   /* Check for bad flags. */
   if (flags & ~UV_UDP_IPV6ONLY) {

deps/uv/src/win/core.c

@@ -48,6 +48,9 @@ static void uv_init(void) {
 
   /* Initialize FS */
   uv_fs_init();
+
+  /* Initialize console */
+  uv_console_init();
 }
 
 

deps/uv/src/win/handle.c

@@ -20,11 +20,36 @@
  */
 
 #include <assert.h>
+#include <io.h>
 
 #include "uv.h"
 #include "internal.h"
 
 
+uv_handle_type uv_guess_handle(uv_file file) {
+  HANDLE handle = (HANDLE) _get_osfhandle(file);
+  DWORD mode;
+
+  switch (GetFileType(handle)) {
+    case FILE_TYPE_CHAR:
+      if (GetConsoleMode(handle, &mode)) {
+        return UV_TTY;
+      } else {
+        return UV_UNKNOWN_HANDLE;
+      }
+
+    case FILE_TYPE_PIPE:
+      return UV_NAMED_PIPE;
+
+    case FILE_TYPE_DISK:
+      return UV_FILE;
+
+    default:
+      return UV_UNKNOWN_HANDLE;
+  }
+}
+
+
 int uv_is_active(uv_handle_t* handle) {
   switch (handle->type) {
     case UV_TIMER:
@@ -80,6 +105,10 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
       }
       return;
 
+    case UV_TTY:
+      uv_tty_close((uv_tty_t*) handle);
+      return;
+
     case UV_UDP:
       udp = (uv_udp_t*) handle;
       uv_udp_recv_stop(udp);
@@ -159,6 +188,10 @@ void uv_process_endgames(uv_loop_t* loop) {
         uv_pipe_endgame(loop, (uv_pipe_t*) handle);
         break;
 
+      case UV_TTY:
+        uv_tty_endgame(loop, (uv_tty_t*) handle);
+        break;
+
       case UV_UDP:
         uv_udp_endgame(loop, (uv_udp_t*) handle);
         break;

deps/uv/src/win/internal.h

@@ -64,6 +64,7 @@ void uv_process_timers(uv_loop_t* loop);
 #define UV_HANDLE_UV_ALLOCED       0x20000
 #define UV_HANDLE_SYNC_BYPASS_IOCP 0x40000
 #define UV_HANDLE_ZERO_READ        0x80000
+#define UV_HANDLE_TTY_RAW          0x100000
 
 void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle);
 void uv_process_endgames(uv_loop_t* loop);
@@ -173,6 +174,33 @@ void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
 void uv_process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
     uv_shutdown_t* req);
 
+
+/*
+ * TTY
+ */
+void uv_console_init();
+
+int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
+    uv_read_cb read_cb);
+int uv_tty_read_stop(uv_tty_t* handle);
+int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
+    uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
+void uv_tty_close(uv_tty_t* handle);
+
+void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
+    uv_req_t* req);
+void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
+    uv_write_t* req);
+/* TODO: remove me */
+void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
+    uv_req_t* raw_req);
+/* TODO: remove me */
+void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
+    uv_connect_t* req);
+
+void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle);
+
+
 /*
  * Loop watchers
  */

deps/uv/src/win/pipe.c

@@ -231,6 +231,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
     if (result) {
       /* Mark the handle as shut now to avoid going through this again. */
       handle->flags |= UV_HANDLE_SHUT;
+      return;
 
     } else {
       /* Failure. */
@@ -678,6 +679,8 @@ static void uv_pipe_queue_read(uv_loop_t* loop, uv_pipe_t* handle) {
     /* Make this req pending reporting an error. */
     SET_REQ_ERROR(req, WSAGetLastError());
     uv_insert_pending_req(loop, req);
+
+    handle->flags |= UV_HANDLE_READ_PENDING;
     handle->reqs_pending++;
     return;
   }

deps/uv/src/win/req.c

@@ -87,6 +87,12 @@ static uv_req_t* uv_remove_pending_req(uv_loop_t* loop) {
                                        req);                                  \
         break;                                                                \
                                                                               \
+      case UV_TTY:                                                            \
+        uv_process_tty_##method##_req(loop,                                   \
+                                      (uv_tty_t*) ((req)->handle_at),         \
+                                      req);                                   \
+        break;                                                                \
+                                                                              \
       default:                                                                \
         assert(0);                                                            \
     }                                                                         \

deps/uv/src/win/stream.c

@@ -83,6 +83,8 @@ int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
       return uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
     case UV_NAMED_PIPE:
       return uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
+    case UV_TTY:
+      return uv_tty_read_start((uv_tty_t*) handle, alloc_cb, read_cb);
     default:
       assert(0);
       return -1;
@@ -91,10 +93,13 @@ int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
 
 
 int uv_read_stop(uv_stream_t* handle) {
+  if (handle->type = UV_TTY) {
+    return uv_tty_read_stop((uv_tty_t*) handle);
+  } else {
     handle->flags &= ~UV_HANDLE_READING;
-
     return 0;
   }
+}
 
 
 int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
@@ -106,6 +111,8 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
       return uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
     case UV_NAMED_PIPE:
       return uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+    case UV_TTY:
+      return uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, bufcnt, cb);
     default:
       assert(0);
       uv_set_sys_error(loop, WSAEINVAL);

deps/uv/src/win/tcp.c

@@ -128,7 +128,9 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
       }
       handle->shutdown_req->cb(handle->shutdown_req, status);
     }
-    handle->reqs_pending--;
+
+    DECREASE_PENDING_REQ_COUNT(handle);
+    return;
   }
 
   if (handle->flags & UV_HANDLE_CLOSING &&

deps/uv/test/test-list.h

@@ -22,6 +22,8 @@
 TEST_DECLARE   (tty)
 TEST_DECLARE   (tcp_ping_pong)
 TEST_DECLARE   (tcp_ping_pong_v6)
+TEST_DECLARE   (tcp_ref)
+TEST_DECLARE   (tcp_ref2)
 TEST_DECLARE   (pipe_ping_pong)
 TEST_DECLARE   (delayed_accept)
 TEST_DECLARE   (tcp_writealot)
@@ -52,6 +54,8 @@ TEST_DECLARE   (connection_fail_doesnt_auto_close)
 TEST_DECLARE   (shutdown_eof)
 TEST_DECLARE   (callback_stack)
 TEST_DECLARE   (timer)
+TEST_DECLARE   (timer_ref)
+TEST_DECLARE   (timer_ref2)
 TEST_DECLARE   (timer_again)
 TEST_DECLARE   (idle_starvation)
 TEST_DECLARE   (loop_handles)
@@ -104,6 +108,12 @@ HELPER_DECLARE (pipe_echo_server)
 TASK_LIST_START
   TEST_ENTRY  (tty)
 
+
+  TEST_ENTRY  (tcp_ref)
+
+  TEST_ENTRY  (tcp_ref2)
+  TEST_HELPER (tcp_ref2, tcp4_echo_server)
+
   TEST_ENTRY  (tcp_ping_pong)
   TEST_HELPER (tcp_ping_pong, tcp4_echo_server)
 
@@ -154,6 +164,8 @@ TASK_LIST_START
   TEST_HELPER (callback_stack, tcp4_echo_server)
 
   TEST_ENTRY  (timer)
+  TEST_ENTRY  (timer_ref)
+  TEST_ENTRY  (timer_ref2)
 
   TEST_ENTRY  (timer_again)
 

deps/uv/test/test-tcp-close.c

@@ -127,3 +127,50 @@ TEST_IMPL(tcp_close) {
 
   return 0;
 }
+
+
+TEST_IMPL(tcp_ref) {
+  uv_tcp_t never;
+  int r;
+
+  /* A tcp just initialized should count as one reference. */
+  r = uv_tcp_init(uv_default_loop(), &never);
+  ASSERT(r == 0);
+
+  /* One unref should set the loop ref count to zero. */
+  uv_unref(uv_default_loop());
+
+  /* Therefore this does not block */
+  uv_run(uv_default_loop());
+
+  return 0;
+}
+
+
+static void never_cb(uv_connect_t* conn_req, int status) {
+  FATAL("never_cb should never be called");
+}
+
+
+TEST_IMPL(tcp_ref2) {
+  uv_tcp_t never;
+  int r;
+
+  /* A tcp just initialized should count as one reference. */
+  r = uv_tcp_init(uv_default_loop(), &never);
+  ASSERT(r == 0);
+
+  r = uv_tcp_connect(&connect_req,
+                     &never,
+                     uv_ip4_addr("127.0.0.1", TEST_PORT),
+                     never_cb);
+  ASSERT(r == 0);
+
+  /* One unref should set the loop ref count to zero. */
+  uv_unref(uv_default_loop());
+
+  /* Therefore this does not block */
+  uv_run(uv_default_loop());
+
+  return 0;
+}

deps/uv/test/test-tcp-write-error.c

@@ -35,10 +35,15 @@ static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
 static uv_tcp_t tcp_server;
 static uv_tcp_t tcp_client;
 static uv_tcp_t tcp_peer; /* client socket as accept()-ed by server */
-static uv_write_t write_req;
 static uv_connect_t connect_req;
 
 static int write_cb_called;
+static int write_cb_error_called;
+ 
+typedef struct {
+  uv_write_t req;
+  uv_buf_t buf;
+} write_req_t;
 
 
 static void connection_cb(uv_stream_t* server, int status) {
@@ -75,10 +80,12 @@ static void connect_cb(uv_connect_t* req, int status) {
   size_t size;
   char* data;
   int r;
+  write_req_t* wr;
 
   ASSERT(req == &connect_req);
   ASSERT(status == 0);
 
+  while (1) {
     size = 10 * 1024 * 1024;
     data = malloc(size);
     ASSERT(data != NULL);
@@ -86,29 +93,34 @@ static void connect_cb(uv_connect_t* req, int status) {
     memset(data, '$', size);
     buf = uv_buf_init(data, size);
  
-  write_req.data = data;
+    wr = (write_req_t*) malloc(sizeof *wr);
+    wr->buf = buf;
+    wr->req.data = data;
  
-  r = uv_write(&write_req, req->handle, &buf, 1, write_cb);
+    r = uv_write(&(wr->req), req->handle, &wr->buf, 1, write_cb);
     ASSERT(r == 0);
  
-  /* Write queue should have been updated. */
-  ASSERT(req->handle->write_queue_size > 0);
-
-  /* write_queue_size <= size, part may have already been written. */
-  ASSERT(req->handle->write_queue_size <= size);
+    if (req->handle->write_queue_size > 0) {
+      break;
+    }
+  }
 }
 
 
 static void write_cb(uv_write_t* req, int status) {
-  ASSERT(req == &write_req);
-  ASSERT(status == -1);
+  write_req_t* wr;
+  wr = (write_req_t*) req;
 
-  /* This is what this test is all about. */
-  ASSERT(tcp_client.write_queue_size == 0);
-
-  free(write_req.data);
+  if (status == -1) {
+    write_cb_error_called++;
+  }
 
+  if (req->handle->write_queue_size == 0) {
     uv_close((uv_handle_t*)&tcp_client, NULL);
+  }
+
+  free(wr->buf.base);
+  free(wr);
 
   write_cb_called++;
 }
@@ -148,7 +160,9 @@ TEST_IMPL(tcp_write_error) {
   r = uv_run(loop);
   ASSERT(r == 0);
 
-  ASSERT(write_cb_called == 1);
+  ASSERT(write_cb_called > 0);
+  ASSERT(write_cb_error_called == 1);
+  ASSERT(tcp_client.write_queue_size == 0);
 
   return 0;
 }

deps/uv/test/test-timer.c

@@ -130,3 +130,43 @@ TEST_IMPL(timer) {
 
   return 0;
 }
+
+
+TEST_IMPL(timer_ref) {
+  uv_timer_t never;
+  int r;
+
+  /* A timer just initialized should count as one reference. */
+  r = uv_timer_init(uv_default_loop(), &never);
+  ASSERT(r == 0);
+
+  /* One unref should set the loop ref count to zero. */
+  uv_unref(uv_default_loop());
+
+  /* Therefore this does not block */
+  uv_run(uv_default_loop());
+
+  return 0;
+}
+
+
+TEST_IMPL(timer_ref2) {
+  uv_timer_t never;
+  int r;
+
+  /* A timer just initialized should count as one reference. */
+  r = uv_timer_init(uv_default_loop(), &never);
+  ASSERT(r == 0);
+
+  /* We start the timer, this should not effect the ref count. */
+  r = uv_timer_start(&never, never_cb, 1000, 1000);
+  ASSERT(r == 0);
+
+  /* One unref should set the loop ref count to zero. */
+  uv_unref(uv_default_loop());
+
+  /* Therefore this does not block */
+  uv_run(uv_default_loop());
+
+  return 0;
+}