lib/Support/Windows/Path.inc

   1 //===- llvm/Support/Windows/Path.inc - Windows Path Impl --------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Windows specific implementation of the Path API.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 //=== WARNING: Implementation here must contain only generic Windows code that
  16 //===          is guaranteed to work on *all* Windows variants.
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/Support/WindowsError.h"
  21 #include <fcntl.h>
  22 #include <io.h>
  23 #include <sys/stat.h>
  24 #include <sys/types.h>
  25
  26 // These two headers must be included last, and make sure shlobj is required
  27 // after Windows.h to make sure it picks up our definition of _WIN32_WINNT
  28 #include "WindowsSupport.h"
  29 #include <shlobj.h>
  30
  31 #undef max
  32
  33 // MinGW doesn't define this.
  34 #ifndef _ERRNO_T_DEFINED
  35 #define _ERRNO_T_DEFINED
  36 typedef int errno_t;
  37 #endif
  38
  39 #ifdef _MSC_VER
  40 # pragma comment(lib, "advapi32.lib")  // This provides CryptAcquireContextW.
  41 #endif
  42
  43 using namespace llvm;
  44
  45 using llvm::sys::windows::UTF8ToUTF16;
  46 using llvm::sys::windows::UTF16ToUTF8;
  47
  48 static std::error_code windows_error(DWORD E) {
  49   return mapWindowsError(E);
  50 }
  51
  52 static bool is_separator(const wchar_t value) {
  53   switch (value) {
  54   case L'\\':
  55   case L'/':
  56     return true;
  57   default:
  58     return false;
  59   }
  60 }
  61
  62 // Convert a UTF-8 path to UTF-16.  Also, if the absolute equivalent of the
  63 // path is longer than CreateDirectory can tolerate, make it absolute and
  64 // prefixed by '\\?\'.
  65 static std::error_code widenPath(const Twine &Path8,
  66                                  SmallVectorImpl<wchar_t> &Path16) {
  67   const size_t MaxDirLen = MAX_PATH - 12; // Must leave room for 8.3 filename.
  68
  69   // Several operations would convert Path8 to SmallString; more efficient to
  70   // do it once up front.
  71   SmallString<128> Path8Str;
  72   Path8.toVector(Path8Str);
  73
  74   // If we made this path absolute, how much longer would it get?
  75   size_t CurPathLen;
  76   if (llvm::sys::path::is_absolute(Twine(Path8Str)))
  77     CurPathLen = 0; // No contribution from current_path needed.
  78   else {
  79     CurPathLen = ::GetCurrentDirectoryW(0, NULL);
  80     if (CurPathLen == 0)
  81       return windows_error(::GetLastError());
  82   }
  83
  84   // Would the absolute path be longer than our limit?
  85   if ((Path8Str.size() + CurPathLen) >= MaxDirLen &&
  86       !Path8Str.startswith("\\\\?\\")) {
  87     SmallString<2*MAX_PATH> FullPath("\\\\?\\");
  88     if (CurPathLen) {
  89       SmallString<80> CurPath;
  90       if (std::error_code EC = llvm::sys::fs::current_path(CurPath))
  91         return EC;
  92       FullPath.append(CurPath);
  93     }
  94     // Traverse the requested path, canonicalizing . and .. as we go (because
  95     // the \\?\ prefix is documented to treat them as real components).
  96     // The iterators don't report separators and append() always attaches
  97     // preferred_separator so we don't need to call native() on the result.
  98     for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(Path8Str),
  99                                          E = llvm::sys::path::end(Path8Str);
 100                                          I != E; ++I) {
 101       if (I->size() == 1 && *I == ".")
 102         continue;
 103       if (I->size() == 2 && *I == "..")
 104         llvm::sys::path::remove_filename(FullPath);
 105       else
 106         llvm::sys::path::append(FullPath, *I);
 107     }
 108     return UTF8ToUTF16(FullPath, Path16);
 109   }
 110
 111   // Just use the caller's original path.
 112   return UTF8ToUTF16(Path8Str, Path16);
 113 }
 114
 115 namespace llvm {
 116 namespace sys  {
 117 namespace fs {
 118
 119 std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
 120   SmallVector<wchar_t, MAX_PATH> PathName;
 121   DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.capacity());
 122
 123   // A zero return value indicates a failure other than insufficient space.
 124   if (Size == 0)
 125     return "";
 126
 127   // Insufficient space is determined by a return value equal to the size of
 128   // the buffer passed in.
 129   if (Size == PathName.capacity())
 130     return "";
 131
 132   // On success, GetModuleFileNameW returns the number of characters written to
 133   // the buffer not including the NULL terminator.
 134   PathName.set_size(Size);
 135
 136   // Convert the result from UTF-16 to UTF-8.
 137   SmallVector<char, MAX_PATH> PathNameUTF8;
 138   if (UTF16ToUTF8(PathName.data(), PathName.size(), PathNameUTF8))
 139     return "";
 140
 141   return std::string(PathNameUTF8.data());
 142 }
 143
 144 UniqueID file_status::getUniqueID() const {
 145   // The file is uniquely identified by the volume serial number along
 146   // with the 64-bit file identifier.
 147   uint64_t FileID = (static_cast<uint64_t>(FileIndexHigh) << 32ULL) |
 148                     static_cast<uint64_t>(FileIndexLow);
 149
 150   return UniqueID(VolumeSerialNumber, FileID);
 151 }
 152
 153 TimeValue file_status::getLastModificationTime() const {
 154   ULARGE_INTEGER UI;
 155   UI.LowPart = LastWriteTimeLow;
 156   UI.HighPart = LastWriteTimeHigh;
 157
 158   TimeValue Ret;
 159   Ret.fromWin32Time(UI.QuadPart);
 160   return Ret;
 161 }
 162
 163 std::error_code current_path(SmallVectorImpl<char> &result) {
 164   SmallVector<wchar_t, MAX_PATH> cur_path;
 165   DWORD len = MAX_PATH;
 166
 167   do {
 168     cur_path.reserve(len);
 169     len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
 170
 171     // A zero return value indicates a failure other than insufficient space.
 172     if (len == 0)
 173       return windows_error(::GetLastError());
 174
 175     // If there's insufficient space, the len returned is larger than the len
 176     // given.
 177   } while (len > cur_path.capacity());
 178
 179   // On success, GetCurrentDirectoryW returns the number of characters not
 180   // including the null-terminator.
 181   cur_path.set_size(len);
 182   return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result);
 183 }
 184
 185 std::error_code create_directory(const Twine &path, bool IgnoreExisting) {
 186   SmallVector<wchar_t, 128> path_utf16;
 187
 188   if (std::error_code ec = widenPath(path, path_utf16))
 189     return ec;
 190
 191   if (!::CreateDirectoryW(path_utf16.begin(), NULL)) {
 192     DWORD LastError = ::GetLastError();
 193     if (LastError != ERROR_ALREADY_EXISTS || !IgnoreExisting)
 194       return windows_error(LastError);
 195   }
 196
 197   return std::error_code();
 198 }
 199
 200 // We can't use symbolic links for windows.
 201 std::error_code create_link(const Twine &to, const Twine &from) {
 202   // Convert to utf-16.
 203   SmallVector<wchar_t, 128> wide_from;
 204   SmallVector<wchar_t, 128> wide_to;
 205   if (std::error_code ec = widenPath(from, wide_from))
 206     return ec;
 207   if (std::error_code ec = widenPath(to, wide_to))
 208     return ec;
 209
 210   if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL))
 211     return windows_error(::GetLastError());
 212
 213   return std::error_code();
 214 }
 215
 216 std::error_code remove(const Twine &path, bool IgnoreNonExisting) {
 217   SmallVector<wchar_t, 128> path_utf16;
 218
 219   file_status ST;
 220   if (std::error_code EC = status(path, ST)) {
 221     if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
 222       return EC;
 223     return std::error_code();
 224   }
 225
 226   if (std::error_code ec = widenPath(path, path_utf16))
 227     return ec;
 228
 229   if (ST.type() == file_type::directory_file) {
 230     if (!::RemoveDirectoryW(c_str(path_utf16))) {
 231       std::error_code EC = windows_error(::GetLastError());
 232       if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
 233         return EC;
 234     }
 235     return std::error_code();
 236   }
 237   if (!::DeleteFileW(c_str(path_utf16))) {
 238     std::error_code EC = windows_error(::GetLastError());
 239     if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting)
 240       return EC;
 241   }
 242   return std::error_code();
 243 }
 244
 245 std::error_code rename(const Twine &from, const Twine &to) {
 246   // Convert to utf-16.
 247   SmallVector<wchar_t, 128> wide_from;
 248   SmallVector<wchar_t, 128> wide_to;
 249   if (std::error_code ec = widenPath(from, wide_from))
 250     return ec;
 251   if (std::error_code ec = widenPath(to, wide_to))
 252     return ec;
 253
 254   std::error_code ec = std::error_code();
 255   for (int i = 0; i < 2000; i++) {
 256     if (::MoveFileExW(wide_from.begin(), wide_to.begin(),
 257                       MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING))
 258       return std::error_code();
 259     DWORD LastError = ::GetLastError();
 260     if (LastError != ERROR_ACCESS_DENIED)
 261       break;
 262     // Retry MoveFile() at ACCESS_DENIED.
 263     // System scanners (eg. indexer) might open the source file when
 264     // It is written and closed.
 265     ::Sleep(1);
 266   }
 267
 268   return ec;
 269 }
 270
 271 std::error_code resize_file(const Twine &path, uint64_t size) {
 272   SmallVector<wchar_t, 128> path_utf16;
 273
 274   if (std::error_code ec = widenPath(path, path_utf16))
 275     return ec;
 276
 277   int fd = ::_wopen(path_utf16.begin(), O_BINARY | _O_RDWR, S_IWRITE);
 278   if (fd == -1)
 279     return std::error_code(errno, std::generic_category());
 280 #ifdef HAVE__CHSIZE_S
 281   errno_t error = ::_chsize_s(fd, size);
 282 #else
 283   errno_t error = ::_chsize(fd, size);
 284 #endif
 285   ::close(fd);
 286   return std::error_code(error, std::generic_category());
 287 }
 288
 289 std::error_code access(const Twine &Path, AccessMode Mode) {
 290   SmallVector<wchar_t, 128> PathUtf16;
 291
 292   if (std::error_code EC = widenPath(Path, PathUtf16))
 293     return EC;
 294
 295   DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin());
 296
 297   if (Attributes == INVALID_FILE_ATTRIBUTES) {
 298     // See if the file didn't actually exist.
 299     DWORD LastError = ::GetLastError();
 300     if (LastError != ERROR_FILE_NOT_FOUND &&
 301         LastError != ERROR_PATH_NOT_FOUND)
 302       return windows_error(LastError);
 303     return errc::no_such_file_or_directory;
 304   }
 305
 306   if (Mode == AccessMode::Write && (Attributes & FILE_ATTRIBUTE_READONLY))
 307     return errc::permission_denied;
 308
 309   return std::error_code();
 310 }
 311
 312 bool equivalent(file_status A, file_status B) {
 313   assert(status_known(A) && status_known(B));
 314   return A.FileIndexHigh      == B.FileIndexHigh &&
 315          A.FileIndexLow       == B.FileIndexLow &&
 316          A.FileSizeHigh       == B.FileSizeHigh &&
 317          A.FileSizeLow        == B.FileSizeLow &&
 318          A.LastWriteTimeHigh  == B.LastWriteTimeHigh &&
 319          A.LastWriteTimeLow   == B.LastWriteTimeLow &&
 320          A.VolumeSerialNumber == B.VolumeSerialNumber;
 321 }
 322
 323 std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
 324   file_status fsA, fsB;
 325   if (std::error_code ec = status(A, fsA))
 326     return ec;
 327   if (std::error_code ec = status(B, fsB))
 328     return ec;
 329   result = equivalent(fsA, fsB);
 330   return std::error_code();
 331 }
 332
 333 static bool isReservedName(StringRef path) {
 334   // This list of reserved names comes from MSDN, at:
 335   // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx
 336   static const char *sReservedNames[] = { "nul", "con", "prn", "aux",
 337                               "com1", "com2", "com3", "com4", "com5", "com6",
 338                               "com7", "com8", "com9", "lpt1", "lpt2", "lpt3",
 339                               "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9" };
 340
 341   // First, check to see if this is a device namespace, which always
 342   // starts with \\.\, since device namespaces are not legal file paths.
 343   if (path.startswith("\\\\.\\"))
 344     return true;
 345
 346   // Then compare against the list of ancient reserved names
 347   for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) {
 348     if (path.equals_lower(sReservedNames[i]))
 349       return true;
 350   }
 351
 352   // The path isn't what we consider reserved.
 353   return false;
 354 }
 355
 356 static std::error_code getStatus(HANDLE FileHandle, file_status &Result) {
 357   if (FileHandle == INVALID_HANDLE_VALUE)
 358     goto handle_status_error;
 359
 360   switch (::GetFileType(FileHandle)) {
 361   default:
 362     llvm_unreachable("Don't know anything about this file type");
 363   case FILE_TYPE_UNKNOWN: {
 364     DWORD Err = ::GetLastError();
 365     if (Err != NO_ERROR)
 366       return windows_error(Err);
 367     Result = file_status(file_type::type_unknown);
 368     return std::error_code();
 369   }
 370   case FILE_TYPE_DISK:
 371     break;
 372   case FILE_TYPE_CHAR:
 373     Result = file_status(file_type::character_file);
 374     return std::error_code();
 375   case FILE_TYPE_PIPE:
 376     Result = file_status(file_type::fifo_file);
 377     return std::error_code();
 378   }
 379
 380   BY_HANDLE_FILE_INFORMATION Info;
 381   if (!::GetFileInformationByHandle(FileHandle, &Info))
 382     goto handle_status_error;
 383
 384   {
 385     file_type Type = (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 386                          ? file_type::directory_file
 387                          : file_type::regular_file;
 388     Result =
 389         file_status(Type, Info.ftLastWriteTime.dwHighDateTime,
 390                     Info.ftLastWriteTime.dwLowDateTime,
 391                     Info.dwVolumeSerialNumber, Info.nFileSizeHigh,
 392                     Info.nFileSizeLow, Info.nFileIndexHigh, Info.nFileIndexLow);
 393     return std::error_code();
 394   }
 395
 396 handle_status_error:
 397   DWORD LastError = ::GetLastError();
 398   if (LastError == ERROR_FILE_NOT_FOUND ||
 399       LastError == ERROR_PATH_NOT_FOUND)
 400     Result = file_status(file_type::file_not_found);
 401   else if (LastError == ERROR_SHARING_VIOLATION)
 402     Result = file_status(file_type::type_unknown);
 403   else
 404     Result = file_status(file_type::status_error);
 405   return windows_error(LastError);
 406 }
 407
 408 std::error_code status(const Twine &path, file_status &result) {
 409   SmallString<128> path_storage;
 410   SmallVector<wchar_t, 128> path_utf16;
 411
 412   StringRef path8 = path.toStringRef(path_storage);
 413   if (isReservedName(path8)) {
 414     result = file_status(file_type::character_file);
 415     return std::error_code();
 416   }
 417
 418   if (std::error_code ec = widenPath(path8, path_utf16))
 419     return ec;
 420
 421   DWORD attr = ::GetFileAttributesW(path_utf16.begin());
 422   if (attr == INVALID_FILE_ATTRIBUTES)
 423     return getStatus(INVALID_HANDLE_VALUE, result);
 424
 425   // Handle reparse points.
 426   if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
 427     ScopedFileHandle h(
 428       ::CreateFileW(path_utf16.begin(),
 429                     0, // Attributes only.
 430                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
 431                     NULL,
 432                     OPEN_EXISTING,
 433                     FILE_FLAG_BACKUP_SEMANTICS,
 434                     0));
 435     if (!h)
 436       return getStatus(INVALID_HANDLE_VALUE, result);
 437   }
 438
 439   ScopedFileHandle h(
 440       ::CreateFileW(path_utf16.begin(), 0, // Attributes only.
 441                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
 442                     NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));
 443     if (!h)
 444       return getStatus(INVALID_HANDLE_VALUE, result);
 445
 446     return getStatus(h, result);
 447 }
 448
 449 std::error_code status(int FD, file_status &Result) {
 450   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
 451   return getStatus(FileHandle, Result);
 452 }
 453
 454 std::error_code setLastModificationAndAccessTime(int FD, TimeValue Time) {
 455   ULARGE_INTEGER UI;
 456   UI.QuadPart = Time.toWin32Time();
 457   FILETIME FT;
 458   FT.dwLowDateTime = UI.LowPart;
 459   FT.dwHighDateTime = UI.HighPart;
 460   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
 461   if (!SetFileTime(FileHandle, NULL, &FT, &FT))
 462     return windows_error(::GetLastError());
 463   return std::error_code();
 464 }
 465
 466 std::error_code mapped_file_region::init(int FD, bool CloseFD, uint64_t Offset) {
 467   FileDescriptor = FD;
 468   // Make sure that the requested size fits within SIZE_T.
 469   if (Size > std::numeric_limits<SIZE_T>::max()) {
 470     if (FileDescriptor) {
 471       if (CloseFD)
 472         _close(FileDescriptor);
 473     } else
 474       ::CloseHandle(FileHandle);
 475     return make_error_code(errc::invalid_argument);
 476   }
 477
 478   DWORD flprotect;
 479   switch (Mode) {
 480   case readonly:  flprotect = PAGE_READONLY; break;
 481   case readwrite: flprotect = PAGE_READWRITE; break;
 482   case priv:      flprotect = PAGE_WRITECOPY; break;
 483   }
 484
 485   FileMappingHandle =
 486       ::CreateFileMappingW(FileHandle, 0, flprotect,
 487                            (Offset + Size) >> 32,
 488                            (Offset + Size) & 0xffffffff,
 489                            0);
 490   if (FileMappingHandle == NULL) {
 491     std::error_code ec = windows_error(GetLastError());
 492     if (FileDescriptor) {
 493       if (CloseFD)
 494         _close(FileDescriptor);
 495     } else
 496       ::CloseHandle(FileHandle);
 497     return ec;
 498   }
 499
 500   DWORD dwDesiredAccess;
 501   switch (Mode) {
 502   case readonly:  dwDesiredAccess = FILE_MAP_READ; break;
 503   case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break;
 504   case priv:      dwDesiredAccess = FILE_MAP_COPY; break;
 505   }
 506   Mapping = ::MapViewOfFile(FileMappingHandle,
 507                             dwDesiredAccess,
 508                             Offset >> 32,
 509                             Offset & 0xffffffff,
 510                             Size);
 511   if (Mapping == NULL) {
 512     std::error_code ec = windows_error(GetLastError());
 513     ::CloseHandle(FileMappingHandle);
 514     if (FileDescriptor) {
 515       if (CloseFD)
 516         _close(FileDescriptor);
 517     } else
 518       ::CloseHandle(FileHandle);
 519     return ec;
 520   }
 521
 522   if (Size == 0) {
 523     MEMORY_BASIC_INFORMATION mbi;
 524     SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi));
 525     if (Result == 0) {
 526       std::error_code ec = windows_error(GetLastError());
 527       ::UnmapViewOfFile(Mapping);
 528       ::CloseHandle(FileMappingHandle);
 529       if (FileDescriptor) {
 530         if (CloseFD)
 531           _close(FileDescriptor);
 532       } else
 533         ::CloseHandle(FileHandle);
 534       return ec;
 535     }
 536     Size = mbi.RegionSize;
 537   }
 538
 539   // Close all the handles except for the view. It will keep the other handles
 540   // alive.
 541   ::CloseHandle(FileMappingHandle);
 542   if (FileDescriptor) {
 543     if (CloseFD)
 544       _close(FileDescriptor); // Also closes FileHandle.
 545   } else
 546     ::CloseHandle(FileHandle);
 547   return std::error_code();
 548 }
 549
 550 mapped_file_region::mapped_file_region(const Twine &path,
 551                                        mapmode mode,
 552                                        uint64_t length,
 553                                        uint64_t offset,
 554                                        std::error_code &ec)
 555   : Mode(mode)
 556   , Size(length)
 557   , Mapping()
 558   , FileDescriptor()
 559   , FileHandle(INVALID_HANDLE_VALUE)
 560   , FileMappingHandle() {
 561   SmallVector<wchar_t, 128> path_utf16;
 562
 563   // Convert path to UTF-16.
 564   if (ec = widenPath(path, path_utf16))
 565     return;
 566
 567   // Get file handle for creating a file mapping.
 568   FileHandle = ::CreateFileW(c_str(path_utf16),
 569                              Mode == readonly ? GENERIC_READ
 570                                               : GENERIC_READ | GENERIC_WRITE,
 571                              Mode == readonly ? FILE_SHARE_READ
 572                                               : 0,
 573                              0,
 574                              Mode == readonly ? OPEN_EXISTING
 575                                               : OPEN_ALWAYS,
 576                              Mode == readonly ? FILE_ATTRIBUTE_READONLY
 577                                               : FILE_ATTRIBUTE_NORMAL,
 578                              0);
 579   if (FileHandle == INVALID_HANDLE_VALUE) {
 580     ec = windows_error(::GetLastError());
 581     return;
 582   }
 583
 584   FileDescriptor = 0;
 585   ec = init(FileDescriptor, true, offset);
 586   if (ec) {
 587     Mapping = FileMappingHandle = 0;
 588     FileHandle = INVALID_HANDLE_VALUE;
 589     FileDescriptor = 0;
 590   }
 591 }
 592
 593 mapped_file_region::mapped_file_region(int fd,
 594                                        bool closefd,
 595                                        mapmode mode,
 596                                        uint64_t length,
 597                                        uint64_t offset,
 598                                        std::error_code &ec)
 599   : Mode(mode)
 600   , Size(length)
 601   , Mapping()
 602   , FileDescriptor(fd)
 603   , FileHandle(INVALID_HANDLE_VALUE)
 604   , FileMappingHandle() {
 605   FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
 606   if (FileHandle == INVALID_HANDLE_VALUE) {
 607     if (closefd)
 608       _close(FileDescriptor);
 609     FileDescriptor = 0;
 610     ec = make_error_code(errc::bad_file_descriptor);
 611     return;
 612   }
 613
 614   ec = init(FileDescriptor, closefd, offset);
 615   if (ec) {
 616     Mapping = FileMappingHandle = 0;
 617     FileHandle = INVALID_HANDLE_VALUE;
 618     FileDescriptor = 0;
 619   }
 620 }
 621
 622 mapped_file_region::~mapped_file_region() {
 623   if (Mapping)
 624     ::UnmapViewOfFile(Mapping);
 625 }
 626
 627 mapped_file_region::mapped_file_region(mapped_file_region &&other)
 628   : Mode(other.Mode)
 629   , Size(other.Size)
 630   , Mapping(other.Mapping)
 631   , FileDescriptor(other.FileDescriptor)
 632   , FileHandle(other.FileHandle)
 633   , FileMappingHandle(other.FileMappingHandle) {
 634   other.Mapping = other.FileMappingHandle = 0;
 635   other.FileHandle = INVALID_HANDLE_VALUE;
 636   other.FileDescriptor = 0;
 637 }
 638
 639 mapped_file_region::mapmode mapped_file_region::flags() const {
 640   assert(Mapping && "Mapping failed but used anyway!");
 641   return Mode;
 642 }
 643
 644 uint64_t mapped_file_region::size() const {
 645   assert(Mapping && "Mapping failed but used anyway!");
 646   return Size;
 647 }
 648
 649 char *mapped_file_region::data() const {
 650   assert(Mode != readonly && "Cannot get non-const data for readonly mapping!");
 651   assert(Mapping && "Mapping failed but used anyway!");
 652   return reinterpret_cast<char*>(Mapping);
 653 }
 654
 655 const char *mapped_file_region::const_data() const {
 656   assert(Mapping && "Mapping failed but used anyway!");
 657   return reinterpret_cast<const char*>(Mapping);
 658 }
 659
 660 int mapped_file_region::alignment() {
 661   SYSTEM_INFO SysInfo;
 662   ::GetSystemInfo(&SysInfo);
 663   return SysInfo.dwAllocationGranularity;
 664 }
 665
 666 std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
 667                                                 StringRef path){
 668   SmallVector<wchar_t, 128> path_utf16;
 669
 670   if (std::error_code ec = widenPath(path, path_utf16))
 671     return ec;
 672
 673   // Convert path to the format that Windows is happy with.
 674   if (path_utf16.size() > 0 &&
 675       !is_separator(path_utf16[path.size() - 1]) &&
 676       path_utf16[path.size() - 1] != L':') {
 677     path_utf16.push_back(L'\\');
 678     path_utf16.push_back(L'*');
 679   } else {
 680     path_utf16.push_back(L'*');
 681   }
 682
 683   //  Get the first directory entry.
 684   WIN32_FIND_DATAW FirstFind;
 685   ScopedFindHandle FindHandle(::FindFirstFileW(c_str(path_utf16), &FirstFind));
 686   if (!FindHandle)
 687     return windows_error(::GetLastError());
 688
 689   size_t FilenameLen = ::wcslen(FirstFind.cFileName);
 690   while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') ||
 691          (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' &&
 692                               FirstFind.cFileName[1] == L'.'))
 693     if (!::FindNextFileW(FindHandle, &FirstFind)) {
 694       DWORD LastError = ::GetLastError();
 695       // Check for end.
 696       if (LastError == ERROR_NO_MORE_FILES)
 697         return detail::directory_iterator_destruct(it);
 698       return windows_error(LastError);
 699     } else
 700       FilenameLen = ::wcslen(FirstFind.cFileName);
 701
 702   // Construct the current directory entry.
 703   SmallString<128> directory_entry_name_utf8;
 704   if (std::error_code ec =
 705           UTF16ToUTF8(FirstFind.cFileName, ::wcslen(FirstFind.cFileName),
 706                       directory_entry_name_utf8))
 707     return ec;
 708
 709   it.IterationHandle = intptr_t(FindHandle.take());
 710   SmallString<128> directory_entry_path(path);
 711   path::append(directory_entry_path, directory_entry_name_utf8.str());
 712   it.CurrentEntry = directory_entry(directory_entry_path.str());
 713
 714   return std::error_code();
 715 }
 716
 717 std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
 718   if (it.IterationHandle != 0)
 719     // Closes the handle if it's valid.
 720     ScopedFindHandle close(HANDLE(it.IterationHandle));
 721   it.IterationHandle = 0;
 722   it.CurrentEntry = directory_entry();
 723   return std::error_code();
 724 }
 725
 726 std::error_code detail::directory_iterator_increment(detail::DirIterState &it) {
 727   WIN32_FIND_DATAW FindData;
 728   if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) {
 729     DWORD LastError = ::GetLastError();
 730     // Check for end.
 731     if (LastError == ERROR_NO_MORE_FILES)
 732       return detail::directory_iterator_destruct(it);
 733     return windows_error(LastError);
 734   }
 735
 736   size_t FilenameLen = ::wcslen(FindData.cFileName);
 737   if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') ||
 738       (FilenameLen == 2 && FindData.cFileName[0] == L'.' &&
 739                            FindData.cFileName[1] == L'.'))
 740     return directory_iterator_increment(it);
 741
 742   SmallString<128> directory_entry_path_utf8;
 743   if (std::error_code ec =
 744           UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName),
 745                       directory_entry_path_utf8))
 746     return ec;
 747
 748   it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8));
 749   return std::error_code();
 750 }
 751
 752 std::error_code openFileForRead(const Twine &Name, int &ResultFD) {
 753   SmallVector<wchar_t, 128> PathUTF16;
 754
 755   if (std::error_code EC = widenPath(Name, PathUTF16))
 756     return EC;
 757
 758   HANDLE H = ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
 759                            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 760                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 761   if (H == INVALID_HANDLE_VALUE) {
 762     DWORD LastError = ::GetLastError();
 763     std::error_code EC = windows_error(LastError);
 764     // Provide a better error message when trying to open directories.
 765     // This only runs if we failed to open the file, so there is probably
 766     // no performances issues.
 767     if (LastError != ERROR_ACCESS_DENIED)
 768       return EC;
 769     if (is_directory(Name))
 770       return make_error_code(errc::is_a_directory);
 771     return EC;
 772   }
 773
 774   int FD = ::_open_osfhandle(intptr_t(H), 0);
 775   if (FD == -1) {
 776     ::CloseHandle(H);
 777     return windows_error(ERROR_INVALID_HANDLE);
 778   }
 779
 780   ResultFD = FD;
 781   return std::error_code();
 782 }
 783
 784 std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
 785                             sys::fs::OpenFlags Flags, unsigned Mode) {
 786   // Verify that we don't have both "append" and "excl".
 787   assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
 788          "Cannot specify both 'excl' and 'append' file creation flags!");
 789
 790   SmallVector<wchar_t, 128> PathUTF16;
 791
 792   if (std::error_code EC = widenPath(Name, PathUTF16))
 793     return EC;
 794
 795   DWORD CreationDisposition;
 796   if (Flags & F_Excl)
 797     CreationDisposition = CREATE_NEW;
 798   else if (Flags & F_Append)
 799     CreationDisposition = OPEN_ALWAYS;
 800   else
 801     CreationDisposition = CREATE_ALWAYS;
 802
 803   DWORD Access = GENERIC_WRITE;
 804   if (Flags & F_RW)
 805     Access |= GENERIC_READ;
 806
 807   HANDLE H = ::CreateFileW(PathUTF16.begin(), Access,
 808                            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 809                            CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
 810
 811   if (H == INVALID_HANDLE_VALUE) {
 812     DWORD LastError = ::GetLastError();
 813     std::error_code EC = windows_error(LastError);
 814     // Provide a better error message when trying to open directories.
 815     // This only runs if we failed to open the file, so there is probably
 816     // no performances issues.
 817     if (LastError != ERROR_ACCESS_DENIED)
 818       return EC;
 819     if (is_directory(Name))
 820       return make_error_code(errc::is_a_directory);
 821     return EC;
 822   }
 823
 824   int OpenFlags = 0;
 825   if (Flags & F_Append)
 826     OpenFlags |= _O_APPEND;
 827
 828   if (Flags & F_Text)
 829     OpenFlags |= _O_TEXT;
 830
 831   int FD = ::_open_osfhandle(intptr_t(H), OpenFlags);
 832   if (FD == -1) {
 833     ::CloseHandle(H);
 834     return windows_error(ERROR_INVALID_HANDLE);
 835   }
 836
 837   ResultFD = FD;
 838   return std::error_code();
 839 }
 840 } // end namespace fs
 841
 842 namespace path {
 843
 844 bool home_directory(SmallVectorImpl<char> &result) {
 845   wchar_t Path[MAX_PATH];
 846   if (::SHGetFolderPathW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0,
 847                          /*SHGFP_TYPE_CURRENT*/0, Path) != S_OK)
 848     return false;
 849
 850   if (UTF16ToUTF8(Path, ::wcslen(Path), result))
 851     return false;
 852
 853   return true;
 854 }
 855
 856 static bool getTempDirEnvVar(const char *Var, SmallVectorImpl<char> &Res) {
 857   SmallVector<wchar_t, 128> NameUTF16;
 858   if (windows::UTF8ToUTF16(Var, NameUTF16))
 859     return false;
 860
 861   SmallVector<wchar_t, 1024> Buf;
 862   size_t Size = 1024;
 863   do {
 864     Buf.reserve(Size);
 865     Size =
 866         GetEnvironmentVariableW(NameUTF16.data(), Buf.data(), Buf.capacity());
 867     if (Size == 0)
 868       return false;
 869
 870     // Try again with larger buffer.
 871   } while (Size > Buf.capacity());
 872   Buf.set_size(Size);
 873
 874   if (windows::UTF16ToUTF8(Buf.data(), Size, Res))
 875     return false;
 876   return true;
 877 }
 878
 879 static bool getTempDirEnvVar(SmallVectorImpl<char> &Res) {
 880   const char *EnvironmentVariables[] = {"TMP", "TEMP", "USERPROFILE"};
 881   for (const char *Env : EnvironmentVariables) {
 882     if (getTempDirEnvVar(Env, Res))
 883       return true;
 884   }
 885   return false;
 886 }
 887
 888 void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
 889   (void)ErasedOnReboot;
 890   Result.clear();
 891
 892   // Check whether the temporary directory is specified by an environment
 893   // variable.
 894   if (getTempDirEnvVar(Result))
 895     return;
 896
 897   // Fall back to a system default.
 898   const char *DefaultResult = "C:\\TEMP";
 899   Result.append(DefaultResult, DefaultResult + strlen(DefaultResult));
 900 }
 901 } // end namespace path
 902
 903 namespace windows {
 904 std::error_code UTF8ToUTF16(llvm::StringRef utf8,
 905                             llvm::SmallVectorImpl<wchar_t> &utf16) {
 906   if (!utf8.empty()) {
 907     int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
 908                                     utf8.size(), utf16.begin(), 0);
 909
 910     if (len == 0)
 911       return windows_error(::GetLastError());
 912
 913     utf16.reserve(len + 1);
 914     utf16.set_size(len);
 915
 916     len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
 917                                 utf8.size(), utf16.begin(), utf16.size());
 918
 919     if (len == 0)
 920       return windows_error(::GetLastError());
 921   }
 922
 923   // Make utf16 null terminated.
 924   utf16.push_back(0);
 925   utf16.pop_back();
 926
 927   return std::error_code();
 928 }
 929
 930 static
 931 std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16,
 932                                 size_t utf16_len,
 933                                 llvm::SmallVectorImpl<char> &utf8) {
 934   if (utf16_len) {
 935     // Get length.
 936     int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.begin(),
 937                                     0, NULL, NULL);
 938
 939     if (len == 0)
 940       return windows_error(::GetLastError());
 941
 942     utf8.reserve(len);
 943     utf8.set_size(len);
 944
 945     // Now do the actual conversion.
 946     len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.data(),
 947                                 utf8.size(), NULL, NULL);
 948
 949     if (len == 0)
 950       return windows_error(::GetLastError());
 951   }
 952
 953   // Make utf8 null terminated.
 954   utf8.push_back(0);
 955   utf8.pop_back();
 956
 957   return std::error_code();
 958 }
 959
 960 std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len,
 961                             llvm::SmallVectorImpl<char> &utf8) {
 962   return UTF16ToCodePage(CP_UTF8, utf16, utf16_len, utf8);
 963 }
 964
 965 std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len,
 966                              llvm::SmallVectorImpl<char> &utf8) {
 967   return UTF16ToCodePage(CP_ACP, utf16, utf16_len, utf8);
 968 }
 969 } // end namespace windows
 970 } // end namespace sys
 971 } // end namespace llvm