[15/N] [libcxx] Implement the canonical function for windows

[mstorsjo]

Rebased on top of updated patches.

[amccarth]

libcxx/src/filesystem/operations.cpp

863

This return value needs to be checked more carefully.

If the final path is longer than the buffer, then GetFinalPathNameByHandleW will return the actual length needed, which will convince this if statement that the call succeeded when it didn't, and then we'll process the uninitialized buffer.

How can the final path require a buffer longer than MAX_PATH? Two ways:

1. The function always returns the \\?\ prefix, so a path that (with it's terminating L'\0') is exactly MAX_PATH will require MAX_PATH+4 when the prefix is added.

2. MAX_PATH applies to most Windows APIs, but not to the actual filesystem. It's possible to have a final path that's longer than MAX_PATH (especially since it's using the \\?\ prefix). If we don't think it's worth handling those, fine, but we'd need to detect that case so that we can return an error. (A common way this happens is when the user uses subst to replace a long prefix with a fictitious drive letter. This is, in fact, how we get certain LLDB source paths under the MAX_PATH limit on some of the Windows build bots.)

[mstorsjo]

libcxx/src/filesystem/operations.cpp

863

Thanks, good catch. Will update with a stack buffer that should fit all practical cases (MAX_PATH+10) and fall back on dynamic allocation if that wasn't big enough.

[mstorsjo]

Check the return value of GetFinalPathNameFromHandleW if it overflowed the buffer size and handle it appropriately.

[amccarth]

LGTM.

[mstorsjo]

Made a new realpath posix-like helper for windows, change explicit char to path::value_type in calling code.

[mstorsjo]

Rebased, retriggering CI.

Compared to the older version that @amccarth approved, this is a little bit reworked to fit into the POSIX realpath() interface, which means it returns a malloc() allocated buffer, so the end of the function uses a bit of memmove/wcscpy to assemble paths, instead of the slightly simpler version before (when operating on the level of the __canonical function that returns a std::filesystem::path).

This touches the existing code a little bit to just change char into path::value_type, and add the detail:: prefix on the calls to realpath().

[amccarth]

The changes to provide realpath on Windows looks right. Since it's relying on a system call, it would be difficult to create tests for the \\?\ and UNC cases. I'm assuming the more mainstream cases will be tested by existing tests. So LGTM.

libcxx/src/filesystem/operations.cpp

   ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
 
   path p = __do_absolute(orig_p, &cwd, ec);
-#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112
-  std::unique_ptr<char, decltype(&::free)>
-    hold(::realpath(p.c_str(), nullptr), &::free);
+#if (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || defined(_LIBCPP_WIN32API)
+  std::unique_ptr<path::value_type, decltype(&::free)>
+    hold(detail::realpath(p.c_str(), nullptr), &::free);
   if (hold.get() == nullptr)
     return err.report(capture_errno());
   return {hold.get()};
 #else
-  char buff[PATH_MAX + 1];
-  char* ret;
-  if ((ret = ::realpath(p.c_str(), buff)) == nullptr)
+  path::value_type buff[PATH_MAX + 1];
+  path::value_type* ret;
+  if ((ret = detail::realpath(p.c_str(), buff)) == nullptr)
     return err.report(capture_errno());
   return {ret};
 #endif

libcxx/src/filesystem/posix_compat.h

 int chdir(const wchar_t *path) { return _wchdir(path); }
 
 wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); }
+
+wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) {
+  // Only expected to be used with us allocating the buffer.
+  _LIBCPP_ASSERT(resolved_name == nullptr,
+                 "Windows realpath() assumes a null resolved_name");
+
+  WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
+  if (!h) {
+    set_errno();
+    return nullptr;
+  }
+  size_t buff_size = MAX_PATH + 10;
+  std::unique_ptr<wchar_t, decltype(&::free)> buff(
+      static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free);
+  DWORD retval = GetFinalPathNameByHandleW(
+      h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+  if (retval > buff_size) {
+    buff_size = retval;
+    buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))));
+    retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size,
+                                       FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+  }
+  if (!retval) {
+    set_errno();
+    return nullptr;
+  }
+  wchar_t *ptr = buff.get();
+  if (!wcsncmp(ptr, L"\\\\?\\", 4)) {
+    if (ptr[5] == ':') { // \\?\X: -> X:
+      memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t));
+    } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server
+      wcscpy(&ptr[0], L"\\\\");
+      memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t));
+    }
+  }
+  return buff.release();
+}
 #else
 int symlink_file(const char *oldname, const char *newname) {
   return ::symlink(oldname, newname);

 using ::lstat;
 using ::mkdir;
 using ::open;
+using ::realpath;
 using ::remove;
 using ::rename;
 using ::stat;