Path.inc revision 2cf5425d0a048fbf36fc15035487f427499b514a 
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 "Windows.h"
21#include <fcntl.h>
22#include <io.h>
23#include <sys/stat.h>
24#include <sys/types.h>
25
26#undef max
27
28// MinGW doesn't define this.
29#ifndef _ERRNO_T_DEFINED
30#define _ERRNO_T_DEFINED
31typedef int errno_t;
32#endif
33
34using namespace llvm;
35
36namespace {
37  typedef BOOLEAN (WINAPI *PtrCreateSymbolicLinkW)(
38    /*__in*/ LPCWSTR lpSymlinkFileName,
39    /*__in*/ LPCWSTR lpTargetFileName,
40    /*__in*/ DWORD dwFlags);
41
42  PtrCreateSymbolicLinkW create_symbolic_link_api = PtrCreateSymbolicLinkW(
43    ::GetProcAddress(::GetModuleHandleA("kernel32.dll"),
44                     "CreateSymbolicLinkW"));
45
46  error_code UTF8ToUTF16(StringRef utf8, SmallVectorImpl<wchar_t> &utf16) {
47    int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
48                                    utf8.begin(), utf8.size(),
49                                    utf16.begin(), 0);
50
51    if (len == 0)
52      return windows_error(::GetLastError());
53
54    utf16.reserve(len + 1);
55    utf16.set_size(len);
56
57    len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
58                                    utf8.begin(), utf8.size(),
59                                    utf16.begin(), utf16.size());
60
61    if (len == 0)
62      return windows_error(::GetLastError());
63
64    // Make utf16 null terminated.
65    utf16.push_back(0);
66    utf16.pop_back();
67
68    return error_code::success();
69  }
70
71  error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len,
72                               SmallVectorImpl<char> &utf8) {
73    // Get length.
74    int len = ::WideCharToMultiByte(CP_UTF8, 0,
75                                    utf16, utf16_len,
76                                    utf8.begin(), 0,
77                                    NULL, NULL);
78
79    if (len == 0)
80      return windows_error(::GetLastError());
81
82    utf8.reserve(len);
83    utf8.set_size(len);
84
85    // Now do the actual conversion.
86    len = ::WideCharToMultiByte(CP_UTF8, 0,
87                                utf16, utf16_len,
88                                utf8.data(), utf8.size(),
89                                NULL, NULL);
90
91    if (len == 0)
92      return windows_error(::GetLastError());
93
94    // Make utf8 null terminated.
95    utf8.push_back(0);
96    utf8.pop_back();
97
98    return error_code::success();
99  }
100
101  error_code TempDir(SmallVectorImpl<wchar_t> &result) {
102  retry_temp_dir:
103    DWORD len = ::GetTempPathW(result.capacity(), result.begin());
104
105    if (len == 0)
106      return windows_error(::GetLastError());
107
108    if (len > result.capacity()) {
109      result.reserve(len);
110      goto retry_temp_dir;
111    }
112
113    result.set_size(len);
114    return error_code::success();
115  }
116
117  bool is_separator(const wchar_t value) {
118    switch (value) {
119    case L'\\':
120    case L'/':
121      return true;
122    default:
123      return false;
124    }
125  }
126}
127
128// FIXME: mode should be used here and default to user r/w only,
129// it currently comes in as a UNIX mode.
130static error_code createUniqueEntity(const Twine &model, int &result_fd,
131                                     SmallVectorImpl<char> &result_path,
132                                     bool makeAbsolute, unsigned mode,
133                                     FSEntity Type) {
134  // Use result_path as temp storage.
135  result_path.set_size(0);
136  StringRef m = model.toStringRef(result_path);
137
138  SmallVector<wchar_t, 128> model_utf16;
139  if (error_code ec = UTF8ToUTF16(m, model_utf16)) return ec;
140
141  if (makeAbsolute) {
142    // Make model absolute by prepending a temp directory if it's not already.
143    bool absolute = sys::path::is_absolute(m);
144
145    if (!absolute) {
146      SmallVector<wchar_t, 64> temp_dir;
147      if (error_code ec = TempDir(temp_dir)) return ec;
148      // Handle c: by removing it.
149      if (model_utf16.size() > 2 && model_utf16[1] == L':') {
150        model_utf16.erase(model_utf16.begin(), model_utf16.begin() + 2);
151      }
152      model_utf16.insert(model_utf16.begin(), temp_dir.begin(), temp_dir.end());
153    }
154  }
155
156  // Replace '%' with random chars. From here on, DO NOT modify model. It may be
157  // needed if the randomly chosen path already exists.
158  SmallVector<wchar_t, 128> random_path_utf16;
159
160  // Get a Crypto Provider for CryptGenRandom.
161  HCRYPTPROV HCPC;
162  if (!::CryptAcquireContextW(&HCPC,
163                              NULL,
164                              NULL,
165                              PROV_RSA_FULL,
166                              CRYPT_VERIFYCONTEXT))
167    return windows_error(::GetLastError());
168  ScopedCryptContext CryptoProvider(HCPC);
169
170retry_random_path:
171  random_path_utf16.set_size(0);
172  for (SmallVectorImpl<wchar_t>::const_iterator i = model_utf16.begin(),
173                                                e = model_utf16.end();
174                                                i != e; ++i) {
175    if (*i == L'%') {
176      BYTE val = 0;
177      if (!::CryptGenRandom(CryptoProvider, 1, &val))
178          return windows_error(::GetLastError());
179      random_path_utf16.push_back("0123456789abcdef"[val & 15]);
180    }
181    else
182      random_path_utf16.push_back(*i);
183  }
184  // Make random_path_utf16 null terminated.
185  random_path_utf16.push_back(0);
186  random_path_utf16.pop_back();
187
188  HANDLE TempFileHandle;
189
190  switch (Type) {
191  case FS_File: {
192    // Try to create + open the path.
193    TempFileHandle =
194        ::CreateFileW(random_path_utf16.begin(), GENERIC_READ | GENERIC_WRITE,
195                      FILE_SHARE_READ, NULL,
196                      // Return ERROR_FILE_EXISTS if the file
197                      // already exists.
198                      CREATE_NEW, FILE_ATTRIBUTE_TEMPORARY, NULL);
199    if (TempFileHandle == INVALID_HANDLE_VALUE) {
200      // If the file existed, try again, otherwise, error.
201      error_code ec = windows_error(::GetLastError());
202      if (ec == windows_error::file_exists)
203        goto retry_random_path;
204
205      return ec;
206    }
207
208    // Convert the Windows API file handle into a C-runtime handle.
209    int fd = ::_open_osfhandle(intptr_t(TempFileHandle), 0);
210    if (fd == -1) {
211      ::CloseHandle(TempFileHandle);
212      ::DeleteFileW(random_path_utf16.begin());
213      // MSDN doesn't say anything about _open_osfhandle setting errno or
214      // GetLastError(), so just return invalid_handle.
215      return windows_error::invalid_handle;
216    }
217
218    result_fd = fd;
219    break;
220  }
221
222  case FS_Name: {
223    DWORD attributes = ::GetFileAttributesW(random_path_utf16.begin());
224    if (attributes != INVALID_FILE_ATTRIBUTES)
225      goto retry_random_path;
226    error_code EC = make_error_code(windows_error(::GetLastError()));
227    if (EC != windows_error::file_not_found &&
228        EC != windows_error::path_not_found)
229      return EC;
230    break;
231  }
232
233  case FS_Dir:
234    if (!::CreateDirectoryW(random_path_utf16.begin(), NULL)) {
235      error_code EC = windows_error(::GetLastError());
236      if (EC != windows_error::already_exists)
237        return EC;
238      goto retry_random_path;
239    }
240    break;
241  }
242
243  // Set result_path to the utf-8 representation of the path.
244  if (error_code ec = UTF16ToUTF8(random_path_utf16.begin(),
245                                  random_path_utf16.size(), result_path)) {
246    switch (Type) {
247    case FS_File:
248      ::CloseHandle(TempFileHandle);
249      ::DeleteFileW(random_path_utf16.begin());
250    case FS_Name:
251      break;
252    case FS_Dir:
253      ::RemoveDirectoryW(random_path_utf16.begin());
254      break;
255    }
256    return ec;
257  }
258
259  return error_code::success();
260}
261
262namespace llvm {
263namespace sys  {
264namespace fs {
265
266std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
267  char pathname[MAX_PATH];
268  DWORD ret = ::GetModuleFileNameA(NULL, pathname, MAX_PATH);
269  return ret != MAX_PATH ? pathname : "";
270}
271
272
273TimeValue file_status::getLastModificationTime() const {
274  ULARGE_INTEGER UI;
275  UI.LowPart = LastWriteTimeLow;
276  UI.HighPart = LastWriteTimeHigh;
277
278  TimeValue Ret;
279  Ret.fromWin32Time(UI.QuadPart);
280  return Ret;
281}
282
283error_code current_path(SmallVectorImpl<char> &result) {
284  SmallVector<wchar_t, 128> cur_path;
285  cur_path.reserve(128);
286retry_cur_dir:
287  DWORD len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
288
289  // A zero return value indicates a failure other than insufficient space.
290  if (len == 0)
291    return windows_error(::GetLastError());
292
293  // If there's insufficient space, the len returned is larger than the len
294  // given.
295  if (len > cur_path.capacity()) {
296    cur_path.reserve(len);
297    goto retry_cur_dir;
298  }
299
300  cur_path.set_size(len);
301  // cur_path now holds the current directory in utf-16. Convert to utf-8.
302
303  // Find out how much space we need. Sadly, this function doesn't return the
304  // size needed unless you tell it the result size is 0, which means you
305  // _always_ have to call it twice.
306  len = ::WideCharToMultiByte(CP_UTF8, 0,
307                              cur_path.data(), cur_path.size(),
308                              result.data(), 0,
309                              NULL, NULL);
310
311  if (len == 0)
312    return make_error_code(windows_error(::GetLastError()));
313
314  result.reserve(len);
315  result.set_size(len);
316  // Now do the actual conversion.
317  len = ::WideCharToMultiByte(CP_UTF8, 0,
318                              cur_path.data(), cur_path.size(),
319                              result.data(), result.size(),
320                              NULL, NULL);
321  if (len == 0)
322    return windows_error(::GetLastError());
323
324  return error_code::success();
325}
326
327error_code create_directory(const Twine &path, bool &existed) {
328  SmallString<128> path_storage;
329  SmallVector<wchar_t, 128> path_utf16;
330
331  if (error_code ec = UTF8ToUTF16(path.toStringRef(path_storage),
332                                  path_utf16))
333    return ec;
334
335  if (!::CreateDirectoryW(path_utf16.begin(), NULL)) {
336    error_code ec = windows_error(::GetLastError());
337    if (ec == windows_error::already_exists)
338      existed = true;
339    else
340      return ec;
341  } else
342    existed = false;
343
344  return error_code::success();
345}
346
347error_code create_hard_link(const Twine &to, const Twine &from) {
348  // Get arguments.
349  SmallString<128> from_storage;
350  SmallString<128> to_storage;
351  StringRef f = from.toStringRef(from_storage);
352  StringRef t = to.toStringRef(to_storage);
353
354  // Convert to utf-16.
355  SmallVector<wchar_t, 128> wide_from;
356  SmallVector<wchar_t, 128> wide_to;
357  if (error_code ec = UTF8ToUTF16(f, wide_from)) return ec;
358  if (error_code ec = UTF8ToUTF16(t, wide_to)) return ec;
359
360  if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL))
361    return windows_error(::GetLastError());
362
363  return error_code::success();
364}
365
366error_code create_symlink(const Twine &to, const Twine &from) {
367  // Only do it if the function is available at runtime.
368  if (!create_symbolic_link_api)
369    return make_error_code(errc::function_not_supported);
370
371  // Get arguments.
372  SmallString<128> from_storage;
373  SmallString<128> to_storage;
374  StringRef f = from.toStringRef(from_storage);
375  StringRef t = to.toStringRef(to_storage);
376
377  // Convert to utf-16.
378  SmallVector<wchar_t, 128> wide_from;
379  SmallVector<wchar_t, 128> wide_to;
380  if (error_code ec = UTF8ToUTF16(f, wide_from)) return ec;
381  if (error_code ec = UTF8ToUTF16(t, wide_to)) return ec;
382
383  if (!create_symbolic_link_api(wide_from.begin(), wide_to.begin(), 0))
384    return windows_error(::GetLastError());
385
386  return error_code::success();
387}
388
389error_code remove(const Twine &path, bool &existed) {
390  SmallString<128> path_storage;
391  SmallVector<wchar_t, 128> path_utf16;
392
393  file_status st;
394  if (error_code ec = status(path, st))
395    return ec;
396
397  if (error_code ec = UTF8ToUTF16(path.toStringRef(path_storage),
398                                  path_utf16))
399    return ec;
400
401  if (st.type() == file_type::directory_file) {
402    if (!::RemoveDirectoryW(c_str(path_utf16))) {
403      error_code ec = windows_error(::GetLastError());
404      if (ec != windows_error::file_not_found)
405        return ec;
406      existed = false;
407    } else
408      existed = true;
409  } else {
410    if (!::DeleteFileW(c_str(path_utf16))) {
411      error_code ec = windows_error(::GetLastError());
412      if (ec != windows_error::file_not_found)
413        return ec;
414      existed = false;
415    } else
416      existed = true;
417  }
418
419  return error_code::success();
420}
421
422error_code rename(const Twine &from, const Twine &to) {
423  // Get arguments.
424  SmallString<128> from_storage;
425  SmallString<128> to_storage;
426  StringRef f = from.toStringRef(from_storage);
427  StringRef t = to.toStringRef(to_storage);
428
429  // Convert to utf-16.
430  SmallVector<wchar_t, 128> wide_from;
431  SmallVector<wchar_t, 128> wide_to;
432  if (error_code ec = UTF8ToUTF16(f, wide_from)) return ec;
433  if (error_code ec = UTF8ToUTF16(t, wide_to)) return ec;
434
435  error_code ec = error_code::success();
436  for (int i = 0; i < 2000; i++) {
437    if (::MoveFileExW(wide_from.begin(), wide_to.begin(),
438                      MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING))
439      return error_code::success();
440    ec = windows_error(::GetLastError());
441    if (ec != windows_error::access_denied)
442      break;
443    // Retry MoveFile() at ACCESS_DENIED.
444    // System scanners (eg. indexer) might open the source file when
445    // It is written and closed.
446    ::Sleep(1);
447  }
448
449  return ec;
450}
451
452error_code resize_file(const Twine &path, uint64_t size) {
453  SmallString<128> path_storage;
454  SmallVector<wchar_t, 128> path_utf16;
455
456  if (error_code ec = UTF8ToUTF16(path.toStringRef(path_storage),
457                                  path_utf16))
458    return ec;
459
460  int fd = ::_wopen(path_utf16.begin(), O_BINARY | _O_RDWR, S_IWRITE);
461  if (fd == -1)
462    return error_code(errno, generic_category());
463#ifdef HAVE__CHSIZE_S
464  errno_t error = ::_chsize_s(fd, size);
465#else
466  errno_t error = ::_chsize(fd, size);
467#endif
468  ::close(fd);
469  return error_code(error, generic_category());
470}
471
472error_code exists(const Twine &path, bool &result) {
473  SmallString<128> path_storage;
474  SmallVector<wchar_t, 128> path_utf16;
475
476  if (error_code ec = UTF8ToUTF16(path.toStringRef(path_storage),
477                                  path_utf16))
478    return ec;
479
480  DWORD attributes = ::GetFileAttributesW(path_utf16.begin());
481
482  if (attributes == INVALID_FILE_ATTRIBUTES) {
483    // See if the file didn't actually exist.
484    error_code ec = make_error_code(windows_error(::GetLastError()));
485    if (ec != windows_error::file_not_found &&
486        ec != windows_error::path_not_found)
487      return ec;
488    result = false;
489  } else
490    result = true;
491  return error_code::success();
492}
493
494bool can_write(const Twine &Path) {
495  // FIXME: take security attributes into account.
496  SmallString<128> PathStorage;
497  SmallVector<wchar_t, 128> PathUtf16;
498
499  if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
500    return false;
501
502  DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
503  return (Attr != INVALID_FILE_ATTRIBUTES) && !(Attr & FILE_ATTRIBUTE_READONLY);
504}
505
506bool can_execute(const Twine &Path) {
507  SmallString<128> PathStorage;
508  SmallVector<wchar_t, 128> PathUtf16;
509
510  if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
511    return false;
512
513  DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
514  return Attr != INVALID_FILE_ATTRIBUTES;
515}
516
517bool equivalent(file_status A, file_status B) {
518  assert(status_known(A) && status_known(B));
519  return A.FileIndexHigh      == B.FileIndexHigh &&
520         A.FileIndexLow       == B.FileIndexLow &&
521         A.FileSizeHigh       == B.FileSizeHigh &&
522         A.FileSizeLow        == B.FileSizeLow &&
523         A.LastWriteTimeHigh  == B.LastWriteTimeHigh &&
524         A.LastWriteTimeLow   == B.LastWriteTimeLow &&
525         A.VolumeSerialNumber == B.VolumeSerialNumber;
526}
527
528error_code equivalent(const Twine &A, const Twine &B, bool &result) {
529  file_status fsA, fsB;
530  if (error_code ec = status(A, fsA)) return ec;
531  if (error_code ec = status(B, fsB)) return ec;
532  result = equivalent(fsA, fsB);
533  return error_code::success();
534}
535
536error_code getUniqueID(const Twine Path, uint64_t &Result) {
537  file_status Status;
538  if (error_code E = status(Path, Status))
539    return E;
540
541  // The file is uniquely identified by the volume serial number along
542  // with the 64-bit file identifier.
543  Result = (static_cast<uint64_t>(Status.FileIndexHigh) << 32ULL) |
544           static_cast<uint64_t>(Status.FileIndexLow);
545
546  // Because the serial number is 32-bits, but we've already used up all 64
547  // bits for the file index, XOR the serial number into the high 32 bits of
548  // the resulting value.  We could potentially get collisons from this, but
549  // the likelihood is low.
550  Result ^= (static_cast<uint64_t>(Status.VolumeSerialNumber) << 32ULL);
551
552  return error_code::success();
553}
554
555static bool isReservedName(StringRef path) {
556  // This list of reserved names comes from MSDN, at:
557  // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx
558  static const char *sReservedNames[] = { "nul", "con", "prn", "aux",
559                              "com1", "com2", "com3", "com4", "com5", "com6",
560                              "com7", "com8", "com9", "lpt1", "lpt2", "lpt3",
561                              "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9" };
562
563  // First, check to see if this is a device namespace, which always
564  // starts with \\.\, since device namespaces are not legal file paths.
565  if (path.startswith("\\\\.\\"))
566    return true;
567
568  // Then compare against the list of ancient reserved names
569  for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) {
570    if (path.equals_lower(sReservedNames[i]))
571      return true;
572  }
573
574  // The path isn't what we consider reserved.
575  return false;
576}
577
578static error_code getStatus(HANDLE FileHandle, file_status &Result) {
579  if (FileHandle == INVALID_HANDLE_VALUE)
580    goto handle_status_error;
581
582  switch (::GetFileType(FileHandle)) {
583  default:
584  case FILE_TYPE_UNKNOWN:
585  case FILE_TYPE_DISK:
586    break;
587  case FILE_TYPE_CHAR:
588    Result = file_status(file_type::character_file);
589    return error_code::success();
590  case FILE_TYPE_PIPE:
591    Result = file_status(file_type::fifo_file);
592    return error_code::success();
593  }
594
595  BY_HANDLE_FILE_INFORMATION Info;
596  if (!::GetFileInformationByHandle(FileHandle, &Info))
597    goto handle_status_error;
598
599  Result = file_status(
600        file_type::regular_file, Info.ftLastWriteTime.dwHighDateTime,
601        Info.ftLastWriteTime.dwLowDateTime, Info.dwVolumeSerialNumber,
602        Info.nFileSizeHigh, Info.nFileSizeLow, Info.nFileIndexHigh,
603        Info.nFileIndexLow);
604  return error_code::success();
605
606handle_status_error:
607  error_code EC = windows_error(::GetLastError());
608  if (EC == windows_error::file_not_found ||
609      EC == windows_error::path_not_found)
610    Result = file_status(file_type::file_not_found);
611  else if (EC == windows_error::sharing_violation)
612    Result = file_status(file_type::type_unknown);
613  else {
614    Result = file_status(file_type::status_error);
615    return EC;
616  }
617  return error_code::success();
618}
619
620error_code status(const Twine &path, file_status &result) {
621  SmallString<128> path_storage;
622  SmallVector<wchar_t, 128> path_utf16;
623
624  StringRef path8 = path.toStringRef(path_storage);
625  if (isReservedName(path8)) {
626    result = file_status(file_type::character_file);
627    return error_code::success();
628  }
629
630  if (error_code ec = UTF8ToUTF16(path8, path_utf16))
631    return ec;
632
633  DWORD attr = ::GetFileAttributesW(path_utf16.begin());
634  if (attr == INVALID_FILE_ATTRIBUTES)
635    return getStatus(INVALID_HANDLE_VALUE, result);
636
637  // Handle reparse points.
638  if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
639    ScopedFileHandle h(
640      ::CreateFileW(path_utf16.begin(),
641                    0, // Attributes only.
642                    FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
643                    NULL,
644                    OPEN_EXISTING,
645                    FILE_FLAG_BACKUP_SEMANTICS,
646                    0));
647    if (!h)
648      return getStatus(INVALID_HANDLE_VALUE, result);
649  }
650
651  if (attr & FILE_ATTRIBUTE_DIRECTORY)
652    result = file_status(file_type::directory_file);
653  else {
654    ScopedFileHandle h(
655      ::CreateFileW(path_utf16.begin(),
656                    0, // Attributes only.
657                    FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
658                    NULL,
659                    OPEN_EXISTING,
660                    FILE_FLAG_BACKUP_SEMANTICS,
661                    0));
662    if (!h)
663      return getStatus(INVALID_HANDLE_VALUE, result);
664    BY_HANDLE_FILE_INFORMATION Info;
665    if (!::GetFileInformationByHandle(h, &Info))
666      return getStatus(INVALID_HANDLE_VALUE, result);
667
668    return getStatus(h, result);
669  }
670  return error_code::success();
671}
672
673error_code status(int FD, file_status &Result) {
674  HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
675  return getStatus(FileHandle, Result);
676}
677
678error_code setLastModificationAndAccessTime(int FD, TimeValue Time) {
679  ULARGE_INTEGER UI;
680  UI.QuadPart = Time.toWin32Time();
681  FILETIME FT;
682  FT.dwLowDateTime = UI.LowPart;
683  FT.dwHighDateTime = UI.HighPart;
684  HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
685  if (!SetFileTime(FileHandle, NULL, &FT, &FT))
686    return windows_error(::GetLastError());
687  return error_code::success();
688}
689
690error_code get_magic(const Twine &path, uint32_t len,
691                     SmallVectorImpl<char> &result) {
692  SmallString<128> path_storage;
693  SmallVector<wchar_t, 128> path_utf16;
694  result.set_size(0);
695
696  // Convert path to UTF-16.
697  if (error_code ec = UTF8ToUTF16(path.toStringRef(path_storage),
698                                  path_utf16))
699    return ec;
700
701  // Open file.
702  HANDLE file = ::CreateFileW(c_str(path_utf16),
703                              GENERIC_READ,
704                              FILE_SHARE_READ,
705                              NULL,
706                              OPEN_EXISTING,
707                              FILE_ATTRIBUTE_READONLY,
708                              NULL);
709  if (file == INVALID_HANDLE_VALUE)
710    return windows_error(::GetLastError());
711
712  // Allocate buffer.
713  result.reserve(len);
714
715  // Get magic!
716  DWORD bytes_read = 0;
717  BOOL read_success = ::ReadFile(file, result.data(), len, &bytes_read, NULL);
718  error_code ec = windows_error(::GetLastError());
719  ::CloseHandle(file);
720  if (!read_success || (bytes_read != len)) {
721    // Set result size to the number of bytes read if it's valid.
722    if (bytes_read <= len)
723      result.set_size(bytes_read);
724    // ERROR_HANDLE_EOF is mapped to errc::value_too_large.
725    return ec;
726  }
727
728  result.set_size(len);
729  return error_code::success();
730}
731
732error_code mapped_file_region::init(int FD, bool CloseFD, uint64_t Offset) {
733  FileDescriptor = FD;
734  // Make sure that the requested size fits within SIZE_T.
735  if (Size > std::numeric_limits<SIZE_T>::max()) {
736    if (FileDescriptor) {
737      if (CloseFD)
738        _close(FileDescriptor);
739    } else
740      ::CloseHandle(FileHandle);
741    return make_error_code(errc::invalid_argument);
742  }
743
744  DWORD flprotect;
745  switch (Mode) {
746  case readonly:  flprotect = PAGE_READONLY; break;
747  case readwrite: flprotect = PAGE_READWRITE; break;
748  case priv:      flprotect = PAGE_WRITECOPY; break;
749  }
750
751  FileMappingHandle = ::CreateFileMapping(FileHandle,
752                                          0,
753                                          flprotect,
754                                          Size >> 32,
755                                          Size & 0xffffffff,
756                                          0);
757  if (FileMappingHandle == NULL) {
758    error_code ec = windows_error(GetLastError());
759    if (FileDescriptor) {
760      if (CloseFD)
761        _close(FileDescriptor);
762    } else
763      ::CloseHandle(FileHandle);
764    return ec;
765  }
766
767  DWORD dwDesiredAccess;
768  switch (Mode) {
769  case readonly:  dwDesiredAccess = FILE_MAP_READ; break;
770  case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break;
771  case priv:      dwDesiredAccess = FILE_MAP_COPY; break;
772  }
773  Mapping = ::MapViewOfFile(FileMappingHandle,
774                            dwDesiredAccess,
775                            Offset >> 32,
776                            Offset & 0xffffffff,
777                            Size);
778  if (Mapping == NULL) {
779    error_code ec = windows_error(GetLastError());
780    ::CloseHandle(FileMappingHandle);
781    if (FileDescriptor) {
782      if (CloseFD)
783        _close(FileDescriptor);
784    } else
785      ::CloseHandle(FileHandle);
786    return ec;
787  }
788
789  if (Size == 0) {
790    MEMORY_BASIC_INFORMATION mbi;
791    SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi));
792    if (Result == 0) {
793      error_code ec = windows_error(GetLastError());
794      ::UnmapViewOfFile(Mapping);
795      ::CloseHandle(FileMappingHandle);
796      if (FileDescriptor) {
797        if (CloseFD)
798          _close(FileDescriptor);
799      } else
800        ::CloseHandle(FileHandle);
801      return ec;
802    }
803    Size = mbi.RegionSize;
804  }
805
806  // Close all the handles except for the view. It will keep the other handles
807  // alive.
808  ::CloseHandle(FileMappingHandle);
809  if (FileDescriptor) {
810    if (CloseFD)
811      _close(FileDescriptor); // Also closes FileHandle.
812  } else
813    ::CloseHandle(FileHandle);
814  return error_code::success();
815}
816
817mapped_file_region::mapped_file_region(const Twine &path,
818                                       mapmode mode,
819                                       uint64_t length,
820                                       uint64_t offset,
821                                       error_code &ec)
822  : Mode(mode)
823  , Size(length)
824  , Mapping()
825  , FileDescriptor()
826  , FileHandle(INVALID_HANDLE_VALUE)
827  , FileMappingHandle() {
828  SmallString<128> path_storage;
829  SmallVector<wchar_t, 128> path_utf16;
830
831  // Convert path to UTF-16.
832  if ((ec = UTF8ToUTF16(path.toStringRef(path_storage), path_utf16)))
833    return;
834
835  // Get file handle for creating a file mapping.
836  FileHandle = ::CreateFileW(c_str(path_utf16),
837                             Mode == readonly ? GENERIC_READ
838                                              : GENERIC_READ | GENERIC_WRITE,
839                             Mode == readonly ? FILE_SHARE_READ
840                                              : 0,
841                             0,
842                             Mode == readonly ? OPEN_EXISTING
843                                              : OPEN_ALWAYS,
844                             Mode == readonly ? FILE_ATTRIBUTE_READONLY
845                                              : FILE_ATTRIBUTE_NORMAL,
846                             0);
847  if (FileHandle == INVALID_HANDLE_VALUE) {
848    ec = windows_error(::GetLastError());
849    return;
850  }
851
852  FileDescriptor = 0;
853  ec = init(FileDescriptor, true, offset);
854  if (ec) {
855    Mapping = FileMappingHandle = 0;
856    FileHandle = INVALID_HANDLE_VALUE;
857    FileDescriptor = 0;
858  }
859}
860
861mapped_file_region::mapped_file_region(int fd,
862                                       bool closefd,
863                                       mapmode mode,
864                                       uint64_t length,
865                                       uint64_t offset,
866                                       error_code &ec)
867  : Mode(mode)
868  , Size(length)
869  , Mapping()
870  , FileDescriptor(fd)
871  , FileHandle(INVALID_HANDLE_VALUE)
872  , FileMappingHandle() {
873  FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
874  if (FileHandle == INVALID_HANDLE_VALUE) {
875    if (closefd)
876      _close(FileDescriptor);
877    FileDescriptor = 0;
878    ec = make_error_code(errc::bad_file_descriptor);
879    return;
880  }
881
882  ec = init(FileDescriptor, closefd, offset);
883  if (ec) {
884    Mapping = FileMappingHandle = 0;
885    FileHandle = INVALID_HANDLE_VALUE;
886    FileDescriptor = 0;
887  }
888}
889
890mapped_file_region::~mapped_file_region() {
891  if (Mapping)
892    ::UnmapViewOfFile(Mapping);
893}
894
895#if LLVM_HAS_RVALUE_REFERENCES
896mapped_file_region::mapped_file_region(mapped_file_region &&other)
897  : Mode(other.Mode)
898  , Size(other.Size)
899  , Mapping(other.Mapping)
900  , FileDescriptor(other.FileDescriptor)
901  , FileHandle(other.FileHandle)
902  , FileMappingHandle(other.FileMappingHandle) {
903  other.Mapping = other.FileMappingHandle = 0;
904  other.FileHandle = INVALID_HANDLE_VALUE;
905  other.FileDescriptor = 0;
906}
907#endif
908
909mapped_file_region::mapmode mapped_file_region::flags() const {
910  assert(Mapping && "Mapping failed but used anyway!");
911  return Mode;
912}
913
914uint64_t mapped_file_region::size() const {
915  assert(Mapping && "Mapping failed but used anyway!");
916  return Size;
917}
918
919char *mapped_file_region::data() const {
920  assert(Mode != readonly && "Cannot get non const data for readonly mapping!");
921  assert(Mapping && "Mapping failed but used anyway!");
922  return reinterpret_cast<char*>(Mapping);
923}
924
925const char *mapped_file_region::const_data() const {
926  assert(Mapping && "Mapping failed but used anyway!");
927  return reinterpret_cast<const char*>(Mapping);
928}
929
930int mapped_file_region::alignment() {
931  SYSTEM_INFO SysInfo;
932  ::GetSystemInfo(&SysInfo);
933  return SysInfo.dwAllocationGranularity;
934}
935
936error_code detail::directory_iterator_construct(detail::DirIterState &it,
937                                                StringRef path){
938  SmallVector<wchar_t, 128> path_utf16;
939
940  if (error_code ec = UTF8ToUTF16(path,
941                                  path_utf16))
942    return ec;
943
944  // Convert path to the format that Windows is happy with.
945  if (path_utf16.size() > 0 &&
946      !is_separator(path_utf16[path.size() - 1]) &&
947      path_utf16[path.size() - 1] != L':') {
948    path_utf16.push_back(L'\\');
949    path_utf16.push_back(L'*');
950  } else {
951    path_utf16.push_back(L'*');
952  }
953
954  //  Get the first directory entry.
955  WIN32_FIND_DATAW FirstFind;
956  ScopedFindHandle FindHandle(::FindFirstFileW(c_str(path_utf16), &FirstFind));
957  if (!FindHandle)
958    return windows_error(::GetLastError());
959
960  size_t FilenameLen = ::wcslen(FirstFind.cFileName);
961  while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') ||
962         (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' &&
963                              FirstFind.cFileName[1] == L'.'))
964    if (!::FindNextFileW(FindHandle, &FirstFind)) {
965      error_code ec = windows_error(::GetLastError());
966      // Check for end.
967      if (ec == windows_error::no_more_files)
968        return detail::directory_iterator_destruct(it);
969      return ec;
970    } else
971      FilenameLen = ::wcslen(FirstFind.cFileName);
972
973  // Construct the current directory entry.
974  SmallString<128> directory_entry_name_utf8;
975  if (error_code ec = UTF16ToUTF8(FirstFind.cFileName,
976                                  ::wcslen(FirstFind.cFileName),
977                                  directory_entry_name_utf8))
978    return ec;
979
980  it.IterationHandle = intptr_t(FindHandle.take());
981  SmallString<128> directory_entry_path(path);
982  path::append(directory_entry_path, directory_entry_name_utf8.str());
983  it.CurrentEntry = directory_entry(directory_entry_path.str());
984
985  return error_code::success();
986}
987
988error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
989  if (it.IterationHandle != 0)
990    // Closes the handle if it's valid.
991    ScopedFindHandle close(HANDLE(it.IterationHandle));
992  it.IterationHandle = 0;
993  it.CurrentEntry = directory_entry();
994  return error_code::success();
995}
996
997error_code detail::directory_iterator_increment(detail::DirIterState &it) {
998  WIN32_FIND_DATAW FindData;
999  if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) {
1000    error_code ec = windows_error(::GetLastError());
1001    // Check for end.
1002    if (ec == windows_error::no_more_files)
1003      return detail::directory_iterator_destruct(it);
1004    return ec;
1005  }
1006
1007  size_t FilenameLen = ::wcslen(FindData.cFileName);
1008  if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') ||
1009      (FilenameLen == 2 && FindData.cFileName[0] == L'.' &&
1010                           FindData.cFileName[1] == L'.'))
1011    return directory_iterator_increment(it);
1012
1013  SmallString<128> directory_entry_path_utf8;
1014  if (error_code ec = UTF16ToUTF8(FindData.cFileName,
1015                                  ::wcslen(FindData.cFileName),
1016                                  directory_entry_path_utf8))
1017    return ec;
1018
1019  it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8));
1020  return error_code::success();
1021}
1022
1023error_code map_file_pages(const Twine &path, off_t file_offset, size_t size,
1024                                            bool map_writable, void *&result) {
1025  assert(0 && "NOT IMPLEMENTED");
1026  return windows_error::invalid_function;
1027}
1028
1029error_code unmap_file_pages(void *base, size_t size) {
1030  assert(0 && "NOT IMPLEMENTED");
1031  return windows_error::invalid_function;
1032}
1033
1034error_code openFileForRead(const Twine &Name, int &ResultFD) {
1035  SmallString<128> PathStorage;
1036  SmallVector<wchar_t, 128> PathUTF16;
1037
1038  if (error_code EC = UTF8ToUTF16(Name.toStringRef(PathStorage),
1039                                  PathUTF16))
1040    return EC;
1041
1042  HANDLE H = ::CreateFileW(PathUTF16.begin(), GENERIC_READ,
1043                           FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1044                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1045  if (H == INVALID_HANDLE_VALUE) {
1046    error_code EC = windows_error(::GetLastError());
1047    // Provide a better error message when trying to open directories.
1048    // This only runs if we failed to open the file, so there is probably
1049    // no performances issues.
1050    if (EC != windows_error::access_denied)
1051      return EC;
1052    if (is_directory(Name))
1053      return error_code(errc::is_a_directory, posix_category());
1054    return EC;
1055  }
1056
1057  int FD = ::_open_osfhandle(intptr_t(H), 0);
1058  if (FD == -1) {
1059    ::CloseHandle(H);
1060    return windows_error::invalid_handle;
1061  }
1062
1063  ResultFD = FD;
1064  return error_code::success();
1065}
1066
1067} // end namespace fs
1068} // end namespace sys
1069} // end namespace llvm
1070