Path.inc revision 288943
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 36typedef int errno_t; 37#endif 38 39#ifdef _MSC_VER 40# pragma comment(lib, "advapi32.lib") // This provides CryptAcquireContextW. 41#endif 42 43using namespace llvm; 44 45using llvm::sys::windows::UTF8ToUTF16; 46using llvm::sys::windows::UTF16ToUTF8; 47using llvm::sys::path::widenPath; 48 49static bool is_separator(const wchar_t value) { 50 switch (value) { 51 case L'\\': 52 case L'/': 53 return true; 54 default: 55 return false; 56 } 57} 58 59namespace llvm { 60namespace sys { 61namespace path { 62 63// Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the 64// path is longer than CreateDirectory can tolerate, make it absolute and 65// prefixed by '\\?\'. 66std::error_code widenPath(const Twine &Path8, 67 SmallVectorImpl<wchar_t> &Path16) { 68 const size_t MaxDirLen = MAX_PATH - 12; // Must leave room for 8.3 filename. 69 70 // Several operations would convert Path8 to SmallString; more efficient to 71 // do it once up front. 72 SmallString<128> Path8Str; 73 Path8.toVector(Path8Str); 74 75 // If we made this path absolute, how much longer would it get? 76 size_t CurPathLen; 77 if (llvm::sys::path::is_absolute(Twine(Path8Str))) 78 CurPathLen = 0; // No contribution from current_path needed. 79 else { 80 CurPathLen = ::GetCurrentDirectoryW(0, NULL); 81 if (CurPathLen == 0) 82 return mapWindowsError(::GetLastError()); 83 } 84 85 // Would the absolute path be longer than our limit? 86 if ((Path8Str.size() + CurPathLen) >= MaxDirLen && 87 !Path8Str.startswith("\\\\?\\")) { 88 SmallString<2*MAX_PATH> FullPath("\\\\?\\"); 89 if (CurPathLen) { 90 SmallString<80> CurPath; 91 if (std::error_code EC = llvm::sys::fs::current_path(CurPath)) 92 return EC; 93 FullPath.append(CurPath); 94 } 95 // Traverse the requested path, canonicalizing . and .. as we go (because 96 // the \\?\ prefix is documented to treat them as real components). 97 // The iterators don't report separators and append() always attaches 98 // preferred_separator so we don't need to call native() on the result. 99 for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(Path8Str), 100 E = llvm::sys::path::end(Path8Str); 101 I != E; ++I) { 102 if (I->size() == 1 && *I == ".") 103 continue; 104 if (I->size() == 2 && *I == "..") 105 llvm::sys::path::remove_filename(FullPath); 106 else 107 llvm::sys::path::append(FullPath, *I); 108 } 109 return UTF8ToUTF16(FullPath, Path16); 110 } 111 112 // Just use the caller's original path. 113 return UTF8ToUTF16(Path8Str, Path16); 114} 115} // end namespace path 116 117namespace fs { 118 119std::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 144UniqueID 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 153TimeValue 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 163std::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 mapWindowsError(::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 185std::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 mapWindowsError(LastError); 195 } 196 197 return std::error_code(); 198} 199 200// We can't use symbolic links for windows. 201std::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 mapWindowsError(::GetLastError()); 212 213 return std::error_code(); 214} 215 216std::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 = mapWindowsError(::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 = mapWindowsError(::GetLastError()); 239 if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting) 240 return EC; 241 } 242 return std::error_code(); 243} 244 245std::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 ec = mapWindowsError(LastError); 261 if (LastError != ERROR_ACCESS_DENIED) 262 break; 263 // Retry MoveFile() at ACCESS_DENIED. 264 // System scanners (eg. indexer) might open the source file when 265 // It is written and closed. 266 ::Sleep(1); 267 } 268 269 return ec; 270} 271 272std::error_code resize_file(int FD, uint64_t Size) { 273#ifdef HAVE__CHSIZE_S 274 errno_t error = ::_chsize_s(FD, Size); 275#else 276 errno_t error = ::_chsize(FD, Size); 277#endif 278 return std::error_code(error, std::generic_category()); 279} 280 281std::error_code access(const Twine &Path, AccessMode Mode) { 282 SmallVector<wchar_t, 128> PathUtf16; 283 284 if (std::error_code EC = widenPath(Path, PathUtf16)) 285 return EC; 286 287 DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin()); 288 289 if (Attributes == INVALID_FILE_ATTRIBUTES) { 290 // See if the file didn't actually exist. 291 DWORD LastError = ::GetLastError(); 292 if (LastError != ERROR_FILE_NOT_FOUND && 293 LastError != ERROR_PATH_NOT_FOUND) 294 return mapWindowsError(LastError); 295 return errc::no_such_file_or_directory; 296 } 297 298 if (Mode == AccessMode::Write && (Attributes & FILE_ATTRIBUTE_READONLY)) 299 return errc::permission_denied; 300 301 return std::error_code(); 302} 303 304bool equivalent(file_status A, file_status B) { 305 assert(status_known(A) && status_known(B)); 306 return A.FileIndexHigh == B.FileIndexHigh && 307 A.FileIndexLow == B.FileIndexLow && 308 A.FileSizeHigh == B.FileSizeHigh && 309 A.FileSizeLow == B.FileSizeLow && 310 A.LastWriteTimeHigh == B.LastWriteTimeHigh && 311 A.LastWriteTimeLow == B.LastWriteTimeLow && 312 A.VolumeSerialNumber == B.VolumeSerialNumber; 313} 314 315std::error_code equivalent(const Twine &A, const Twine &B, bool &result) { 316 file_status fsA, fsB; 317 if (std::error_code ec = status(A, fsA)) 318 return ec; 319 if (std::error_code ec = status(B, fsB)) 320 return ec; 321 result = equivalent(fsA, fsB); 322 return std::error_code(); 323} 324 325static bool isReservedName(StringRef path) { 326 // This list of reserved names comes from MSDN, at: 327 // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx 328 static const char *sReservedNames[] = { "nul", "con", "prn", "aux", 329 "com1", "com2", "com3", "com4", "com5", "com6", 330 "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", 331 "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9" }; 332 333 // First, check to see if this is a device namespace, which always 334 // starts with \\.\, since device namespaces are not legal file paths. 335 if (path.startswith("\\\\.\\")) 336 return true; 337 338 // Then compare against the list of ancient reserved names 339 for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) { 340 if (path.equals_lower(sReservedNames[i])) 341 return true; 342 } 343 344 // The path isn't what we consider reserved. 345 return false; 346} 347 348static std::error_code getStatus(HANDLE FileHandle, file_status &Result) { 349 if (FileHandle == INVALID_HANDLE_VALUE) 350 goto handle_status_error; 351 352 switch (::GetFileType(FileHandle)) { 353 default: 354 llvm_unreachable("Don't know anything about this file type"); 355 case FILE_TYPE_UNKNOWN: { 356 DWORD Err = ::GetLastError(); 357 if (Err != NO_ERROR) 358 return mapWindowsError(Err); 359 Result = file_status(file_type::type_unknown); 360 return std::error_code(); 361 } 362 case FILE_TYPE_DISK: 363 break; 364 case FILE_TYPE_CHAR: 365 Result = file_status(file_type::character_file); 366 return std::error_code(); 367 case FILE_TYPE_PIPE: 368 Result = file_status(file_type::fifo_file); 369 return std::error_code(); 370 } 371 372 BY_HANDLE_FILE_INFORMATION Info; 373 if (!::GetFileInformationByHandle(FileHandle, &Info)) 374 goto handle_status_error; 375 376 { 377 file_type Type = (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 378 ? file_type::directory_file 379 : file_type::regular_file; 380 Result = 381 file_status(Type, Info.ftLastWriteTime.dwHighDateTime, 382 Info.ftLastWriteTime.dwLowDateTime, 383 Info.dwVolumeSerialNumber, Info.nFileSizeHigh, 384 Info.nFileSizeLow, Info.nFileIndexHigh, Info.nFileIndexLow); 385 return std::error_code(); 386 } 387 388handle_status_error: 389 DWORD LastError = ::GetLastError(); 390 if (LastError == ERROR_FILE_NOT_FOUND || 391 LastError == ERROR_PATH_NOT_FOUND) 392 Result = file_status(file_type::file_not_found); 393 else if (LastError == ERROR_SHARING_VIOLATION) 394 Result = file_status(file_type::type_unknown); 395 else 396 Result = file_status(file_type::status_error); 397 return mapWindowsError(LastError); 398} 399 400std::error_code status(const Twine &path, file_status &result) { 401 SmallString<128> path_storage; 402 SmallVector<wchar_t, 128> path_utf16; 403 404 StringRef path8 = path.toStringRef(path_storage); 405 if (isReservedName(path8)) { 406 result = file_status(file_type::character_file); 407 return std::error_code(); 408 } 409 410 if (std::error_code ec = widenPath(path8, path_utf16)) 411 return ec; 412 413 DWORD attr = ::GetFileAttributesW(path_utf16.begin()); 414 if (attr == INVALID_FILE_ATTRIBUTES) 415 return getStatus(INVALID_HANDLE_VALUE, result); 416 417 // Handle reparse points. 418 if (attr & FILE_ATTRIBUTE_REPARSE_POINT) { 419 ScopedFileHandle h( 420 ::CreateFileW(path_utf16.begin(), 421 0, // Attributes only. 422 FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 423 NULL, 424 OPEN_EXISTING, 425 FILE_FLAG_BACKUP_SEMANTICS, 426 0)); 427 if (!h) 428 return getStatus(INVALID_HANDLE_VALUE, result); 429 } 430 431 ScopedFileHandle h( 432 ::CreateFileW(path_utf16.begin(), 0, // Attributes only. 433 FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 434 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)); 435 if (!h) 436 return getStatus(INVALID_HANDLE_VALUE, result); 437 438 return getStatus(h, result); 439} 440 441std::error_code status(int FD, file_status &Result) { 442 HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 443 return getStatus(FileHandle, Result); 444} 445 446std::error_code setLastModificationAndAccessTime(int FD, TimeValue Time) { 447 ULARGE_INTEGER UI; 448 UI.QuadPart = Time.toWin32Time(); 449 FILETIME FT; 450 FT.dwLowDateTime = UI.LowPart; 451 FT.dwHighDateTime = UI.HighPart; 452 HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 453 if (!SetFileTime(FileHandle, NULL, &FT, &FT)) 454 return mapWindowsError(::GetLastError()); 455 return std::error_code(); 456} 457 458std::error_code mapped_file_region::init(int FD, uint64_t Offset, 459 mapmode Mode) { 460 // Make sure that the requested size fits within SIZE_T. 461 if (Size > std::numeric_limits<SIZE_T>::max()) 462 return make_error_code(errc::invalid_argument); 463 464 HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 465 if (FileHandle == INVALID_HANDLE_VALUE) 466 return make_error_code(errc::bad_file_descriptor); 467 468 DWORD flprotect; 469 switch (Mode) { 470 case readonly: flprotect = PAGE_READONLY; break; 471 case readwrite: flprotect = PAGE_READWRITE; break; 472 case priv: flprotect = PAGE_WRITECOPY; break; 473 } 474 475 HANDLE FileMappingHandle = 476 ::CreateFileMappingW(FileHandle, 0, flprotect, 477 (Offset + Size) >> 32, 478 (Offset + Size) & 0xffffffff, 479 0); 480 if (FileMappingHandle == NULL) { 481 std::error_code ec = mapWindowsError(GetLastError()); 482 return ec; 483 } 484 485 DWORD dwDesiredAccess; 486 switch (Mode) { 487 case readonly: dwDesiredAccess = FILE_MAP_READ; break; 488 case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break; 489 case priv: dwDesiredAccess = FILE_MAP_COPY; break; 490 } 491 Mapping = ::MapViewOfFile(FileMappingHandle, 492 dwDesiredAccess, 493 Offset >> 32, 494 Offset & 0xffffffff, 495 Size); 496 if (Mapping == NULL) { 497 std::error_code ec = mapWindowsError(GetLastError()); 498 ::CloseHandle(FileMappingHandle); 499 return ec; 500 } 501 502 if (Size == 0) { 503 MEMORY_BASIC_INFORMATION mbi; 504 SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi)); 505 if (Result == 0) { 506 std::error_code ec = mapWindowsError(GetLastError()); 507 ::UnmapViewOfFile(Mapping); 508 ::CloseHandle(FileMappingHandle); 509 return ec; 510 } 511 Size = mbi.RegionSize; 512 } 513 514 // Close all the handles except for the view. It will keep the other handles 515 // alive. 516 ::CloseHandle(FileMappingHandle); 517 return std::error_code(); 518} 519 520mapped_file_region::mapped_file_region(int fd, mapmode mode, uint64_t length, 521 uint64_t offset, std::error_code &ec) 522 : Size(length), Mapping() { 523 ec = init(fd, offset, mode); 524 if (ec) 525 Mapping = 0; 526} 527 528mapped_file_region::~mapped_file_region() { 529 if (Mapping) 530 ::UnmapViewOfFile(Mapping); 531} 532 533uint64_t mapped_file_region::size() const { 534 assert(Mapping && "Mapping failed but used anyway!"); 535 return Size; 536} 537 538char *mapped_file_region::data() const { 539 assert(Mapping && "Mapping failed but used anyway!"); 540 return reinterpret_cast<char*>(Mapping); 541} 542 543const char *mapped_file_region::const_data() const { 544 assert(Mapping && "Mapping failed but used anyway!"); 545 return reinterpret_cast<const char*>(Mapping); 546} 547 548int mapped_file_region::alignment() { 549 SYSTEM_INFO SysInfo; 550 ::GetSystemInfo(&SysInfo); 551 return SysInfo.dwAllocationGranularity; 552} 553 554std::error_code detail::directory_iterator_construct(detail::DirIterState &it, 555 StringRef path){ 556 SmallVector<wchar_t, 128> path_utf16; 557 558 if (std::error_code ec = widenPath(path, path_utf16)) 559 return ec; 560 561 // Convert path to the format that Windows is happy with. 562 if (path_utf16.size() > 0 && 563 !is_separator(path_utf16[path.size() - 1]) && 564 path_utf16[path.size() - 1] != L':') { 565 path_utf16.push_back(L'\\'); 566 path_utf16.push_back(L'*'); 567 } else { 568 path_utf16.push_back(L'*'); 569 } 570 571 // Get the first directory entry. 572 WIN32_FIND_DATAW FirstFind; 573 ScopedFindHandle FindHandle(::FindFirstFileW(c_str(path_utf16), &FirstFind)); 574 if (!FindHandle) 575 return mapWindowsError(::GetLastError()); 576 577 size_t FilenameLen = ::wcslen(FirstFind.cFileName); 578 while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') || 579 (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' && 580 FirstFind.cFileName[1] == L'.')) 581 if (!::FindNextFileW(FindHandle, &FirstFind)) { 582 DWORD LastError = ::GetLastError(); 583 // Check for end. 584 if (LastError == ERROR_NO_MORE_FILES) 585 return detail::directory_iterator_destruct(it); 586 return mapWindowsError(LastError); 587 } else 588 FilenameLen = ::wcslen(FirstFind.cFileName); 589 590 // Construct the current directory entry. 591 SmallString<128> directory_entry_name_utf8; 592 if (std::error_code ec = 593 UTF16ToUTF8(FirstFind.cFileName, ::wcslen(FirstFind.cFileName), 594 directory_entry_name_utf8)) 595 return ec; 596 597 it.IterationHandle = intptr_t(FindHandle.take()); 598 SmallString<128> directory_entry_path(path); 599 path::append(directory_entry_path, directory_entry_name_utf8); 600 it.CurrentEntry = directory_entry(directory_entry_path); 601 602 return std::error_code(); 603} 604 605std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) { 606 if (it.IterationHandle != 0) 607 // Closes the handle if it's valid. 608 ScopedFindHandle close(HANDLE(it.IterationHandle)); 609 it.IterationHandle = 0; 610 it.CurrentEntry = directory_entry(); 611 return std::error_code(); 612} 613 614std::error_code detail::directory_iterator_increment(detail::DirIterState &it) { 615 WIN32_FIND_DATAW FindData; 616 if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) { 617 DWORD LastError = ::GetLastError(); 618 // Check for end. 619 if (LastError == ERROR_NO_MORE_FILES) 620 return detail::directory_iterator_destruct(it); 621 return mapWindowsError(LastError); 622 } 623 624 size_t FilenameLen = ::wcslen(FindData.cFileName); 625 if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') || 626 (FilenameLen == 2 && FindData.cFileName[0] == L'.' && 627 FindData.cFileName[1] == L'.')) 628 return directory_iterator_increment(it); 629 630 SmallString<128> directory_entry_path_utf8; 631 if (std::error_code ec = 632 UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName), 633 directory_entry_path_utf8)) 634 return ec; 635 636 it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8)); 637 return std::error_code(); 638} 639 640std::error_code openFileForRead(const Twine &Name, int &ResultFD) { 641 SmallVector<wchar_t, 128> PathUTF16; 642 643 if (std::error_code EC = widenPath(Name, PathUTF16)) 644 return EC; 645 646 HANDLE H = ::CreateFileW(PathUTF16.begin(), GENERIC_READ, 647 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 648 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 649 if (H == INVALID_HANDLE_VALUE) { 650 DWORD LastError = ::GetLastError(); 651 std::error_code EC = mapWindowsError(LastError); 652 // Provide a better error message when trying to open directories. 653 // This only runs if we failed to open the file, so there is probably 654 // no performances issues. 655 if (LastError != ERROR_ACCESS_DENIED) 656 return EC; 657 if (is_directory(Name)) 658 return make_error_code(errc::is_a_directory); 659 return EC; 660 } 661 662 int FD = ::_open_osfhandle(intptr_t(H), 0); 663 if (FD == -1) { 664 ::CloseHandle(H); 665 return mapWindowsError(ERROR_INVALID_HANDLE); 666 } 667 668 ResultFD = FD; 669 return std::error_code(); 670} 671 672std::error_code openFileForWrite(const Twine &Name, int &ResultFD, 673 sys::fs::OpenFlags Flags, unsigned Mode) { 674 // Verify that we don't have both "append" and "excl". 675 assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) && 676 "Cannot specify both 'excl' and 'append' file creation flags!"); 677 678 SmallVector<wchar_t, 128> PathUTF16; 679 680 if (std::error_code EC = widenPath(Name, PathUTF16)) 681 return EC; 682 683 DWORD CreationDisposition; 684 if (Flags & F_Excl) 685 CreationDisposition = CREATE_NEW; 686 else if (Flags & F_Append) 687 CreationDisposition = OPEN_ALWAYS; 688 else 689 CreationDisposition = CREATE_ALWAYS; 690 691 DWORD Access = GENERIC_WRITE; 692 if (Flags & F_RW) 693 Access |= GENERIC_READ; 694 695 HANDLE H = ::CreateFileW(PathUTF16.begin(), Access, 696 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 697 CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL); 698 699 if (H == INVALID_HANDLE_VALUE) { 700 DWORD LastError = ::GetLastError(); 701 std::error_code EC = mapWindowsError(LastError); 702 // Provide a better error message when trying to open directories. 703 // This only runs if we failed to open the file, so there is probably 704 // no performances issues. 705 if (LastError != ERROR_ACCESS_DENIED) 706 return EC; 707 if (is_directory(Name)) 708 return make_error_code(errc::is_a_directory); 709 return EC; 710 } 711 712 int OpenFlags = 0; 713 if (Flags & F_Append) 714 OpenFlags |= _O_APPEND; 715 716 if (Flags & F_Text) 717 OpenFlags |= _O_TEXT; 718 719 int FD = ::_open_osfhandle(intptr_t(H), OpenFlags); 720 if (FD == -1) { 721 ::CloseHandle(H); 722 return mapWindowsError(ERROR_INVALID_HANDLE); 723 } 724 725 ResultFD = FD; 726 return std::error_code(); 727} 728} // end namespace fs 729 730namespace path { 731 732bool home_directory(SmallVectorImpl<char> &result) { 733 wchar_t Path[MAX_PATH]; 734 if (::SHGetFolderPathW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 735 /*SHGFP_TYPE_CURRENT*/0, Path) != S_OK) 736 return false; 737 738 if (UTF16ToUTF8(Path, ::wcslen(Path), result)) 739 return false; 740 741 return true; 742} 743 744static bool getTempDirEnvVar(const char *Var, SmallVectorImpl<char> &Res) { 745 SmallVector<wchar_t, 128> NameUTF16; 746 if (windows::UTF8ToUTF16(Var, NameUTF16)) 747 return false; 748 749 SmallVector<wchar_t, 1024> Buf; 750 size_t Size = 1024; 751 do { 752 Buf.reserve(Size); 753 Size = 754 GetEnvironmentVariableW(NameUTF16.data(), Buf.data(), Buf.capacity()); 755 if (Size == 0) 756 return false; 757 758 // Try again with larger buffer. 759 } while (Size > Buf.capacity()); 760 Buf.set_size(Size); 761 762 if (windows::UTF16ToUTF8(Buf.data(), Size, Res)) 763 return false; 764 return true; 765} 766 767static bool getTempDirEnvVar(SmallVectorImpl<char> &Res) { 768 const char *EnvironmentVariables[] = {"TMP", "TEMP", "USERPROFILE"}; 769 for (const char *Env : EnvironmentVariables) { 770 if (getTempDirEnvVar(Env, Res)) 771 return true; 772 } 773 return false; 774} 775 776void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) { 777 (void)ErasedOnReboot; 778 Result.clear(); 779 780 // Check whether the temporary directory is specified by an environment 781 // variable. 782 if (getTempDirEnvVar(Result)) 783 return; 784 785 // Fall back to a system default. 786 const char *DefaultResult = "C:\\TEMP"; 787 Result.append(DefaultResult, DefaultResult + strlen(DefaultResult)); 788} 789} // end namespace path 790 791namespace windows { 792std::error_code UTF8ToUTF16(llvm::StringRef utf8, 793 llvm::SmallVectorImpl<wchar_t> &utf16) { 794 if (!utf8.empty()) { 795 int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(), 796 utf8.size(), utf16.begin(), 0); 797 798 if (len == 0) 799 return mapWindowsError(::GetLastError()); 800 801 utf16.reserve(len + 1); 802 utf16.set_size(len); 803 804 len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(), 805 utf8.size(), utf16.begin(), utf16.size()); 806 807 if (len == 0) 808 return mapWindowsError(::GetLastError()); 809 } 810 811 // Make utf16 null terminated. 812 utf16.push_back(0); 813 utf16.pop_back(); 814 815 return std::error_code(); 816} 817 818static 819std::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16, 820 size_t utf16_len, 821 llvm::SmallVectorImpl<char> &utf8) { 822 if (utf16_len) { 823 // Get length. 824 int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.begin(), 825 0, NULL, NULL); 826 827 if (len == 0) 828 return mapWindowsError(::GetLastError()); 829 830 utf8.reserve(len); 831 utf8.set_size(len); 832 833 // Now do the actual conversion. 834 len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.data(), 835 utf8.size(), NULL, NULL); 836 837 if (len == 0) 838 return mapWindowsError(::GetLastError()); 839 } 840 841 // Make utf8 null terminated. 842 utf8.push_back(0); 843 utf8.pop_back(); 844 845 return std::error_code(); 846} 847 848std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len, 849 llvm::SmallVectorImpl<char> &utf8) { 850 return UTF16ToCodePage(CP_UTF8, utf16, utf16_len, utf8); 851} 852 853std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len, 854 llvm::SmallVectorImpl<char> &utf8) { 855 return UTF16ToCodePage(CP_ACP, utf16, utf16_len, utf8); 856} 857} // end namespace windows 858} // end namespace sys 859} // end namespace llvm 860