1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 //
10 // POSIX-like portability helper functions.
11 //
12 // These generally behave like the proper posix functions, with these
13 // exceptions:
14 // On Windows, they take paths in wchar_t* form, instead of char* form.
15 // The symlink() function is split into two frontends, symlink_file()
16 // and symlink_dir().
17 //
18 // These are provided within an anonymous namespace within the detail
19 // namespace - callers need to include this header and call them as
20 // detail::function(), regardless of platform.
21 //
22 
23 #ifndef POSIX_COMPAT_H
24 #define POSIX_COMPAT_H
25 
26 #include <__assert>
27 #include <filesystem>
28 
29 #include "filesystem_common.h"
30 
31 #if defined(_LIBCPP_WIN32API)
32 # define WIN32_LEAN_AND_MEAN
33 # define NOMINMAX
34 # include <windows.h>
35 # include <io.h>
36 # include <winioctl.h>
37 #else
38 # include <unistd.h>
39 # include <sys/stat.h>
40 # include <sys/statvfs.h>
41 #endif
42 #include <time.h>
43 
44 #if defined(_LIBCPP_WIN32API)
45 // This struct isn't defined in the normal Windows SDK, but only in the
46 // Windows Driver Kit.
47 struct LIBCPP_REPARSE_DATA_BUFFER {
48   unsigned long  ReparseTag;
49   unsigned short ReparseDataLength;
50   unsigned short Reserved;
51   union {
52     struct {
53       unsigned short SubstituteNameOffset;
54       unsigned short SubstituteNameLength;
55       unsigned short PrintNameOffset;
56       unsigned short PrintNameLength;
57       unsigned long  Flags;
58       wchar_t        PathBuffer[1];
59     } SymbolicLinkReparseBuffer;
60     struct {
61       unsigned short SubstituteNameOffset;
62       unsigned short SubstituteNameLength;
63       unsigned short PrintNameOffset;
64       unsigned short PrintNameLength;
65       wchar_t        PathBuffer[1];
66     } MountPointReparseBuffer;
67     struct {
68       unsigned char DataBuffer[1];
69     } GenericReparseBuffer;
70   };
71 };
72 #endif
73 
74 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
75 
76 namespace detail {
77 namespace {
78 
79 #if defined(_LIBCPP_WIN32API)
80 
81 // Various C runtime header sets provide more or less of these. As we
82 // provide our own implementation, undef all potential defines from the
83 // C runtime headers and provide a complete set of macros of our own.
84 
85 #undef _S_IFMT
86 #undef _S_IFDIR
87 #undef _S_IFCHR
88 #undef _S_IFIFO
89 #undef _S_IFREG
90 #undef _S_IFBLK
91 #undef _S_IFLNK
92 #undef _S_IFSOCK
93 
94 #define _S_IFMT   0xF000
95 #define _S_IFDIR  0x4000
96 #define _S_IFCHR  0x2000
97 #define _S_IFIFO  0x1000
98 #define _S_IFREG  0x8000
99 #define _S_IFBLK  0x6000
100 #define _S_IFLNK  0xA000
101 #define _S_IFSOCK 0xC000
102 
103 #undef S_ISDIR
104 #undef S_ISFIFO
105 #undef S_ISCHR
106 #undef S_ISREG
107 #undef S_ISLNK
108 #undef S_ISBLK
109 #undef S_ISSOCK
110 
111 #define S_ISDIR(m)      (((m) & _S_IFMT) == _S_IFDIR)
112 #define S_ISCHR(m)      (((m) & _S_IFMT) == _S_IFCHR)
113 #define S_ISFIFO(m)     (((m) & _S_IFMT) == _S_IFIFO)
114 #define S_ISREG(m)      (((m) & _S_IFMT) == _S_IFREG)
115 #define S_ISBLK(m)      (((m) & _S_IFMT) == _S_IFBLK)
116 #define S_ISLNK(m)      (((m) & _S_IFMT) == _S_IFLNK)
117 #define S_ISSOCK(m)     (((m) & _S_IFMT) == _S_IFSOCK)
118 
119 #define O_NONBLOCK 0
120 
121 
122 // There were 369 years and 89 leap days from the Windows epoch
123 // (1601) to the Unix epoch (1970).
124 #define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
125 
filetime_to_timespec(LARGE_INTEGER li)126 TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
127   TimeSpec ret;
128   ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
129   ret.tv_nsec = (li.QuadPart % 10000000) * 100;
130   return ret;
131 }
132 
filetime_to_timespec(FILETIME ft)133 TimeSpec filetime_to_timespec(FILETIME ft) {
134   LARGE_INTEGER li;
135   li.LowPart = ft.dwLowDateTime;
136   li.HighPart = ft.dwHighDateTime;
137   return filetime_to_timespec(li);
138 }
139 
timespec_to_filetime(TimeSpec ts)140 FILETIME timespec_to_filetime(TimeSpec ts) {
141   LARGE_INTEGER li;
142   li.QuadPart =
143       ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
144   FILETIME ft;
145   ft.dwLowDateTime = li.LowPart;
146   ft.dwHighDateTime = li.HighPart;
147   return ft;
148 }
149 
150 int set_errno(int e = GetLastError()) {
151   errno = static_cast<int>(__win_err_to_errc(e));
152   return -1;
153 }
154 
155 class WinHandle {
156 public:
WinHandle(const wchar_t * p,DWORD access,DWORD flags)157   WinHandle(const wchar_t *p, DWORD access, DWORD flags) {
158     h = CreateFileW(
159         p, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
160         nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | flags, nullptr);
161   }
~WinHandle()162   ~WinHandle() {
163     if (h != INVALID_HANDLE_VALUE)
164       CloseHandle(h);
165   }
HANDLE()166   operator HANDLE() const { return h; }
167   operator bool() const { return h != INVALID_HANDLE_VALUE; }
168 
169 private:
170   HANDLE h;
171 };
172 
stat_handle(HANDLE h,StatT * buf)173 int stat_handle(HANDLE h, StatT *buf) {
174   FILE_BASIC_INFO basic;
175   if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
176     return set_errno();
177   memset(buf, 0, sizeof(*buf));
178   buf->st_mtim = filetime_to_timespec(basic.LastWriteTime);
179   buf->st_atim = filetime_to_timespec(basic.LastAccessTime);
180   buf->st_mode = 0555; // Read-only
181   if (!(basic.FileAttributes & FILE_ATTRIBUTE_READONLY))
182     buf->st_mode |= 0222; // Write
183   if (basic.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
184     buf->st_mode |= _S_IFDIR;
185   } else {
186     buf->st_mode |= _S_IFREG;
187   }
188   if (basic.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
189     FILE_ATTRIBUTE_TAG_INFO tag;
190     if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tag,
191                                       sizeof(tag)))
192       return set_errno();
193     if (tag.ReparseTag == IO_REPARSE_TAG_SYMLINK)
194       buf->st_mode = (buf->st_mode & ~_S_IFMT) | _S_IFLNK;
195   }
196   FILE_STANDARD_INFO standard;
197   if (!GetFileInformationByHandleEx(h, FileStandardInfo, &standard,
198                                     sizeof(standard)))
199     return set_errno();
200   buf->st_nlink = standard.NumberOfLinks;
201   buf->st_size = standard.EndOfFile.QuadPart;
202   BY_HANDLE_FILE_INFORMATION info;
203   if (!GetFileInformationByHandle(h, &info))
204     return set_errno();
205   buf->st_dev = info.dwVolumeSerialNumber;
206   memcpy(&buf->st_ino.id[0], &info.nFileIndexHigh, 4);
207   memcpy(&buf->st_ino.id[4], &info.nFileIndexLow, 4);
208   return 0;
209 }
210 
stat_file(const wchar_t * path,StatT * buf,DWORD flags)211 int stat_file(const wchar_t *path, StatT *buf, DWORD flags) {
212   WinHandle h(path, FILE_READ_ATTRIBUTES, flags);
213   if (!h)
214     return set_errno();
215   int ret = stat_handle(h, buf);
216   return ret;
217 }
218 
stat(const wchar_t * path,StatT * buf)219 int stat(const wchar_t *path, StatT *buf) { return stat_file(path, buf, 0); }
220 
lstat(const wchar_t * path,StatT * buf)221 int lstat(const wchar_t *path, StatT *buf) {
222   return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT);
223 }
224 
fstat(int fd,StatT * buf)225 int fstat(int fd, StatT *buf) {
226   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
227   return stat_handle(h, buf);
228 }
229 
mkdir(const wchar_t * path,int permissions)230 int mkdir(const wchar_t *path, int permissions) {
231   (void)permissions;
232   return _wmkdir(path);
233 }
234 
symlink_file_dir(const wchar_t * oldname,const wchar_t * newname,bool is_dir)235 int symlink_file_dir(const wchar_t *oldname, const wchar_t *newname,
236                      bool is_dir) {
237   path dest(oldname);
238   dest.make_preferred();
239   oldname = dest.c_str();
240   DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
241   if (CreateSymbolicLinkW(newname, oldname,
242                           flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
243     return 0;
244   int e = GetLastError();
245   if (e != ERROR_INVALID_PARAMETER)
246     return set_errno(e);
247   if (CreateSymbolicLinkW(newname, oldname, flags))
248     return 0;
249   return set_errno();
250 }
251 
symlink_file(const wchar_t * oldname,const wchar_t * newname)252 int symlink_file(const wchar_t *oldname, const wchar_t *newname) {
253   return symlink_file_dir(oldname, newname, false);
254 }
255 
symlink_dir(const wchar_t * oldname,const wchar_t * newname)256 int symlink_dir(const wchar_t *oldname, const wchar_t *newname) {
257   return symlink_file_dir(oldname, newname, true);
258 }
259 
link(const wchar_t * oldname,const wchar_t * newname)260 int link(const wchar_t *oldname, const wchar_t *newname) {
261   if (CreateHardLinkW(newname, oldname, nullptr))
262     return 0;
263   return set_errno();
264 }
265 
remove(const wchar_t * path)266 int remove(const wchar_t *path) {
267   detail::WinHandle h(path, DELETE, FILE_FLAG_OPEN_REPARSE_POINT);
268   if (!h)
269     return set_errno();
270   FILE_DISPOSITION_INFO info;
271   info.DeleteFile = TRUE;
272   if (!SetFileInformationByHandle(h, FileDispositionInfo, &info, sizeof(info)))
273     return set_errno();
274   return 0;
275 }
276 
truncate_handle(HANDLE h,off_t length)277 int truncate_handle(HANDLE h, off_t length) {
278   LARGE_INTEGER size_param;
279   size_param.QuadPart = length;
280   if (!SetFilePointerEx(h, size_param, 0, FILE_BEGIN))
281     return set_errno();
282   if (!SetEndOfFile(h))
283     return set_errno();
284   return 0;
285 }
286 
ftruncate(int fd,off_t length)287 int ftruncate(int fd, off_t length) {
288   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
289   return truncate_handle(h, length);
290 }
291 
truncate(const wchar_t * path,off_t length)292 int truncate(const wchar_t *path, off_t length) {
293   detail::WinHandle h(path, GENERIC_WRITE, 0);
294   if (!h)
295     return set_errno();
296   return truncate_handle(h, length);
297 }
298 
rename(const wchar_t * from,const wchar_t * to)299 int rename(const wchar_t *from, const wchar_t *to) {
300   if (!(MoveFileExW(from, to,
301                     MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING |
302                         MOVEFILE_WRITE_THROUGH)))
303     return set_errno();
304   return 0;
305 }
306 
open(const wchar_t * filename,Args...args)307 template <class... Args> int open(const wchar_t *filename, Args... args) {
308   return _wopen(filename, args...);
309 }
close(int fd)310 int close(int fd) { return _close(fd); }
chdir(const wchar_t * path)311 int chdir(const wchar_t *path) { return _wchdir(path); }
312 
313 struct StatVFS {
314   uint64_t f_frsize;
315   uint64_t f_blocks;
316   uint64_t f_bfree;
317   uint64_t f_bavail;
318 };
319 
statvfs(const wchar_t * p,StatVFS * buf)320 int statvfs(const wchar_t *p, StatVFS *buf) {
321   path dir = p;
322   while (true) {
323     error_code local_ec;
324     const file_status st = status(dir, local_ec);
325     if (!exists(st) || is_directory(st))
326       break;
327     path parent = dir.parent_path();
328     if (parent == dir) {
329       errno = ENOENT;
330       return -1;
331     }
332     dir = parent;
333   }
334   ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes,
335       total_number_of_free_bytes;
336   if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller,
337                            &total_number_of_bytes, &total_number_of_free_bytes))
338     return set_errno();
339   buf->f_frsize = 1;
340   buf->f_blocks = total_number_of_bytes.QuadPart;
341   buf->f_bfree = total_number_of_free_bytes.QuadPart;
342   buf->f_bavail = free_bytes_available_to_caller.QuadPart;
343   return 0;
344 }
345 
getcwd(wchar_t * buff,size_t size)346 wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); }
347 
realpath(const wchar_t * path,wchar_t * resolved_name)348 wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) {
349   // Only expected to be used with us allocating the buffer.
350   _LIBCPP_ASSERT(resolved_name == nullptr,
351                  "Windows realpath() assumes a null resolved_name");
352 
353   WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
354   if (!h) {
355     set_errno();
356     return nullptr;
357   }
358   size_t buff_size = MAX_PATH + 10;
359   std::unique_ptr<wchar_t, decltype(&::free)> buff(
360       static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free);
361   DWORD retval = GetFinalPathNameByHandleW(
362       h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
363   if (retval > buff_size) {
364     buff_size = retval;
365     buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))));
366     retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size,
367                                        FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
368   }
369   if (!retval) {
370     set_errno();
371     return nullptr;
372   }
373   wchar_t *ptr = buff.get();
374   if (!wcsncmp(ptr, L"\\\\?\\", 4)) {
375     if (ptr[5] == ':') { // \\?\X: -> X:
376       memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t));
377     } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server
378       wcscpy(&ptr[0], L"\\\\");
379       memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t));
380     }
381   }
382   return buff.release();
383 }
384 
385 #define AT_FDCWD -1
386 #define AT_SYMLINK_NOFOLLOW 1
387 using ModeT = int;
388 
fchmod_handle(HANDLE h,int perms)389 int fchmod_handle(HANDLE h, int perms) {
390   FILE_BASIC_INFO basic;
391   if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
392     return set_errno();
393   DWORD orig_attributes = basic.FileAttributes;
394   basic.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
395   if ((perms & 0222) == 0)
396     basic.FileAttributes |= FILE_ATTRIBUTE_READONLY;
397   if (basic.FileAttributes != orig_attributes &&
398       !SetFileInformationByHandle(h, FileBasicInfo, &basic, sizeof(basic)))
399     return set_errno();
400   return 0;
401 }
402 
fchmodat(int fd,const wchar_t * path,int perms,int flag)403 int fchmodat(int fd, const wchar_t *path, int perms, int flag) {
404   DWORD attributes = GetFileAttributesW(path);
405   if (attributes == INVALID_FILE_ATTRIBUTES)
406     return set_errno();
407   if (attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
408       !(flag & AT_SYMLINK_NOFOLLOW)) {
409     // If the file is a symlink, and we are supposed to operate on the target
410     // of the symlink, we need to open a handle to it, without the
411     // FILE_FLAG_OPEN_REPARSE_POINT flag, to open the destination of the
412     // symlink, and operate on it via the handle.
413     detail::WinHandle h(path, FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, 0);
414     if (!h)
415       return set_errno();
416     return fchmod_handle(h, perms);
417   } else {
418     // For a non-symlink, or if operating on the symlink itself instead of
419     // its target, we can use SetFileAttributesW, saving a few calls.
420     DWORD orig_attributes = attributes;
421     attributes &= ~FILE_ATTRIBUTE_READONLY;
422     if ((perms & 0222) == 0)
423       attributes |= FILE_ATTRIBUTE_READONLY;
424     if (attributes != orig_attributes && !SetFileAttributesW(path, attributes))
425       return set_errno();
426   }
427   return 0;
428 }
429 
fchmod(int fd,int perms)430 int fchmod(int fd, int perms) {
431   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
432   return fchmod_handle(h, perms);
433 }
434 
435 #define MAX_SYMLINK_SIZE MAXIMUM_REPARSE_DATA_BUFFER_SIZE
436 using SSizeT = ::int64_t;
437 
readlink(const wchar_t * path,wchar_t * ret_buf,size_t bufsize)438 SSizeT readlink(const wchar_t *path, wchar_t *ret_buf, size_t bufsize) {
439   uint8_t buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
440   detail::WinHandle h(path, FILE_READ_ATTRIBUTES, FILE_FLAG_OPEN_REPARSE_POINT);
441   if (!h)
442     return set_errno();
443   DWORD out;
444   if (!DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buf, sizeof(buf),
445                        &out, 0))
446     return set_errno();
447   const auto *reparse = reinterpret_cast<LIBCPP_REPARSE_DATA_BUFFER *>(buf);
448   size_t path_buf_offset = offsetof(LIBCPP_REPARSE_DATA_BUFFER,
449                                     SymbolicLinkReparseBuffer.PathBuffer[0]);
450   if (out < path_buf_offset) {
451     errno = EINVAL;
452     return -1;
453   }
454   if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
455     errno = EINVAL;
456     return -1;
457   }
458   const auto &symlink = reparse->SymbolicLinkReparseBuffer;
459   unsigned short name_offset, name_length;
460   if (symlink.PrintNameLength == 0) {
461     name_offset = symlink.SubstituteNameOffset;
462     name_length = symlink.SubstituteNameLength;
463   } else {
464     name_offset = symlink.PrintNameOffset;
465     name_length = symlink.PrintNameLength;
466   }
467   // name_offset/length are expressed in bytes, not in wchar_t
468   if (path_buf_offset + name_offset + name_length > out) {
469     errno = EINVAL;
470     return -1;
471   }
472   if (name_length / sizeof(wchar_t) > bufsize) {
473     errno = ENOMEM;
474     return -1;
475   }
476   memcpy(ret_buf, &symlink.PathBuffer[name_offset / sizeof(wchar_t)],
477          name_length);
478   return name_length / sizeof(wchar_t);
479 }
480 
481 #else
482 int symlink_file(const char *oldname, const char *newname) {
483   return ::symlink(oldname, newname);
484 }
485 int symlink_dir(const char *oldname, const char *newname) {
486   return ::symlink(oldname, newname);
487 }
488 using ::chdir;
489 using ::close;
490 using ::fchmod;
491 #if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
492 using ::fchmodat;
493 #endif
494 using ::fstat;
495 using ::ftruncate;
496 using ::getcwd;
497 using ::link;
498 using ::lstat;
499 using ::mkdir;
500 using ::open;
501 using ::readlink;
502 using ::realpath;
503 using ::remove;
504 using ::rename;
505 using ::stat;
506 using ::statvfs;
507 using ::truncate;
508 
509 #define O_BINARY 0
510 
511 using StatVFS = struct statvfs;
512 using ModeT = ::mode_t;
513 using SSizeT = ::ssize_t;
514 
515 #endif
516 
517 } // namespace
518 } // end namespace detail
519 
520 _LIBCPP_END_NAMESPACE_FILESYSTEM
521 
522 #endif // POSIX_COMPAT_H
523