dart:io | Ensure that Directory.list terminates even when symbolic links create loops in the file s…

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 "bin/file.h"
 
@@ skipping 50 matching lines @@
       FILE_FLAG_BACKUP_SEMANTICS,
       NULL);
   if (handle == INVALID_HANDLE_VALUE) {
     return true;
   } else {
     CloseHandle(handle);
     return false;
   }
 }
 
+// A linked list structure holding a link target's unique file system ID.
+// Used to detect loops in the file system when listing recursively.
+struct LinkList {
+  DWORD volume;
+  DWORD id_low;
+  DWORD id_high;
+  LinkList* next;
+};
 
 // Forward declarations.
 static bool ListRecursively(PathBuffer* path,
                             bool recursive,
                             bool follow_links,
+                            LinkList* seen,
                             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,
+                      LinkList* seen,
                       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, follow_links, listing));
+      (!recursive ||
+       ListRecursively(path, recursive, follow_links, seen, listing));
 }
 
 
 static bool HandleFile(wchar_t* file_name,
                        PathBuffer* path,
                        DirectoryListing* listing) {
   if (!path->Add(file_name)) {
     PostError(listing, path->data);
     return false;
   }
@@ skipping 15 matching lines @@
   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,
+                        LinkList* seen,
                         DirectoryListing* listing) {
   DWORD attributes = find_file_data->dwFileAttributes;
   if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (!follow_links) {
       return HandleLink(find_file_data->cFileName, path, listing);
     }
     int path_length = path->length;
     if (!path->Add(find_file_data->cFileName)) return false;
-    bool broken = IsBrokenLink(path->data);
+    HANDLE handle = CreateFileW(
+        path->data,
+        0,
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+        NULL,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS,
+        NULL);
     path->Reset(path_length);
-    if (broken) {
+    if (handle == INVALID_HANDLE_VALUE) {
       // Report as (broken) link.
       return HandleLink(find_file_data->cFileName, path, listing);
     }
+    if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
+      // Check the seen link targets to see if we are in a file system loop.
+      LinkList current_link;
+      BY_HANDLE_FILE_INFORMATION info;
+      // Get info
+      if (!GetFileInformationByHandle(handle, &info)) {
+        DWORD error = GetLastError();
+        CloseHandle(handle);
+        SetLastError(error);
+        PostError(listing, path->data);
+        return false;
+      }
+      CloseHandle(handle);
+      current_link.volume = info.dwVolumeSerialNumber;
+      current_link.id_low = info.nFileIndexLow;
+      current_link.id_high = info.nFileIndexHigh;
+      current_link.next = seen;
+      LinkList* previous = seen;
+      while (previous != NULL) {
+        if (previous->volume == current_link.volume &&
+            previous->id_low == current_link.id_low &&
+            previous->id_high == current_link.id_high) {
+          // Report the looping link as a link, rather than following it.
+          return HandleLink(find_file_data->cFileName, path, listing);
+        }
+        previous = previous->next;
+      }
+      // Recurse into the directory, adding current link to the seen links list.
+      return HandleDir(find_file_data->cFileName,
+                       path,
+                       recursive,
+                       follow_links,
+                       &current_link,
+                       listing);
+    }
   }
   if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     return HandleDir(find_file_data->cFileName,
                      path,
                      recursive,
                      follow_links,
+                     seen,
                      listing);
   } else {
     return HandleFile(find_file_data->cFileName, path, listing);
   }
 }
 
 
 static bool ListRecursively(PathBuffer* path,
                             bool recursive,
                             bool follow_links,
+                            LinkList* seen,
                             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,
+                             seen,
                              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,
+                          seen,
                           listing) && success;
   }
 
   if (GetLastError() != ERROR_NO_MORE_FILES) {
     success = false;
     PostError(listing, path->data);
   }
 
   if (FindClose(find_handle) == 0) {
     success = false;
@@ skipping 104 matching lines @@
                      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, follow_links, listing);
+  return ListRecursively(&path, recursive, follow_links, NULL, 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 126 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)