Upgrade libuv to c903bc3

deps/uv/src/unix/stream.c

@@ -482,7 +482,6 @@ static void uv__read(uv_stream_t* stream) {
   struct msghdr msg;
   struct cmsghdr* cmsg;
   char cmsg_space[64];
-  int received_fd = -1;
   struct ev_loop* ev = stream->loop->ev;
 
   /* XXX: Maybe instead of having UV_READING we just test if
@@ -564,7 +563,7 @@ static void uv__read(uv_stream_t* stream) {
       return;
     } else {
       /* Successful read */
-      size_t buflen = buf.len;
+      ssize_t buflen = buf.len;
 
       if (stream->read_cb) {
         stream->read_cb(stream, nread, buf);

deps/uv/src/win/fs.c

@@ -231,6 +231,11 @@ void fs__open(uv_fs_t* req, const char* path, int flags, int mode) {
     goto end;
   }
 
+  /* Figure out whether path is a file or a directory. */
+  if (GetFileAttributesA(path) & FILE_ATTRIBUTE_DIRECTORY) {
+    attributes |= FILE_FLAG_BACKUP_SEMANTICS;
+  }
+
   file = CreateFileA(path,
                      access,
                      share,
@@ -362,11 +367,20 @@ void fs__readdir(uv_fs_t* req, const char* path, int flags) {
   WIN32_FIND_DATAA ent = {0};
   size_t len = strlen(path);
   size_t buf_size = 4096;
+  char* path2;
   const char* fmt = !len                                            ? "./*"
                   : (path[len - 1] == '/' || path[len - 1] == '\\') ? "%s*"
                   :                                                   "%s\\*";
 
-  char* path2 = (char*)malloc(len + 4);
+  /* Figure out whether path is a file or a directory. */
+  if (!(GetFileAttributesA(path) & FILE_ATTRIBUTE_DIRECTORY)) {
+    req->result = -1;
+    req->errorno = UV_ENOTDIR;
+    req->last_error = ERROR_SUCCESS;
+    return;
+  }
+
+  path2 = (char*)malloc(len + 4);
   if (!path2) {
     uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
   }

deps/uv/test/test-fs.c

@@ -263,6 +263,19 @@ static void open_cb(uv_fs_t* req) {
 }
 
 
+static void open_cb_simple(uv_fs_t* req) {
+  ASSERT(req->fs_type == UV_FS_OPEN);
+  if (req->result < 0) {
+    /* TODO get error with uv_last_error() */
+    fprintf(stderr, "async open error: %d\n", req->errorno);
+    ASSERT(0);
+  }
+  open_cb_count++;
+  ASSERT(req->path);
+  uv_fs_req_cleanup(req);
+}
+
+
 static void fsync_cb(uv_fs_t* req) {
   int r;
   ASSERT(req == &fsync_req);
@@ -1366,3 +1379,32 @@ TEST_IMPL(fs_readdir_file) {
 
   return 0;
 }
+
+
+TEST_IMPL(fs_open_dir) {
+  const char* path;
+  uv_fs_t req;
+  int r, file;
+
+  path = ".";
+  loop = uv_default_loop();
+
+  r = uv_fs_open(loop, &req, path, O_RDONLY, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  ASSERT(req.ptr == NULL);
+  file = r;
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_close(loop, &req, file, NULL);
+  ASSERT(r == 0);
+
+  r = uv_fs_open(loop, &req, path, O_RDONLY, 0, open_cb_simple);
+  ASSERT(r == 0);
+
+  ASSERT(open_cb_count == 0);
+  uv_run(loop);
+  ASSERT(open_cb_count == 1);
+
+  return 0;
+}

deps/uv/test/test-list.h

@@ -103,6 +103,7 @@ TEST_DECLARE   (fs_event_watch_file)
 TEST_DECLARE   (fs_event_watch_file_current_dir)
 TEST_DECLARE   (fs_readdir_empty_dir)
 TEST_DECLARE   (fs_readdir_file)
+TEST_DECLARE   (fs_open_dir)
 TEST_DECLARE   (threadpool_queue_work_simple)
 #ifdef _WIN32
 TEST_DECLARE   (spawn_detect_pipe_name_collisions_on_windows)
@@ -240,7 +241,7 @@ TASK_LIST_START
   TEST_ENTRY  (fs_event_watch_file_current_dir)
   TEST_ENTRY  (fs_readdir_empty_dir)
   TEST_ENTRY  (fs_readdir_file)
-
+  TEST_ENTRY  (fs_open_dir)
   TEST_ENTRY  (threadpool_queue_work_simple)
 
 #if 0

deps/uv/test/test-udp-multicast-join.c

@@ -0,0 +1,139 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "uv.h"
+#include "task.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CHECK_HANDLE(handle) \
+  ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client)
+
+static uv_udp_t server;
+static uv_udp_t client;
+
+static int cl_recv_cb_called;
+
+static int sv_send_cb_called;
+
+static int close_cb_called;
+
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+  static char slab[65536];
+
+  CHECK_HANDLE(handle);
+  ASSERT(suggested_size <= sizeof slab);
+
+  return uv_buf_init(slab, sizeof slab);
+}
+
+
+static void close_cb(uv_handle_t* handle) {
+  CHECK_HANDLE(handle);
+  close_cb_called++;
+}
+
+
+static void sv_send_cb(uv_udp_send_t* req, int status) {
+  ASSERT(req != NULL);
+  ASSERT(status == 0);
+  CHECK_HANDLE(req->handle);
+
+  sv_send_cb_called++;
+
+  uv_close((uv_handle_t*) req->handle, close_cb);
+}
+
+
+static void cl_recv_cb(uv_udp_t* handle,
+                       ssize_t nread,
+                       uv_buf_t buf,
+                       struct sockaddr* addr,
+                       unsigned flags) {
+  CHECK_HANDLE(handle);
+  ASSERT(flags == 0);
+
+  cl_recv_cb_called++;
+
+  if (nread < 0) {
+    ASSERT(0 && "unexpected error");
+  }
+
+  if (nread == 0) {
+    /* Returning unused buffer */
+    /* Don't count towards cl_recv_cb_called */
+    ASSERT(addr == NULL);
+    return;
+  }
+
+  ASSERT(addr != NULL);
+  ASSERT(nread == 4);
+  ASSERT(!memcmp("PING", buf.base, nread));
+
+  /* we are done with the client handle, we can close it */
+  uv_close((uv_handle_t*) &client, close_cb);
+}
+
+
+TEST_IMPL(udp_multicast_join) {
+  int r;
+  uv_udp_send_t req;
+  uv_buf_t buf;
+  struct sockaddr_in addr = uv_ip4_addr("239.255.0.1", TEST_PORT);
+
+  r = uv_udp_init(uv_default_loop(), &server);
+  ASSERT(r == 0);
+
+  r = uv_udp_init(uv_default_loop(), &client);
+  ASSERT(r == 0);
+
+  /* bind to the desired port */
+  r = uv_udp_bind(&client, addr, 0);
+  ASSERT(r == 0);
+
+  /* join the multicast channel */
+  r = uv_udp_set_membership(&client, "239.255.0.1", NULL, UV_JOIN_GROUP);
+  ASSERT(r == 0);
+
+  r = uv_udp_recv_start(&client, alloc_cb, cl_recv_cb);
+  ASSERT(r == 0);
+
+  buf = uv_buf_init("PING", 4);
+
+  /* server sends "PING" */
+  r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
+  ASSERT(r == 0);
+
+  ASSERT(close_cb_called == 0);
+  ASSERT(cl_recv_cb_called == 0);
+  ASSERT(sv_send_cb_called == 0);
+
+  /* run the loop till all events are processed */
+  uv_run(uv_default_loop());
+
+  ASSERT(cl_recv_cb_called == 1);
+  ASSERT(sv_send_cb_called == 1);
+  ASSERT(close_cb_called == 2);
+
+  return 0;
+}