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