Use *W versions of win32 file functions

So that the long paths work on windows with registry LongPathsEnabled=1
ninja-build · Apr 21, 2023 · 5e85f4d · 5e85f4d
1 parent c266b21
commit 5e85f4d
Show file tree

Hide file tree

Showing 3 changed files with 67 additions and 19 deletions.
diff --git a/src/disk_interface.cc b/src/disk_interface.cc
@@ -25,7 +25,7 @@
 #ifdef _WIN32
 #include <sstream>
 #include <windows.h>
-#include <direct.h>  // _mkdir
+#include <fileapi.h>
 #else
 #include <unistd.h>
 #endif
@@ -56,7 +56,8 @@ string DirName(const string& path) {
 
 int MakeDir(const string& path) {
 #ifdef _WIN32
-  return _mkdir(path.c_str());
+  std::wstring wpath = ::toWide(path);
+  return CreateDirectoryW((LPCWSTR)wpath.c_str(), NULL) ? 0 : -1;
 #else
   return mkdir(path.c_str(), 0777);
 #endif
@@ -68,14 +69,15 @@ TimeStamp TimeStampFromFileTime(const FILETIME& filetime) {
   // We don't much care about epoch correctness but we do want the
   // resulting value to fit in a 64-bit integer.
   uint64_t mtime = ((uint64_t)filetime.dwHighDateTime << 32) |
-    ((uint64_t)filetime.dwLowDateTime);
+                   ((uint64_t)filetime.dwLowDateTime);
   // 1600 epoch -> 2000 epoch (subtract 400 years).
   return (TimeStamp)mtime - 12622770400LL * (1000000000LL / 100);
 }
 
 TimeStamp StatSingleFile(const string& path, string* err) {
   WIN32_FILE_ATTRIBUTE_DATA attrs;
-  if (!GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &attrs)) {
+  std::wstring wpath = ::toWide(path);
+  if (!GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &attrs)) {
     DWORD win_err = GetLastError();
     if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND)
       return 0;
@@ -218,43 +220,77 @@ TimeStamp RealDiskInterface::Stat(const string& path, string* err) const {
 #elif defined(__APPLE__)
   return ((int64_t)st.st_mtimespec.tv_sec * 1000000000LL +
           st.st_mtimespec.tv_nsec);
-#elif defined(st_mtime) // A macro, so we're likely on modern POSIX.
-  return (int64_t)st.st_mtim.tv_sec * 1000000000LL + st.st_mtim.tv_nsec;
+#elif defined(st_mtime)  // A macro, so we're likely on modern POSIX.
+return (int64_t)st.st_mtim.tv_sec * 1000000000LL + st.st_mtim.tv_nsec;
 #else
-  return (int64_t)st.st_mtime * 1000000000LL + st.st_mtimensec;
+return (int64_t)st.st_mtime * 1000000000LL + st.st_mtimensec;
 #endif
 #endif
 }
 
 bool RealDiskInterface::WriteFile(const string& path, const string& contents) {
+#ifdef _WIN32
+  std::wstring wpath = ::toWide(path);
+  HANDLE h = CreateFileW(wpath.c_str(), (GENERIC_READ | GENERIC_WRITE), 0, NULL,
+                         OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (h == INVALID_HANDLE_VALUE) {
+    Error("WriteFile(%s): Unable to create file. %s", path.c_str(),
+          GetLastErrorString().c_str());
+    return false;
+  }
+  DWORD written = 0;
+  bool result = ::WriteFile(h, (LPCVOID)contents.data(), contents.length(),
+                            &written, NULL);
+  if (!result || written != contents.length()) {
+    Error("WriteFile(%s): Unable to write to the file. %s", path.c_str(),
+          GetLastErrorString().c_str());
+    CloseHandle(h);
+    return false;
+  }
+
+  if (!CloseHandle(h)) {
+    Error("WriteFile(%s): Unable to close the file. %s", path.c_str(),
+          GetLastErrorString().c_str());
+    return false;
+  }
+
+  return true;
+#else
   FILE* fp = fopen(path.c_str(), "w");
   if (fp == NULL) {
-    Error("WriteFile(%s): Unable to create file. %s",
-          path.c_str(), strerror(errno));
+    Error("WriteFile(%s): Unable to create file. %s", path.c_str(),
+          strerror(errno));
     return false;
   }
 
-  if (fwrite(contents.data(), 1, contents.length(), fp) < contents.length())  {
-    Error("WriteFile(%s): Unable to write to the file. %s",
-          path.c_str(), strerror(errno));
+  if (fwrite(contents.data(), 1, contents.length(), fp) < contents.length()) {
+    Error("WriteFile(%s): Unable to write to the file. %s", path.c_str(),
+          strerror(errno));
     fclose(fp);
     return false;
   }
 
   if (fclose(fp) == EOF) {
-    Error("WriteFile(%s): Unable to close the file. %s",
-          path.c_str(), strerror(errno));
+    Error("WriteFile(%s): Unable to close the file. %s", path.c_str(),
+          strerror(errno));
     return false;
   }
 
   return true;
+#endif
 }
 
 bool RealDiskInterface::MakeDir(const string& path) {
   if (::MakeDir(path) < 0) {
+#if _WIN32
+    if (GetLastError() == ERROR_ALREADY_EXISTS) {
+      return true;
+    }
+#else
     if (errno == EEXIST) {
       return true;
     }
+#endif
     Error("mkdir(%s): %s", path.c_str(), strerror(errno));
     return false;
   }
@@ -273,7 +309,8 @@ FileReader::Status RealDiskInterface::ReadFile(const string& path,
 
 int RealDiskInterface::RemoveFile(const string& path) {
 #ifdef _WIN32
-  DWORD attributes = GetFileAttributesA(path.c_str());
+  std::wstring wpath = ::toWide(path);
+  DWORD attributes = GetFileAttributesW(wpath.c_str());
   if (attributes == INVALID_FILE_ATTRIBUTES) {
     DWORD win_err = GetLastError();
     if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
@@ -284,15 +321,15 @@ int RealDiskInterface::RemoveFile(const string& path) {
     // On Windows Ninja should behave the same:
     //   https://github.com/ninja-build/ninja/issues/1886
     // Skip error checking.  If this fails, accept whatever happens below.
-    SetFileAttributesA(path.c_str(), attributes & ~FILE_ATTRIBUTE_READONLY);
+    SetFileAttributesW(wpath.c_str(), attributes & ~FILE_ATTRIBUTE_READONLY);
   }
   if (attributes & FILE_ATTRIBUTE_DIRECTORY) {
     // remove() deletes both files and directories. On Windows we have to 
     // select the correct function (DeleteFile will yield Permission Denied when
     // used on a directory)
     // This fixes the behavior of ninja -t clean in some cases
     // https://github.com/ninja-build/ninja/issues/828
-    if (!RemoveDirectoryA(path.c_str())) {
+    if (!RemoveDirectoryW(wpath.c_str())) {
       DWORD win_err = GetLastError();
       if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
         return 1;
@@ -302,7 +339,7 @@ int RealDiskInterface::RemoveFile(const string& path) {
       return -1;
     }
   } else {
-    if (!DeleteFileA(path.c_str())) {
+    if (!DeleteFileW(wpath.c_str())) {
       DWORD win_err = GetLastError();
       if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
         return 1;

diff --git a/src/util.cc b/src/util.cc
@@ -340,7 +340,8 @@ int ReadFile(const string& path, string* contents, string* err) {
   // This makes a ninja run on a set of 1500 manifest files about 4% faster
   // than using the generic fopen code below.
   err->clear();
-  HANDLE f = ::CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
+  std::wstring wpath = ::toWide(path);
+  HANDLE f = ::CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
                            OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
   if (f == INVALID_HANDLE_VALUE) {
     err->assign(GetLastErrorString());
@@ -477,6 +478,13 @@ void Win32Fatal(const char* function, const char* hint) {
     Fatal("%s: %s", function, GetLastErrorString().c_str());
   }
 }
+
+std::wstring toWide(const string& s) {
+  int wchars_num = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, NULL, 0);
+  std::wstring w(wchars_num, ' ');
+  MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, (LPWSTR)w.data(), w.size());
+  return w;
+}
 #endif
 
 bool islatinalpha(int c) {

diff --git a/src/util.h b/src/util.h
@@ -126,6 +126,9 @@ std::string GetLastErrorString();
 
 /// Calls Fatal() with a function name and GetLastErrorString.
 NORETURN void Win32Fatal(const char* function, const char* hint = NULL);
+
+/// Converts utf-8 std::string to wide char wstring
+std::wstring toWide(const std::string& s);
 #endif
 
 #endif  // NINJA_UTIL_H_