dart:io | Add "followLinks" optional parameter to Directory.list, let it return Link objects when f…

runtime/bin/directory_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/directory.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 34 matching lines @@
   void Reset(int new_length) {
     length = new_length;
     data[length] = L'\0';
   }
 };
 
 
 // Forward declarations.
 static bool ListRecursively(PathBuffer* path,
                             bool recursive,
+                            bool follow_links,
                             DirectoryListing* listing);
 static bool DeleteRecursively(PathBuffer* path);
 
 
 static void PostError(DirectoryListing* listing,
                       const wchar_t* dir_name) {
   const char* utf8_path = StringUtils::WideToUtf8(dir_name);
   listing->HandleError(utf8_path);
   free(const_cast<char*>(utf8_path));
 }
 
 
 static bool HandleDir(wchar_t* dir_name,
                       PathBuffer* path,
                       bool recursive,
+                      bool follow_links,
                       DirectoryListing* listing) {
   if (wcscmp(dir_name, L".") == 0) return true;
   if (wcscmp(dir_name, L"..") == 0) return true;
   if (!path->Add(dir_name)) {
     PostError(listing, path->data);
     return false;
   }
   char* utf8_path = StringUtils::WideToUtf8(path->data);
   bool ok = listing->HandleDirectory(utf8_path);
   free(utf8_path);
-  return ok && (!recursive || ListRecursively(path, recursive, listing));
+  return ok &&
+      (!recursive || ListRecursively(path, recursive, follow_links, listing));
 }
 
 
 static bool HandleFile(wchar_t* file_name,
                        PathBuffer* path,
                        DirectoryListing* listing) {
   if (!path->Add(file_name)) {
     PostError(listing, path->data);
     return false;
   }
   char* utf8_path = StringUtils::WideToUtf8(path->data);
   bool ok = listing->HandleFile(utf8_path);
   free(utf8_path);
   return ok;
 }
 
 
+static bool HandleLink(wchar_t* link_name,
+                       PathBuffer* path,
+                       DirectoryListing* listing) {
+  if (!path->Add(link_name)) {
+    PostError(listing, path->data);
+    return false;
+  }
+  char* utf8_path = StringUtils::WideToUtf8(path->data);
+  bool ok = listing->HandleLink(utf8_path);
+  free(utf8_path);
+  return ok;
+}
+
+
 static bool HandleEntry(LPWIN32_FIND_DATAW find_file_data,
                         PathBuffer* path,
                         bool recursive,
+                        bool follow_links,
                         DirectoryListing* listing) {
   DWORD attributes = find_file_data->dwFileAttributes;
-  if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
+  if (!follow_links && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+    return HandleLink(find_file_data->cFileName, path, listing);
+  } else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     return HandleDir(find_file_data->cFileName,
                      path,
                      recursive,
+                     follow_links,
                      listing);
   } else {
     return HandleFile(find_file_data->cFileName, path, listing);
   }
 }
 
 
 static bool ListRecursively(PathBuffer* path,
                             bool recursive,
+                            bool follow_links,
                             DirectoryListing* listing) {
   if (!path->Add(L"\\*")) {
     PostError(listing, path->data);
     return false;
   }
 
   WIN32_FIND_DATAW find_file_data;
   HANDLE find_handle = FindFirstFileW(path->data, &find_file_data);
 
   // Adjust the path by removing the '*' used for the search.
   path->Reset(path->length - 1);
 
   if (find_handle == INVALID_HANDLE_VALUE) {
     PostError(listing, path->data);
     return false;
   }
 
   int path_length = path->length;
   bool success = HandleEntry(&find_file_data,
                              path,
                              recursive,
+                             follow_links,
                              listing);
 
   while ((FindNextFileW(find_handle, &find_file_data) != 0)) {
     path->Reset(path_length);  // HandleEntry adds the entry name to path.
     success = HandleEntry(&find_file_data,
                           path,
                           recursive,
+                          follow_links,
                           listing) && success;
   }
 
   if (GetLastError() != ERROR_NO_MORE_FILES) {
     success = false;
     PostError(listing, path->data);
   }
 
   if (FindClose(find_handle) == 0) {
     success = false;
@@ skipping 89 matching lines @@
       (RemoveDirectoryW(path->data) == 0)) {
     return false;
   }
 
   return success;
 }
 
 
 bool Directory::List(const char* dir_name,
                      bool recursive,
+                     bool follow_links,
                      DirectoryListing* listing) {
   const wchar_t* system_name = StringUtils::Utf8ToWide(dir_name);
   PathBuffer path;
   if (!path.Add(system_name)) {
     PostError(listing, system_name);
     return false;
   }
   free(const_cast<wchar_t*>(system_name));
-  return ListRecursively(&path, recursive, listing);
+  return ListRecursively(&path, recursive, follow_links, listing);
 }
 
 
 static Directory::ExistsResult ExistsHelper(const wchar_t* dir_name) {
   DWORD attributes = GetFileAttributesW(dir_name);
   if (attributes == INVALID_FILE_ATTRIBUTES) {
     DWORD last_error = GetLastError();
     if (last_error == ERROR_FILE_NOT_FOUND ||
         last_error == ERROR_PATH_NOT_FOUND) {
       return Directory::DOES_NOT_EXIST;
@@ skipping 122 matching lines @@
   }
   DWORD flags = MOVEFILE_WRITE_THROUGH;
   int move_status =
       MoveFileExW(system_path, system_new_path, flags);
   free(const_cast<wchar_t*>(system_path));
   free(const_cast<wchar_t*>(system_new_path));
   return (move_status != 0);
 }
 
 #endif  // defined(TARGET_OS_WINDOWS)