libcxx/src/filesystem/posix_compat.h

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