uv: upgrade to 38fc6ad

deps/uv/LICENSE

@@ -33,6 +33,8 @@ The externally maintained libraries used by libuv are:
 
   - ngx_queue.h (from Nginx), copyright Igor Sysoev. Two clause BSD license.
 
+  - c-ares, copyright Daniel Stenberg and others. MIT licensed.
+
   - libev, located at ev/ is copyright Marc Alexander Lehmann, and
     dual-licensed under the MIT license and GPL2.
 

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

@@ -414,7 +414,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
   uv_fs_event_cb cb;                      \
   wchar_t* filew;                         \
   wchar_t* short_filew;                   \
-  int is_path_dir;                        \
+  wchar_t* dirw;                          \
   char* buffer;
 
 int uv_utf16_to_utf8(const wchar_t* utf16Buffer, size_t utf16Size,

deps/uv/src/unix/kqueue.c

@@ -43,10 +43,12 @@ static void uv__fs_event_start(uv_fs_event_t* handle) {
              handle->fd,
              EV_LIBUV_KQUEUE_HACK);
   ev_io_start(handle->loop->ev, &handle->event_watcher);
+  ev_unref(handle->loop->ev);
 }
 
 
 static void uv__fs_event_stop(uv_fs_event_t* handle) {
+  ev_ref(handle->loop->ev);
   ev_io_stop(handle->loop->ev, &handle->event_watcher);
 }
 

deps/uv/src/unix/linux.c

@@ -283,12 +283,14 @@ int uv_fs_event_init(uv_loop_t* loop,
 
   ev_io_init(&handle->read_watcher, uv__inotify_read, fd, EV_READ);
   ev_io_start(loop->ev, &handle->read_watcher);
+  ev_unref(loop->ev);
 
   return 0;
 }
 
 
 void uv__fs_event_destroy(uv_fs_event_t* handle) {
+  ev_ref(handle->loop->ev);
   ev_io_stop(handle->loop->ev, &handle->read_watcher);
   uv__close(handle->fd);
   handle->fd = -1;

deps/uv/src/unix/sunos.c

@@ -166,12 +166,14 @@ int uv_fs_event_init(uv_loop_t* loop,
 
   ev_io_init(&handle->event_watcher, uv__fs_event_read, portfd, EV_READ);
   ev_io_start(loop->ev, &handle->event_watcher);
+  ev_unref(loop->ev);
 
   return 0;
 }
 
 
 void uv__fs_event_destroy(uv_fs_event_t* handle) {
+  ev_ref(handle->loop->ev);
   ev_io_stop(handle->loop->ev, &handle->event_watcher);
   uv__close(handle->fd);
   handle->fd = -1;

deps/uv/src/win/fs-event.c

@@ -22,6 +22,7 @@
 #include <assert.h>
 #include <malloc.h>
 #include <errno.h>
+#include <stdio.h>
 #include <string.h>
 #include "uv.h"
 #include "internal.h"
@@ -36,12 +37,12 @@ static void uv_fs_event_init_handle(uv_loop_t* loop, uv_fs_event_t* handle,
   handle->loop = loop;
   handle->flags = 0;
   handle->cb = cb;
-  handle->is_path_dir = 0;
   handle->dir_handle = INVALID_HANDLE_VALUE;
   handle->buffer = NULL;
   handle->req_pending = 0;
   handle->filew = NULL;
   handle->short_filew = NULL;
+  handle->dirw = NULL;
 
   uv_req_init(loop, (uv_req_t*)&handle->req);
   handle->req.type = UV_FS_EVENT_REQ;
@@ -134,9 +135,9 @@ static int uv_split_path(const wchar_t* filename, wchar_t** dir,
 
 int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
     const char* filename, uv_fs_event_cb cb, int flags) {
-  int name_size;
+  int name_size, is_path_dir;
   DWORD attr, last_error;
-  wchar_t* dir = NULL, *dir_to_watch, *filenamew;
+  wchar_t* dir = NULL, *dir_to_watch, *filenamew = NULL;
   wchar_t short_path[MAX_PATH];
 
   /* We don't support any flags yet. */
@@ -164,10 +165,11 @@ int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
     goto error;
   }
 
-  handle->is_path_dir = (attr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
+  is_path_dir = (attr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
 
-  if (handle->is_path_dir) {
+  if (is_path_dir) {
      /* filename is a directory, so that's the directory that we will watch. */
+    handle->dirw = filenamew;
     dir_to_watch = filenamew;
   } else {
     /* 
@@ -192,6 +194,8 @@ int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
     }
 
     dir_to_watch = dir;
+    free(filenamew);
+    filenamew = NULL;
   }
 
   handle->dir_handle = CreateFileW(dir_to_watch,
@@ -268,6 +272,8 @@ error:
     handle->short_filew = NULL;
   }
 
+  free(filenamew);
+
   if (handle->dir_handle != INVALID_HANDLE_VALUE) {
     CloseHandle(handle->dir_handle);
     handle->dir_handle = INVALID_HANDLE_VALUE;
@@ -286,8 +292,9 @@ error:
 void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
     uv_fs_event_t* handle) {
   FILE_NOTIFY_INFORMATION* file_info;
+  int sizew, size, result;
   char* filename = NULL;
-  int utf8size;
+  wchar_t* filenamew, *long_filenamew = NULL;
   DWORD offset = 0;
 
   assert(req->type == UV_FS_EVENT_REQ);
@@ -300,41 +307,116 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
     if (req->overlapped.InternalHigh > 0) {
       do {
         file_info = (FILE_NOTIFY_INFORMATION*)((char*)file_info + offset);
+        assert(!filename);
+        assert(!long_filenamew);
 
         /* 
          * Fire the event only if we were asked to watch a directory,
          * or if the filename filter matches.
          */
-        if (handle->is_path_dir ||
+        if (handle->dirw ||
           _wcsnicmp(handle->filew, file_info->FileName,
             file_info->FileNameLength / sizeof(wchar_t)) == 0 ||
           _wcsnicmp(handle->short_filew, file_info->FileName,
             file_info->FileNameLength / sizeof(wchar_t)) == 0) {
 
+          if (handle->dirw) {
+            /* 
+             * We attempt to convert the file name to its long form for 
+             * events that still point to valid files on disk.
+             * For removed and renamed events, we do not provide the file name.
+             */
+            if (file_info->Action != FILE_ACTION_REMOVED &&
+              file_info->Action != FILE_ACTION_RENAMED_OLD_NAME) {
+              /* Construct a full path to the file. */
+              size = wcslen(handle->dirw) +
+                file_info->FileNameLength / sizeof(wchar_t) + 2;
+
+              filenamew = (wchar_t*)malloc(size * sizeof(wchar_t));
+              if (!filenamew) {
+                uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
+              }
+
+              _snwprintf(filenamew, size, L"%s\\%s", handle->dirw,
+                file_info->FileName);
+
+              filenamew[size - 1] = L'\0';
+
+              /* Convert to long name. */
+              size = GetLongPathNameW(filenamew, NULL, 0);
+
+              if (size) {
+                long_filenamew = (wchar_t*)malloc(size * sizeof(wchar_t));
+                if (!long_filenamew) {
+                  uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
+                }
+
+                size = GetLongPathNameW(filenamew, long_filenamew, size);
+                if (size) {
+                  long_filenamew[size] = '\0';
+                } else {
+                  free(long_filenamew);
+                  long_filenamew = NULL;
+                }
+              }
+
+              free(filenamew);
+
+              if (long_filenamew) {
+                /* Get the file name out of the long path. */
+                result = uv_split_path(long_filenamew, NULL, &filenamew);
+                free(long_filenamew);
+
+                if (result == 0) {
+                  long_filenamew = filenamew;
+                  sizew = -1;
+                } else {
+                  long_filenamew = NULL;
+                }
+              }
+
+              /* 
+               * If we couldn't get the long name - just use the name
+               * provided by ReadDirectoryChangesW.
+               */
+              if (!long_filenamew) {
+                filenamew = file_info->FileName;
+                sizew = file_info->FileNameLength / sizeof(wchar_t);
+              }
+            } else {
+              /* Removed or renamed callbacks don't provide filename. */
+              filenamew = NULL;
+            }
+          } else {
+            /* We already have the long name of the file, so just use it. */
+            filenamew = handle->filew;
+            sizew = -1;
+          }
+
+          if (filenamew) {
             /* Convert the filename to utf8. */
-          utf8size = uv_utf16_to_utf8(file_info->FileName,
-                                      file_info->FileNameLength / 
-                                        sizeof(wchar_t),
+            size = uv_utf16_to_utf8(filenamew,
+                                    sizew,
                                     NULL,
                                     0);
-          if (utf8size) {
-            filename = (char*)malloc(utf8size + 1);
+            if (size) {
+              filename = (char*)malloc(size + 1);
               if (!filename) {
                 uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
               }
 
-            utf8size = uv_utf16_to_utf8(file_info->FileName,
-                                        file_info->FileNameLength /
-                                          sizeof(wchar_t),
+              size = uv_utf16_to_utf8(filenamew,
+                                      sizew,
                                       filename,
-                                        utf8size);
-            if (utf8size) {
-              filename[utf8size] = '\0';
+                                      size);
+              if (size) {
+                filename[size] = '\0';
               } else {
                 free(filename);
                 filename = NULL;
               }
             }
+          }
 
           switch (file_info->Action) {
             case FILE_ACTION_ADDED:
@@ -351,6 +433,8 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
 
           free(filename);
           filename = NULL;
+          free(long_filenamew);
+          long_filenamew = NULL;
         }
 
         offset = file_info->NextEntryOffset;
@@ -411,6 +495,11 @@ void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {
       handle->filename = NULL;
     }
 
+    if (handle->dirw) {
+      free(handle->dirw);
+      handle->dirw = NULL;
+    }
+
     if (handle->close_cb) {
       handle->close_cb((uv_handle_t*)handle);
     }

deps/uv/src/win/fs.c

@@ -542,8 +542,12 @@ void fs__fstat(uv_fs_t* req, uv_file file) {
 
 
 void fs__rename(uv_fs_t* req, const wchar_t* path, const wchar_t* new_path) {
-  int result = _wrename(path, new_path);
-  SET_REQ_RESULT(req, result);
+  if (!MoveFileExW(path, new_path, MOVEFILE_REPLACE_EXISTING)) {
+    SET_REQ_RESULT_WIN32_ERROR(req, GetLastError());
+    return;
+  }
+
+  SET_REQ_RESULT(req, 0);
 }
 
 

deps/uv/test/test-fs-event.c

@@ -282,7 +282,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
   ASSERT(status == 0);
 
   r = uv_fs_event_init(handle->loop, &fs_event, ".", fs_event_fail, 0);
-  ASSERT(r != -1);
+  ASSERT(r == 0);
 
   uv_close((uv_handle_t*)&fs_event, close_cb);
   uv_close((uv_handle_t*)handle, close_cb);
@@ -308,3 +308,21 @@ TEST_IMPL(fs_event_immediate_close) {
 
   return 0;
 }
+
+
+TEST_IMPL(fs_event_unref) {
+  uv_loop_t* loop;
+  int r;
+
+  loop = uv_default_loop();
+
+  r = uv_fs_event_init(loop, &fs_event, ".", fs_event_fail, 0);
+  ASSERT(r == 0);
+
+  uv_unref(loop);
+
+  r = uv_run(loop);
+  ASSERT(r == 0);
+
+  return 0;
+}

deps/uv/test/test-fs.c

@@ -1476,3 +1476,71 @@ TEST_IMPL(fs_file_open_append) {
 
   return 0;
 }
+
+
+TEST_IMPL(fs_rename_to_existing_file) {
+  int r;
+
+  /* Setup. */
+  unlink("test_file");
+  unlink("test_file2");
+
+  loop = uv_default_loop();
+
+  r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
+  ASSERT(open_req1.result != -1);
+  uv_fs_req_cleanup(&open_req1);
+
+  r = uv_fs_write(loop, &write_req, open_req1.result, test_buf,
+      sizeof(test_buf), -1, NULL);
+  ASSERT(r != -1);
+  ASSERT(write_req.result != -1);
+  uv_fs_req_cleanup(&write_req);
+
+  r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
+  ASSERT(r != -1);
+  ASSERT(close_req.result != -1);
+  uv_fs_req_cleanup(&close_req);
+
+  r = uv_fs_open(loop, &open_req1, "test_file2", O_WRONLY | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
+  ASSERT(open_req1.result != -1);
+  uv_fs_req_cleanup(&open_req1);
+
+  r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
+  ASSERT(r != -1);
+  ASSERT(close_req.result != -1);
+  uv_fs_req_cleanup(&close_req);
+
+  r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", NULL);
+  ASSERT(r != -1);
+  ASSERT(rename_req.result != -1);
+  uv_fs_req_cleanup(&rename_req);
+
+  r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(open_req1.result != -1);
+  uv_fs_req_cleanup(&open_req1);
+
+  memset(buf, 0, sizeof(buf));
+  r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
+      NULL);
+  ASSERT(r != -1);
+  ASSERT(read_req.result != -1);
+  ASSERT(strcmp(buf, test_buf) == 0);
+  uv_fs_req_cleanup(&read_req);
+
+  r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
+  ASSERT(r != -1);
+  ASSERT(close_req.result != -1);
+  uv_fs_req_cleanup(&close_req);
+
+  /* Cleanup */
+  unlink("test_file");
+  unlink("test_file2");
+
+  return 0;
+}

deps/uv/test/test-list.h

@@ -112,9 +112,11 @@ TEST_DECLARE   (fs_event_watch_file)
 TEST_DECLARE   (fs_event_watch_file_current_dir)
 TEST_DECLARE   (fs_event_no_callback_on_close)
 TEST_DECLARE   (fs_event_immediate_close)
+TEST_DECLARE   (fs_event_unref)
 TEST_DECLARE   (fs_readdir_empty_dir)
 TEST_DECLARE   (fs_readdir_file)
 TEST_DECLARE   (fs_open_dir)
+TEST_DECLARE   (fs_rename_to_existing_file)
 TEST_DECLARE   (threadpool_queue_work_simple)
 TEST_DECLARE   (counters_init)
 #ifdef _WIN32
@@ -267,9 +269,11 @@ TASK_LIST_START
   TEST_ENTRY  (fs_event_watch_file_current_dir)
   TEST_ENTRY  (fs_event_no_callback_on_close)
   TEST_ENTRY  (fs_event_immediate_close)
+  TEST_ENTRY  (fs_event_unref)
   TEST_ENTRY  (fs_readdir_empty_dir)
   TEST_ENTRY  (fs_readdir_file)
   TEST_ENTRY  (fs_open_dir)
+  TEST_ENTRY  (fs_rename_to_existing_file)
   TEST_ENTRY  (threadpool_queue_work_simple)
   TEST_ENTRY  (counters_init)