libuv 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d13aec5db12ee41ad8e672bda901a128d7e29fd3
-  data.tar.gz: 554f2bd2a9ff1d9a69af2551a48a944e3af5cd91
+  metadata.gz: 761d4fa5d96a80530d0b0edd0cb39b8495f81535
+  data.tar.gz: e5e2f17be5d237f0ac49f5973ef4f21a8cb33fe6
 SHA512:
-  metadata.gz: f8362798abe6237ea412ff7ff03fbfa27a47d3606e1f8e318ae8f33555c7e23b59e8f3c84f1ab8453b08464b69cfc1fc568a5127bcc13718f02fd5fc7cb78bf6
-  data.tar.gz: 7f82bc4fff20b9f0a380d3bfe76b2790b5d602679f0943cbe50835bba88a5988f09c7fab31e04d2cd43bc268e2aeec8c8cbcab626ef2a3a451c3fd2e530fbc66
+  metadata.gz: 7d64a84900c157f15e2ede04a848ce9ca961145bd961635dc0db125a82cd10e6448a0fa25bc0c12f9b530053f919eed7aeb95bcc99cbea75981b0f11dd16f8e1
+  data.tar.gz: 8164ddfc3a957a5cbb99f8428bb89159fde23fbee6b1c6398b6ebefd90a9e7b0f232c0eab6453da5afdf91b75b364a742a05b86e780ed44f0815a69abb66abfd

data/.travis.yml

@@ -3,14 +3,14 @@ rvm:
   - "1.9.3"
   - "2.0.0"
   - ruby-head
-  - rbx-2.2.1
-  - jruby-head
+  - rbx-2
+  - jruby-19mode
 branches:
   only:
     - master
 before_install:
   - sudo apt-get install subversion
   - git submodule update --init --recursive
-  - echo "yes" | gem uninstall ffi -a
+  - gem install ffi
 before_script:
   - rake compile

data/ext/libuv/include/uv.h

@@ -1892,7 +1892,7 @@ UV_EXTERN int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file,
 UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path,
     int mode, uv_fs_cb cb);
 
-UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* template,
+UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl,
     uv_fs_cb cb);
 
 UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path,

data/ext/libuv/src/unix/fs.c

@@ -1009,10 +1009,10 @@ int uv_fs_mkdir(uv_loop_t* loop,
 
 int uv_fs_mkdtemp(uv_loop_t* loop,
                   uv_fs_t* req,
-                  const char* template,
+                  const char* tpl,
                   uv_fs_cb cb) {
   INIT(MKDTEMP);
-  req->path = strdup(template);
+  req->path = strdup(tpl);
   if (req->path == NULL)
     return -ENOMEM;
   POST;

data/ext/libuv/src/win/core.c

@@ -45,8 +45,9 @@ static uv_once_t uv_default_loop_init_guard_ = UV_ONCE_INIT;
 
 
 #if defined(_DEBUG) && (defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR))
-/* Our crt debug report handler allows us to temporarily disable asserts */
-/* just for the current thread. */
+/* Our crt debug report handler allows us to temporarily disable asserts
+ * just for the current thread.
+ */
 
 UV_THREAD_LOCAL int uv__crt_assert_enabled = TRUE;
 
@@ -55,8 +56,9 @@ static int uv__crt_dbg_report_handler(int report_type, char *message, int *ret_v
     return FALSE;
 
   if (ret_val) {
-    /* Set ret_val to 0 to continue with normal execution. */
-    /* Set ret_val to 1 to trigger a breakpoint. */
+    /* Set ret_val to 0 to continue with normal execution.
+     * Set ret_val to 1 to trigger a breakpoint.
+    */
 
     if(IsDebuggerPresent())
       *ret_val = 1;
@@ -86,21 +88,24 @@ static void uv_init(void) {
   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
                SEM_NOOPENFILEERRORBOX);
 
-  /* Tell the CRT to not exit the application when an invalid parameter is */
-  /* passed. The main issue is that invalid FDs will trigger this behavior. */
+  /* Tell the CRT to not exit the application when an invalid parameter is
+   * passed. The main issue is that invalid FDs will trigger this behavior.
+   */
 #if !defined(__MINGW32__) || __MSVCRT_VERSION__ >= 0x800
   _set_invalid_parameter_handler(uv__crt_invalid_parameter_handler);
 #endif
 
-  /* We also need to setup our debug report handler because some CRT */
-  /* functions (eg _get_osfhandle) raise an assert when called with invalid */
-  /* FDs even though they return the proper error code in the release build. */
+  /* We also need to setup our debug report handler because some CRT
+   * functions (eg _get_osfhandle) raise an assert when called with invalid
+   * FDs even though they return the proper error code in the release build.
+   */
 #if defined(_DEBUG) && (defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR))
   _CrtSetReportHook(uv__crt_dbg_report_handler);
 #endif
 
-  /* Fetch winapi function pointers. This must be done first because other */
-  /* intialization code might need these function pointers to be loaded. */
+  /* Fetch winapi function pointers. This must be done first because other
+   * intialization code might need these function pointers to be loaded.
+   */
   uv_winapi_init();
 
   /* Initialize winsock */
@@ -129,8 +134,9 @@ int uv_loop_init(uv_loop_t* loop) {
   if (loop->iocp == NULL)
     return uv_translate_sys_error(GetLastError());
 
-  /* To prevent uninitialized memory access, loop->time must be intialized */
-  /* to zero before calling uv_update_time for the first time. */
+  /* To prevent uninitialized memory access, loop->time must be intialized
+   * to zero before calling uv_update_time for the first time.
+   */
   loop->time = 0;
   loop->last_tick_count = 0;
   uv_update_time(loop);
@@ -272,22 +278,31 @@ int uv_backend_fd(const uv_loop_t* loop) {
 
 
 int uv_backend_timeout(const uv_loop_t* loop) {
-  return 0;
+  if (loop->stop_flag != 0)
+    return 0;
+
+  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
+    return 0;
+
+  if (loop->pending_reqs_tail)
+    return 0;
+
+  if (loop->endgame_handles)
+    return 0;
+
+  if (loop->idle_handles)
+    return 0;
+
+  return uv__next_timeout(loop);
 }
 
 
-static void uv_poll(uv_loop_t* loop, int block) {
-  DWORD bytes, timeout;
+static void uv_poll(uv_loop_t* loop, DWORD timeout) {
+  DWORD bytes;
   ULONG_PTR key;
   OVERLAPPED* overlapped;
   uv_req_t* req;
 
-  if (block) {
-    timeout = uv_get_poll_timeout(loop);
-  } else {
-    timeout = 0;
-  }
-
   GetQueuedCompletionStatus(loop->iocp,
                             &bytes,
                             &key,
@@ -302,28 +317,22 @@ static void uv_poll(uv_loop_t* loop, int block) {
     /* Serious error */
     uv_fatal_error(GetLastError(), "GetQueuedCompletionStatus");
   } else {
-    /* We're sure that at least `timeout` milliseconds have expired, but */
-    /* this may not be reflected yet in the GetTickCount() return value. */
-    /* Therefore we ensure it's taken into account here. */
+    /* We're sure that at least `timeout` milliseconds have expired, but
+     * this may not be reflected yet in the GetTickCount() return value.
+     * Therefore we ensure it's taken into account here.
+     */
     uv__time_forward(loop, timeout);
   }
 }
 
 
-static void uv_poll_ex(uv_loop_t* loop, int block) {
+static void uv_poll_ex(uv_loop_t* loop, DWORD timeout) {
   BOOL success;
-  DWORD timeout;
   uv_req_t* req;
   OVERLAPPED_ENTRY overlappeds[128];
   ULONG count;
   ULONG i;
 
-  if (block) {
-    timeout = uv_get_poll_timeout(loop);
-  } else {
-    timeout = 0;
-  }
-
   success = pGetQueuedCompletionStatusEx(loop->iocp,
                                          overlappeds,
                                          ARRAY_SIZE(overlappeds),
@@ -341,9 +350,10 @@ static void uv_poll_ex(uv_loop_t* loop, int block) {
     /* Serious error */
     uv_fatal_error(GetLastError(), "GetQueuedCompletionStatusEx");
   } else if (timeout > 0) {
-    /* We're sure that at least `timeout` milliseconds have expired, but */
-    /* this may not be reflected yet in the GetTickCount() return value. */
-    /* Therefore we ensure it's taken into account here. */
+    /* We're sure that at least `timeout` milliseconds have expired, but
+     * this may not be reflected yet in the GetTickCount() return value.
+     * Therefore we ensure it's taken into account here.
+     */
     uv__time_forward(loop, timeout);
   }
 }
@@ -362,8 +372,9 @@ int uv_loop_alive(const uv_loop_t* loop) {
 
 
 int uv_run(uv_loop_t *loop, uv_run_mode mode) {
+  DWORD timeout;
   int r;
-  void (*poll)(uv_loop_t* loop, int block);
+  void (*poll)(uv_loop_t* loop, DWORD timeout);
 
   if (pGetQueuedCompletionStatusEx)
     poll = &uv_poll_ex;
@@ -382,13 +393,11 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) {
     uv_idle_invoke(loop);
     uv_prepare_invoke(loop);
 
-    (*poll)(loop, loop->idle_handles == NULL &&
-                  loop->pending_reqs_tail == NULL &&
-                  loop->endgame_handles == NULL &&
-                  !loop->stop_flag &&
-                  (loop->active_handles > 0 ||
-                   !QUEUE_EMPTY(&loop->active_reqs)) &&
-                  !(mode & UV_RUN_NOWAIT));
+    timeout = 0;
+    if ((mode & UV_RUN_NOWAIT) == 0)
+      timeout = uv_backend_timeout(loop);
+
+    (*poll)(loop, timeout);
 
     uv_check_invoke(loop);
     uv_process_endgames(loop);

data/ext/libuv/src/win/fs.c

@@ -1797,13 +1797,13 @@ int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
 }
 
 
-int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* template,
+int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl,
     uv_fs_cb cb) {
   int err;
 
   uv_fs_req_init(loop, req, UV_FS_MKDTEMP, cb);
 
-  err = fs__capture_path(loop, req, template, NULL, TRUE);
+  err = fs__capture_path(loop, req, tpl, NULL, TRUE);
   if (err)
     return uv_translate_sys_error(err);
 

data/ext/libuv/src/win/getnameinfo.c

@@ -49,9 +49,9 @@ static void uv__getnameinfo_work(struct uv__work* w) {
   ret = GetNameInfoW((struct sockaddr*)&req->storage,
                      sizeof(req->storage),
                      host,
-                     sizeof(host),
+                     ARRAY_SIZE(host),
                      service,
-                     sizeof(service),
+                     ARRAY_SIZE(service),
                      req->flags);
   req->retcode = uv__getaddrinfo_translate_error(ret);
 

data/ext/libuv/src/win/internal.h

@@ -239,7 +239,7 @@ void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle);
  */
 void uv_timer_endgame(uv_loop_t* loop, uv_timer_t* handle);
 
-DWORD uv_get_poll_timeout(uv_loop_t* loop);
+DWORD uv__next_timeout(const uv_loop_t* loop);
 void uv__time_forward(uv_loop_t* loop, uint64_t msecs);
 void uv_process_timers(uv_loop_t* loop);
 

data/ext/libuv/src/win/process.c

@@ -813,6 +813,20 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) {
   return 0;
 }
 
+/*
+ * Attempt to find the value of the PATH environment variable in the child's
+ * preprocessed environment.
+ *
+ * If found, a pointer into `env` is returned. If not found, NULL is returned.
+ */
+static WCHAR* find_path(WCHAR *env) {
+  for (; env != NULL && *env != 0; env += wcslen(env) + 1) {
+    if (wcsncmp(env, L"PATH=", 5) == 0)
+      return &env[5];
+  }
+
+  return NULL;
+}
 
 /*
  * Called on Windows thread-pool thread to indicate that
@@ -910,7 +924,7 @@ int uv_spawn(uv_loop_t* loop,
              const uv_process_options_t* options) {
   int i;
   int err = 0;
-  WCHAR* path = NULL;
+  WCHAR* path = NULL, *alloc_path = NULL;
   BOOL result;
   WCHAR* application_path = NULL, *application = NULL, *arguments = NULL,
          *env = NULL, *cwd = NULL;
@@ -984,7 +998,8 @@ int uv_spawn(uv_loop_t* loop,
   }
 
   /* Get PATH environment variable. */
-  {
+  path = find_path(env);
+  if (path == NULL) {
     DWORD path_len, r;
 
     path_len = GetEnvironmentVariableW(L"PATH", NULL, 0);
@@ -993,11 +1008,12 @@ int uv_spawn(uv_loop_t* loop,
       goto done;
     }
 
-    path = (WCHAR*) malloc(path_len * sizeof(WCHAR));
-    if (path == NULL) {
+    alloc_path = (WCHAR*) malloc(path_len * sizeof(WCHAR));
+    if (alloc_path == NULL) {
       err = ERROR_OUTOFMEMORY;
       goto done;
     }
+    path = alloc_path;
 
     r = GetEnvironmentVariableW(L"PATH", path, path_len);
     if (r == 0 || r >= path_len) {
@@ -1131,7 +1147,7 @@ int uv_spawn(uv_loop_t* loop,
   free(arguments);
   free(cwd);
   free(env);
-  free(path);
+  free(alloc_path);
 
   if (process->child_stdio_buffer != NULL) {
     /* Clean up child stdio handles. */

data/ext/libuv/src/win/timer.c

@@ -36,10 +36,11 @@ void uv_update_time(uv_loop_t* loop) {
 
   time.QuadPart = loop->time;
 
-  /* GetTickCount() can conceivably wrap around, so when the current tick */
-  /* count is lower than the last tick count, we'll assume it has wrapped. */
-  /* uv_poll must make sure that the timer can never overflow more than */
-  /* once between two subsequent uv_update_time calls. */
+  /* GetTickCount() can conceivably wrap around, so when the current tick
+   * count is lower than the last tick count, we'll assume it has wrapped.
+   * uv_poll must make sure that the timer can never overflow more than
+   * once between two subsequent uv_update_time calls.
+   */
   time.LowPart = ticks;
   if (ticks < loop->last_tick_count)
     time.HighPart++;
@@ -47,13 +48,14 @@ void uv_update_time(uv_loop_t* loop) {
   /* Remember the last tick count. */
   loop->last_tick_count = ticks;
 
-  /* The GetTickCount() resolution isn't too good. Sometimes it'll happen */
-  /* that GetQueuedCompletionStatus() or GetQueuedCompletionStatusEx() has */
-  /* waited for a couple of ms but this is not reflected in the GetTickCount */
-  /* result yet. Therefore whenever GetQueuedCompletionStatus times out */
-  /* we'll add the number of ms that it has waited to the current loop time. */
-  /* When that happened the loop time might be a little ms farther than what */
-  /* we've just computed, and we shouldn't update the loop time. */
+  /* The GetTickCount() resolution isn't too good. Sometimes it'll happen
+   * that GetQueuedCompletionStatus() or GetQueuedCompletionStatusEx() has
+   * waited for a couple of ms but this is not reflected in the GetTickCount
+   * result yet. Therefore whenever GetQueuedCompletionStatus times out
+   * we'll add the number of ms that it has waited to the current loop time.
+   * When that happened the loop time might be a little ms farther than what
+   * we've just computed, and we shouldn't update the loop time.
+   */
   if (loop->time < time.QuadPart)
     loop->time = time.QuadPart;
 }
@@ -193,24 +195,26 @@ uint64_t uv_timer_get_repeat(const uv_timer_t* handle) {
 }
 
 
-DWORD uv_get_poll_timeout(uv_loop_t* loop) {
+DWORD uv__next_timeout(const uv_loop_t* loop) {
   uv_timer_t* timer;
   int64_t delta;
 
-  /* Check if there are any running timers */
-  timer = RB_MIN(uv_timer_tree_s, &loop->timers);
+  /* Check if there are any running timers
+   * Need to cast away const first, since RB_MIN doesn't know what we are
+   * going to do with this return value, it can't be marked const
+   */
+  timer = RB_MIN(uv_timer_tree_s, &((uv_loop_t*)loop)->timers);
   if (timer) {
-    uv_update_time(loop);
-
     delta = timer->due - loop->time;
     if (delta >= UINT_MAX >> 1) {
-      /* A timeout value of UINT_MAX means infinite, so that's no good. But */
-      /* more importantly, there's always the risk that GetTickCount wraps. */
-      /* uv_update_time can detect this, but we must make sure that the */
-      /* tick counter never overflows twice between two subsequent */
-      /* uv_update_time calls. We do this by never sleeping more than half */
-      /* the time it takes to wrap  the counter - which is huge overkill, */
-      /* but hey, it's not so bad to wake up every 25 days. */
+      /* A timeout value of UINT_MAX means infinite, so that's no good. But
+       * more importantly, there's always the risk that GetTickCount wraps.
+       * uv_update_time can detect this, but we must make sure that the
+       * tick counter never overflows twice between two subsequent
+       * uv_update_time calls. We do this by never sleeping more than half
+       * the time it takes to wrap  the counter - which is huge overkill,
+       * but hey, it's not so bad to wake up every 25 days.
+       */
       return UINT_MAX >> 1;
     } else if (delta < 0) {
       /* Negative timeout values are not allowed */

data/ext/libuv/test/test-list.h

@@ -28,6 +28,7 @@ TEST_DECLARE   (loop_alive)
 TEST_DECLARE   (loop_close)
 TEST_DECLARE   (loop_stop)
 TEST_DECLARE   (loop_update_time)
+TEST_DECLARE   (loop_backend_timeout)
 TEST_DECLARE   (barrier_1)
 TEST_DECLARE   (barrier_2)
 TEST_DECLARE   (barrier_3)
@@ -72,7 +73,9 @@ TEST_DECLARE   (tcp_connect_error_fault)
 TEST_DECLARE   (tcp_connect_timeout)
 TEST_DECLARE   (tcp_close_while_connecting)
 TEST_DECLARE   (tcp_close)
+#ifndef _WIN32
 TEST_DECLARE   (tcp_close_accept)
+#endif
 TEST_DECLARE   (tcp_flags)
 TEST_DECLARE   (tcp_write_to_half_open_connection)
 TEST_DECLARE   (tcp_unexpected_read)
@@ -189,6 +192,7 @@ TEST_DECLARE   (spawn_stdout_to_file)
 TEST_DECLARE   (spawn_stdout_and_stderr_to_file)
 TEST_DECLARE   (spawn_auto_unref)
 TEST_DECLARE   (spawn_closed_process_io)
+TEST_DECLARE   (spawn_reads_child_path)
 TEST_DECLARE   (fs_poll)
 TEST_DECLARE   (fs_poll_getpath)
 TEST_DECLARE   (kill)
@@ -291,6 +295,7 @@ TASK_LIST_START
   TEST_ENTRY  (loop_close)
   TEST_ENTRY  (loop_stop)
   TEST_ENTRY  (loop_update_time)
+  TEST_ENTRY  (loop_backend_timeout)
   TEST_ENTRY  (barrier_1)
   TEST_ENTRY  (barrier_2)
   TEST_ENTRY  (barrier_3)
@@ -356,7 +361,9 @@ TASK_LIST_START
   TEST_ENTRY  (tcp_connect_timeout)
   TEST_ENTRY  (tcp_close_while_connecting)
   TEST_ENTRY  (tcp_close)
+#ifndef _WIN32
   TEST_ENTRY  (tcp_close_accept)
+#endif
   TEST_ENTRY  (tcp_flags)
   TEST_ENTRY  (tcp_write_to_half_open_connection)
   TEST_ENTRY  (tcp_unexpected_read)
@@ -514,6 +521,7 @@ TASK_LIST_START
   TEST_ENTRY  (spawn_stdout_and_stderr_to_file)
   TEST_ENTRY  (spawn_auto_unref)
   TEST_ENTRY  (spawn_closed_process_io)
+  TEST_ENTRY  (spawn_reads_child_path)
   TEST_ENTRY  (fs_poll)
   TEST_ENTRY  (fs_poll_getpath)
   TEST_ENTRY  (kill)

data/ext/libuv/test/test-loop-time.c

@@ -30,5 +30,34 @@ TEST_IMPL(loop_update_time) {
   while (uv_now(uv_default_loop()) - start < 1000)
     ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_NOWAIT));
 
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+static void cb(uv_timer_t* timer) {
+  uv_close((uv_handle_t*)timer, NULL);
+}
+
+TEST_IMPL(loop_backend_timeout) {
+  uv_loop_t *loop = uv_default_loop();
+  uv_timer_t timer;
+  int r;
+
+  r = uv_timer_init(loop, &timer);
+  ASSERT(r == 0);
+
+  ASSERT(!uv_loop_alive(loop));
+  ASSERT(uv_backend_timeout(loop) == 0);
+
+  r = uv_timer_start(&timer, cb, 1000, 0); /* 1 sec */
+  ASSERT(r == 0);
+  ASSERT(uv_backend_timeout(loop) > 100); /* 0.1 sec */
+  ASSERT(uv_backend_timeout(loop) <= 1000); /* 1 sec */
+
+  r = uv_run(loop, UV_RUN_DEFAULT);
+  ASSERT(r == 0);
+  ASSERT(uv_backend_timeout(loop) == 0);
+
+  MAKE_VALGRIND_HAPPY();
   return 0;
 }

data/ext/libuv/test/test-spawn.c

@@ -1291,3 +1291,38 @@ TEST_IMPL(closed_fd_events) {
   return 0;
 }
 #endif  /* !_WIN32 */
+
+TEST_IMPL(spawn_reads_child_path) {
+  int r;
+  int len;
+  char path[1024];
+  char *env[2] = {path, NULL};
+
+  /* Set up the process, but make sure that the file to run is relative and */
+  /* requires a lookup into PATH */
+  init_process_options("spawn_helper1", exit_cb);
+  options.file = "run-tests";
+  args[0] = "run-tests";
+
+  /* Set up the PATH env variable */
+  for (len = strlen(exepath);
+       exepath[len - 1] != '/' && exepath[len - 1] != '\\';
+       len--);
+  exepath[len] = 0;
+  strcpy(path, "PATH=");
+  strcpy(path + 5, exepath);
+
+  options.env = env;
+
+  r = uv_spawn(uv_default_loop(), &process, &options);
+  ASSERT(r == 0);
+
+  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+  ASSERT(r == 0);
+
+  ASSERT(exit_cb_called == 1);
+  ASSERT(close_cb_called == 1);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}

data/ext/libuv/test/test-tcp-close-accept.c

@@ -19,6 +19,9 @@
  * IN THE SOFTWARE.
  */
 
+/* this test is Unix only */
+#ifndef _WIN32
+
 #include "uv.h"
 #include "task.h"
 
@@ -181,3 +184,5 @@ TEST_IMPL(tcp_close_accept) {
   MAKE_VALGRIND_HAPPY();
   return 0;
 }
+
+#endif  /* !_WIN32 */

data/lib/libuv/ext/platform/darwin_x64.rb

@@ -9,6 +9,42 @@ module Libuv
                     :int32, :st_qspare_0, :int64, :st_qspare_1, :int64
         end
 
+        class Sockaddr < FFI::Struct
+            layout :sa_len, :uint8,
+                   :sa_family, :sa_family_t,
+                   :sa_data, [:char, 14]
+        end
+
+        class InAddr < FFI::Struct
+            layout :s_addr, :in_addr_t
+        end
+
+        class SockaddrIn < FFI::Struct
+            layout :sin_len, :uint8,
+                   :sin_family, :sa_family_t,
+                   :sin_port, :in_port_t,
+                   :sin_addr, InAddr,
+                   :sin_zero, [:char, 8]
+        end
+
+        class U6Addr < FFI::Union
+            layout :__u6_addr8, [:uint8, 16],
+                   :__u6_addr16, [:uint16, 8]
+        end
+
+        class In6Addr < FFI::Struct
+            layout :__u6_addr, U6Addr
+        end
+
+        class SockaddrIn6 < FFI::Struct
+            layout :sin6_len, :uint8,
+                   :sin6_family, :sa_family_t,
+                   :sin6_port, :in_port_t,
+                   :sin6_flowinfo, :uint32,
+                   :sin6_addr, In6Addr,
+                   :sin6_scope_id, :uint32
+        end
+
         class UvAddrinfo < FFI::Struct
             layout  :flags, :int,
                     :family, :int,

data/lib/libuv/ext/platform/linux.rb

@@ -4,5 +4,50 @@ module Libuv
         typedef :long, :blksize_t
         typedef :uint32, :in_addr_t
         typedef :ushort, :in_port_t
+
+
+        class Sockaddr < FFI::Struct
+            layout :sa_family, :sa_family_t,
+                   :sa_data, [:char, 14]
+        end
+
+        class InAddr < FFI::Struct
+            layout :s_addr, :in_addr_t
+        end
+
+        class SockaddrIn < FFI::Struct
+            layout :sin_family, :sa_family_t,
+                   :sin_port, :in_port_t,
+                   :sin_addr, InAddr,
+                   :sin_zero, [:char, 8]
+        end
+
+        class U6Addr < FFI::Union
+            layout :__u6_addr8, [:uint8, 16],
+                   :__u6_addr16, [:uint16, 8]
+        end
+
+        class In6Addr < FFI::Struct
+            layout :__u6_addr, U6Addr
+        end
+
+        class SockaddrIn6 < FFI::Struct
+            layout :sin6_family, :sa_family_t,
+                   :sin6_port, :in_port_t,
+                   :sin6_flowinfo, :uint32,
+                   :sin6_addr, In6Addr,
+                   :sin6_scope_id, :uint32
+        end
+
+        class UvAddrinfo < FFI::Struct
+            layout  :flags, :int,
+                    :family, :int,
+                    :socktype, :int,
+                    :protocol, :int,
+                    :addrlen, :socklen_t,
+                    :addr, Sockaddr.by_ref,
+                    :canonname, :string,
+                    :next, UvAddrinfo.by_ref
+        end
     end
 end

data/lib/libuv/ext/platform/unix.rb

@@ -13,17 +13,6 @@ module Libuv
                     :st_mtime, :time_t, :st_ctime, :time_t
         end
 
-        class UvAddrinfo < FFI::Struct
-            layout  :flags, :int,
-                    :family, :int,
-                    :socktype, :int,
-                    :protocol, :int,
-                    :addrlen, :socklen_t,
-                    :addr, Sockaddr.by_ref,
-                    :canonname, :string,
-                    :next, UvAddrinfo.by_ref
-        end
-
         attach_function :ntohs, [:ushort], :ushort, :blocking => true
     end
 end

data/lib/libuv/ext/platform/windows.rb

@@ -26,6 +26,46 @@ module Libuv
                     :st_rdev, :dev_t, :st_size, :off_t, :st_uid, :uid_t
         end
 
+
+
+        class Sockaddr < FFI::Struct
+            layout :sa_len, :uint8,
+                   :sa_family, :sa_family_t,
+                   :sa_data, [:char, 14]
+        end
+
+        class InAddr < FFI::Struct
+            layout :s_addr, :in_addr_t
+        end
+
+        class SockaddrIn < FFI::Struct
+            layout :sin_len, :uint8,
+                   :sin_family, :sa_family_t,
+                   :sin_port, :in_port_t,
+                   :sin_addr, InAddr,
+                   :sin_zero, [:char, 8]
+        end
+
+        class U6Addr < FFI::Union
+            layout :__u6_addr8, [:uint8, 16],
+                   :__u6_addr16, [:uint16, 8]
+        end
+
+        class In6Addr < FFI::Struct
+            layout :__u6_addr, U6Addr
+        end
+
+        class SockaddrIn6 < FFI::Struct
+            layout :sin6_len, :uint8,
+                   :sin6_family, :sa_family_t,
+                   :sin6_port, :in_port_t,
+                   :sin6_flowinfo, :uint32,
+                   :sin6_addr, In6Addr,
+                   :sin6_scope_id, :uint32
+        end
+
+
+
         class UvAddrinfo < FFI::Struct
             layout  :flags, :int,
                     :family, :int,

data/lib/libuv/ext/types.rb

@@ -8,28 +8,15 @@ end
 
 module Libuv
     module Ext
-        class Sockaddr < FFI::Struct
-            layout :sa_len, :uint8,
-                   :sa_family, :sa_family_t,
-                   :sa_data, [:char, 15]
-        end
-
-        class UvAddrinfo < FFI::Struct
-            layout  :flags, :int,
-                    :family, :int,
-                    :socktype, :int,
-                    :protocol, :int,
-                    :addrlen, :socklen_t,
-                    :addr, Sockaddr.by_ref,
-                    :canonname, :string,
-                    :next, :pointer
-        end
+        # Defined in platform code
+        class UvAddrinfo < FFI::Struct; end
 
         require 'libuv/ext/platform/linux.rb' if FFI::Platform.linux?
         require 'libuv/ext/platform/unix.rb' if FFI::Platform.unix?
         require 'libuv/ext/platform/darwin_x64.rb' if FFI::Platform.mac? and FFI::Platform::ARCH == 'x86_64'
         require 'libuv/ext/platform/windows.rb' if FFI::Platform.windows?
 
+
         enum :uv_handle_type, [
             :uv_unknown_handle, 0,
             :uv_async, # start UV_HANDLE_TYPE_MAP
@@ -108,39 +95,7 @@ module Libuv
         ]
 
         typedef UvBuf.by_ref, :uv_buf_t
-
-        class InAddr < FFI::Struct
-            layout :s_addr, :in_addr_t
-        end
-
-        class SockaddrIn < FFI::Struct
-            layout :sin_len, :uint8,
-                   :sin_family, :sa_family_t,
-                   :sin_port, :in_port_t,
-                   :sin_addr, InAddr,
-                   :sin_zero, [:char, 8]
-        end
-
         typedef SockaddrIn.by_ref, :sockaddr_in4
-
-        class U6Addr < FFI::Union
-            layout :__u6_addr8, [:uint8, 16],
-                   :__u6_addr16, [:uint16, 8]
-        end
-
-        class In6Addr < FFI::Struct
-            layout :__u6_addr, U6Addr
-        end
-
-        class SockaddrIn6 < FFI::Struct
-            layout :sin6_len, :uint8,
-                   :sin6_family, :sa_family_t,
-                   :sin6_port, :in_port_t,
-                   :sin6_flowinfo, :uint32,
-                   :sin6_addr, In6Addr,
-                   :sin6_scope_id, :uint32
-        end
-
         typedef SockaddrIn6.by_ref, :sockaddr_in6
 
 

data/lib/libuv/version.rb

@@ -1,3 +1,3 @@
 module Libuv
-    VERSION = '1.0.2'
+    VERSION = '1.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libuv
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Bulat Shakirzyanov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-04 00:00:00.000000000 Z
+date: 2014-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi