mt-libuv 4.1.01 → 4.1.02

data/ext/libuv/test/test-pipe-server-close.c

@@ -0,0 +1,94 @@
+/* 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 <string.h>
+#include <errno.h>
+
+
+static uv_pipe_t pipe_client;
+static uv_pipe_t pipe_server;
+static uv_connect_t connect_req;
+
+static int pipe_close_cb_called = 0;
+static int pipe_client_connect_cb_called = 0;
+
+
+static void pipe_close_cb(uv_handle_t* handle) {
+  ASSERT(handle == (uv_handle_t*) &pipe_client ||
+         handle == (uv_handle_t*) &pipe_server);
+  pipe_close_cb_called++;
+}
+
+
+static void pipe_client_connect_cb(uv_connect_t* req, int status) {
+  ASSERT(req == &connect_req);
+  ASSERT(status == 0);
+
+  pipe_client_connect_cb_called++;
+
+  uv_close((uv_handle_t*) &pipe_client, pipe_close_cb);
+  uv_close((uv_handle_t*) &pipe_server, pipe_close_cb);
+}
+
+
+static void pipe_server_connection_cb(uv_stream_t* handle, int status) {
+  /* This function *may* be called, depending on whether accept or the
+   * connection callback is called first.
+   */
+  ASSERT(status == 0);
+}
+
+
+TEST_IMPL(pipe_server_close) {
+#if defined(NO_SELF_CONNECT)
+  RETURN_SKIP(NO_SELF_CONNECT);
+#endif
+  uv_loop_t* loop;
+  int r;
+
+  loop = uv_default_loop();
+  ASSERT(loop != NULL);
+
+  r = uv_pipe_init(loop, &pipe_server, 0);
+  ASSERT(r == 0);
+
+  r = uv_pipe_bind(&pipe_server, TEST_PIPENAME);
+  ASSERT(r == 0);
+
+  r = uv_listen((uv_stream_t*) &pipe_server, 0, pipe_server_connection_cb);
+  ASSERT(r == 0);
+
+  r = uv_pipe_init(loop, &pipe_client, 0);
+  ASSERT(r == 0);
+
+  uv_pipe_connect(&connect_req, &pipe_client, TEST_PIPENAME, pipe_client_connect_cb);
+
+  r = uv_run(loop, UV_RUN_DEFAULT);
+  ASSERT(r == 0);
+  ASSERT(pipe_client_connect_cb_called == 1);
+  ASSERT(pipe_close_cb_called == 2);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}

data/ext/libuv/test/test-pipe-set-fchmod.c

@@ -0,0 +1,90 @@
+/* Copyright libuv project 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"
+
+TEST_IMPL(pipe_set_chmod) {
+  uv_pipe_t pipe_handle;
+  uv_loop_t* loop;
+  int r;
+#ifndef _WIN32
+  struct stat stat_buf;
+#endif
+
+  loop = uv_default_loop();
+
+  r = uv_pipe_init(loop, &pipe_handle, 0);
+  ASSERT(r == 0);
+
+  r = uv_pipe_bind(&pipe_handle, TEST_PIPENAME);
+  ASSERT(r == 0);
+
+  /* No easy way to test if this works, we will only make sure that the call is
+   * successful. */
+  r = uv_pipe_chmod(&pipe_handle, UV_READABLE);
+  if (r == UV_EPERM) {
+    MAKE_VALGRIND_HAPPY();
+    RETURN_SKIP("Insufficient privileges to alter pipe fmode");
+  }
+  ASSERT(r == 0);
+#ifndef _WIN32
+  stat(TEST_PIPENAME, &stat_buf);
+  ASSERT(stat_buf.st_mode & S_IRUSR);
+  ASSERT(stat_buf.st_mode & S_IRGRP);
+  ASSERT(stat_buf.st_mode & S_IROTH);
+#endif
+
+  r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE);
+  ASSERT(r == 0);
+#ifndef _WIN32
+  stat(TEST_PIPENAME, &stat_buf);
+  ASSERT(stat_buf.st_mode & S_IWUSR);
+  ASSERT(stat_buf.st_mode & S_IWGRP);
+  ASSERT(stat_buf.st_mode & S_IWOTH);
+#endif
+
+  r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE);
+  ASSERT(r == 0);
+#ifndef _WIN32
+  stat(TEST_PIPENAME, &stat_buf);
+  ASSERT(stat_buf.st_mode & S_IRUSR);
+  ASSERT(stat_buf.st_mode & S_IRGRP);
+  ASSERT(stat_buf.st_mode & S_IROTH);
+  ASSERT(stat_buf.st_mode & S_IWUSR);
+  ASSERT(stat_buf.st_mode & S_IWGRP);
+  ASSERT(stat_buf.st_mode & S_IWOTH);
+#endif
+
+  r = uv_pipe_chmod(NULL, UV_WRITABLE | UV_READABLE);
+  ASSERT(r == UV_EBADF);
+
+  r = uv_pipe_chmod(&pipe_handle, 12345678);
+  ASSERT(r == UV_EINVAL);
+
+  uv_close((uv_handle_t*)&pipe_handle, NULL);
+  r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE);
+  ASSERT(r == UV_EBADF);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}

data/ext/libuv/test/test-pipe-set-non-blocking.c

@@ -0,0 +1,99 @@
+/* Copyright (c) 2015, Ben Noordhuis <info@bnoordhuis.nl>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "uv.h"
+#include "task.h"
+
+#ifdef _WIN32
+
+TEST_IMPL(pipe_set_non_blocking) {
+  RETURN_SKIP("Test not implemented on Windows.");
+}
+
+#else  /* !_WIN32 */
+
+#include <errno.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+struct thread_ctx {
+  uv_barrier_t barrier;
+  int fd;
+};
+
+static void thread_main(void* arg) {
+  struct thread_ctx* ctx;
+  char buf[4096];
+  ssize_t n;
+
+  ctx = arg;
+  uv_barrier_wait(&ctx->barrier);
+
+  do
+    n = read(ctx->fd, buf, sizeof(buf));
+  while (n > 0 || (n == -1 && errno == EINTR));
+
+  ASSERT(n == 0);
+}
+
+TEST_IMPL(pipe_set_non_blocking) {
+  struct thread_ctx ctx;
+  uv_pipe_t pipe_handle;
+  uv_thread_t thread;
+  size_t nwritten;
+  char data[4096];
+  uv_buf_t buf;
+  int fd[2];
+  int n;
+
+  ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
+  ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, fd));
+  ASSERT(0 == uv_pipe_open(&pipe_handle, fd[0]));
+  ASSERT(0 == uv_stream_set_blocking((uv_stream_t*) &pipe_handle, 1));
+
+  ctx.fd = fd[1];
+  ASSERT(0 == uv_barrier_init(&ctx.barrier, 2));
+  ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx));
+  uv_barrier_wait(&ctx.barrier);
+
+  buf.len = sizeof(data);
+  buf.base = data;
+  memset(data, '.', sizeof(data));
+
+  nwritten = 0;
+  while (nwritten < 10 << 20) {
+    /* The stream is in blocking mode so uv_try_write() should always succeed
+     * with the exact number of bytes that we wanted written.
+     */
+    n = uv_try_write((uv_stream_t*) &pipe_handle, &buf, 1);
+    ASSERT(n == sizeof(data));
+    nwritten += n;
+  }
+
+  uv_close((uv_handle_t*) &pipe_handle, NULL);
+  ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
+
+  ASSERT(0 == uv_thread_join(&thread));
+  ASSERT(0 == close(fd[1]));  /* fd[0] is closed by uv_close(). */
+  uv_barrier_destroy(&ctx.barrier);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+#endif  /* !_WIN32 */

data/ext/libuv/test/test-platform-output.c

@@ -0,0 +1,170 @@
+/* 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 <string.h>
+
+
+TEST_IMPL(platform_output) {
+  char buffer[512];
+  size_t rss;
+  size_t size;
+  double uptime;
+  uv_pid_t pid;
+  uv_pid_t ppid;
+  uv_rusage_t rusage;
+  uv_cpu_info_t* cpus;
+  uv_interface_address_t* interfaces;
+  uv_passwd_t pwd;
+  uv_utsname_t uname;
+  int count;
+  int i;
+  int err;
+
+  err = uv_get_process_title(buffer, sizeof(buffer));
+  ASSERT(err == 0);
+  printf("uv_get_process_title: %s\n", buffer);
+
+  size = sizeof(buffer);
+  err = uv_cwd(buffer, &size);
+  ASSERT(err == 0);
+  printf("uv_cwd: %s\n", buffer);
+
+  err = uv_resident_set_memory(&rss);
+#if defined(__MSYS__)
+  ASSERT(err == UV_ENOSYS);
+#else
+  ASSERT(err == 0);
+  printf("uv_resident_set_memory: %llu\n", (unsigned long long) rss);
+#endif
+
+  err = uv_uptime(&uptime);
+#if defined(__PASE__)
+  ASSERT(err == UV_ENOSYS);
+#else
+  ASSERT(err == 0);
+  ASSERT(uptime > 0);
+  printf("uv_uptime: %f\n", uptime);
+#endif
+
+  err = uv_getrusage(&rusage);
+  ASSERT(err == 0);
+  ASSERT(rusage.ru_utime.tv_sec >= 0);
+  ASSERT(rusage.ru_utime.tv_usec >= 0);
+  ASSERT(rusage.ru_stime.tv_sec >= 0);
+  ASSERT(rusage.ru_stime.tv_usec >= 0);
+  printf("uv_getrusage:\n");
+  printf("  user: %llu sec %llu microsec\n",
+         (unsigned long long) rusage.ru_utime.tv_sec,
+         (unsigned long long) rusage.ru_utime.tv_usec);
+  printf("  system: %llu sec %llu microsec\n",
+         (unsigned long long) rusage.ru_stime.tv_sec,
+         (unsigned long long) rusage.ru_stime.tv_usec);
+  printf("  page faults: %llu\n", (unsigned long long) rusage.ru_majflt);
+  printf("  maximum resident set size: %llu\n",
+         (unsigned long long) rusage.ru_maxrss);
+
+  err = uv_cpu_info(&cpus, &count);
+#if defined(__CYGWIN__) || defined(__MSYS__)
+  ASSERT(err == UV_ENOSYS);
+#else
+  ASSERT(err == 0);
+
+  printf("uv_cpu_info:\n");
+  for (i = 0; i < count; i++) {
+    printf("  model: %s\n", cpus[i].model);
+    printf("  speed: %d\n", cpus[i].speed);
+    printf("  times.sys: %llu\n", (unsigned long long) cpus[i].cpu_times.sys);
+    printf("  times.user: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.user);
+    printf("  times.idle: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.idle);
+    printf("  times.irq: %llu\n",  (unsigned long long) cpus[i].cpu_times.irq);
+    printf("  times.nice: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.nice);
+  }
+#endif
+  uv_free_cpu_info(cpus, count);
+
+  err = uv_interface_addresses(&interfaces, &count);
+  ASSERT(err == 0);
+
+  printf("uv_interface_addresses:\n");
+  for (i = 0; i < count; i++) {
+    printf("  name: %s\n", interfaces[i].name);
+    printf("  internal: %d\n", interfaces[i].is_internal);
+    printf("  physical address: ");
+    printf("%02x:%02x:%02x:%02x:%02x:%02x\n",
+           (unsigned char)interfaces[i].phys_addr[0],
+           (unsigned char)interfaces[i].phys_addr[1],
+           (unsigned char)interfaces[i].phys_addr[2],
+           (unsigned char)interfaces[i].phys_addr[3],
+           (unsigned char)interfaces[i].phys_addr[4],
+           (unsigned char)interfaces[i].phys_addr[5]);
+
+    if (interfaces[i].address.address4.sin_family == AF_INET) {
+      uv_ip4_name(&interfaces[i].address.address4, buffer, sizeof(buffer));
+    } else if (interfaces[i].address.address4.sin_family == AF_INET6) {
+      uv_ip6_name(&interfaces[i].address.address6, buffer, sizeof(buffer));
+    }
+
+    printf("  address: %s\n", buffer);
+
+    if (interfaces[i].netmask.netmask4.sin_family == AF_INET) {
+      uv_ip4_name(&interfaces[i].netmask.netmask4, buffer, sizeof(buffer));
+      printf("  netmask: %s\n", buffer);
+    } else if (interfaces[i].netmask.netmask4.sin_family == AF_INET6) {
+      uv_ip6_name(&interfaces[i].netmask.netmask6, buffer, sizeof(buffer));
+      printf("  netmask: %s\n", buffer);
+    } else {
+      printf("  netmask: none\n");
+    }
+  }
+  uv_free_interface_addresses(interfaces, count);
+
+  err = uv_os_get_passwd(&pwd);
+  ASSERT(err == 0);
+
+  printf("uv_os_get_passwd:\n");
+  printf("  euid: %ld\n", pwd.uid);
+  printf("  gid: %ld\n", pwd.gid);
+  printf("  username: %s\n", pwd.username);
+  printf("  shell: %s\n", pwd.shell);
+  printf("  home directory: %s\n", pwd.homedir);
+
+  pid = uv_os_getpid();
+  ASSERT(pid > 0);
+  printf("uv_os_getpid: %d\n", (int) pid);
+  ppid = uv_os_getppid();
+  ASSERT(ppid > 0);
+  printf("uv_os_getppid: %d\n", (int) ppid);
+
+  err = uv_os_uname(&uname);
+  ASSERT(err == 0);
+  printf("uv_os_uname:\n");
+  printf("  sysname: %s\n", uname.sysname);
+  printf("  release: %s\n", uname.release);
+  printf("  version: %s\n", uname.version);
+  printf("  machine: %s\n", uname.machine);
+
+  return 0;
+}

data/ext/libuv/test/test-poll-close-doesnt-corrupt-stack.c

@@ -0,0 +1,114 @@
+/* Copyright Bert Belder, and other libuv 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 <errno.h>
+#include <stdio.h>
+
+#include "uv.h"
+#include "task.h"
+
+#ifdef _MSC_VER  /* msvc */
+# define NO_INLINE __declspec(noinline)
+#else  /* gcc */
+# define NO_INLINE __attribute__ ((noinline))
+#endif
+
+#ifdef _WIN32
+static uv_os_sock_t sock;
+static uv_poll_t handle;
+static int close_cb_called = 0;
+
+
+static void close_cb(uv_handle_t* h) {
+  close_cb_called++;
+}
+
+
+static void poll_cb(uv_poll_t* h, int status, int events) {
+  ASSERT(0 && "should never get here");
+}
+
+
+static void NO_INLINE close_socket_and_verify_stack(void) {
+  const uint32_t MARKER = 0xDEADBEEF;
+  const int VERIFY_AFTER = 10; /* ms */
+  int r;
+
+  volatile uint32_t data[65536];
+  size_t i;
+
+  for (i = 0; i < ARRAY_SIZE(data); i++)
+    data[i] = MARKER;
+
+  r = closesocket(sock);
+  ASSERT(r == 0);
+
+  uv_sleep(VERIFY_AFTER);
+
+  for (i = 0; i < ARRAY_SIZE(data); i++)
+    ASSERT(data[i] == MARKER);
+}
+#endif
+
+
+TEST_IMPL(poll_close_doesnt_corrupt_stack) {
+#ifndef _WIN32
+  RETURN_SKIP("Test only relevant on Windows");
+#else
+  struct WSAData wsa_data;
+  int r;
+  unsigned long on;
+  struct sockaddr_in addr;
+
+  r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+  ASSERT(r == 0);
+
+  sock = socket(AF_INET, SOCK_STREAM, 0);
+  ASSERT(sock != INVALID_SOCKET);
+  on = 1;
+  r = ioctlsocket(sock, FIONBIO, &on);
+  ASSERT(r == 0);
+
+  r = uv_ip4_addr("127.0.0.1", TEST_PORT, &addr);
+  ASSERT(r == 0);
+
+  r = connect(sock, (const struct sockaddr*) &addr, sizeof addr);
+  ASSERT(r != 0);
+  ASSERT(WSAGetLastError() == WSAEWOULDBLOCK);
+
+  r = uv_poll_init_socket(uv_default_loop(), &handle, sock);
+  ASSERT(r == 0);
+  r = uv_poll_start(&handle, UV_READABLE | UV_WRITABLE, poll_cb);
+  ASSERT(r == 0);
+
+  uv_close((uv_handle_t*) &handle, close_cb);
+
+  close_socket_and_verify_stack();
+
+  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+  ASSERT(r == 0);
+
+  ASSERT(close_cb_called == 1);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+#endif
+}

data/ext/libuv/test/test-poll-close.c

@@ -0,0 +1,73 @@
+/* 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 <errno.h>
+
+#ifndef _WIN32
+# include <fcntl.h>
+# include <sys/socket.h>
+# include <unistd.h>
+#endif
+
+#include "uv.h"
+#include "task.h"
+
+#define NUM_SOCKETS 64
+
+
+static int close_cb_called = 0;
+
+
+static void close_cb(uv_handle_t* handle) {
+  close_cb_called++;
+}
+
+
+TEST_IMPL(poll_close) {
+  uv_os_sock_t sockets[NUM_SOCKETS];
+  uv_poll_t poll_handles[NUM_SOCKETS];
+  int i;
+
+#ifdef _WIN32
+  {
+    struct WSAData wsa_data;
+    int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+    ASSERT(r == 0);
+  }
+#endif
+
+  for (i = 0; i < NUM_SOCKETS; i++) {
+    sockets[i] = socket(AF_INET, SOCK_STREAM, 0);
+    uv_poll_init_socket(uv_default_loop(), &poll_handles[i], sockets[i]);
+    uv_poll_start(&poll_handles[i], UV_READABLE | UV_WRITABLE, NULL);
+  }
+
+  for (i = 0; i < NUM_SOCKETS; i++) {
+    uv_close((uv_handle_t*) &poll_handles[i], close_cb);
+  }
+
+  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+  ASSERT(close_cb_called == NUM_SOCKETS);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}