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