1//===- llvm/Support/Unix/Path.inc - Unix Path Implementation ----*- 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 Unix specific implementation of the Path API. 11// 12//===----------------------------------------------------------------------===// 13 14//===----------------------------------------------------------------------===// 15//=== WARNING: Implementation here must contain only generic UNIX code that 16//=== is guaranteed to work on *all* UNIX variants. 17//===----------------------------------------------------------------------===// 18 19#include "Unix.h" 20#include <limits.h> 21#include <stdio.h> 22#if HAVE_SYS_STAT_H 23#include <sys/stat.h> 24#endif 25#if HAVE_FCNTL_H 26#include <fcntl.h> 27#endif 28#ifdef HAVE_UNISTD_H 29#include <unistd.h> 30#endif 31#ifdef HAVE_SYS_MMAN_H 32#include <sys/mman.h> 33#endif 34 35#include <dirent.h> 36#include <pwd.h> 37 38#ifdef __APPLE__ 39#include <mach-o/dyld.h> 40#include <sys/attr.h> 41#endif 42 43// Both stdio.h and cstdio are included via different paths and 44// stdcxx's cstdio doesn't include stdio.h, so it doesn't #undef the macros 45// either. 46#undef ferror 47#undef feof 48 49// For GNU Hurd 50#if defined(__GNU__) && !defined(PATH_MAX) 51# define PATH_MAX 4096 52#endif 53 54#include <sys/types.h> 55#if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__FreeBSD__) && \ 56 !defined(__linux__) 57#include <sys/statvfs.h> 58#define STATVFS statvfs 59#define FSTATVFS fstatvfs 60#define STATVFS_F_FRSIZE(vfs) vfs.f_frsize 61#else 62#if defined(__OpenBSD__) || defined(__FreeBSD__) 63#include <sys/mount.h> 64#include <sys/param.h> 65#elif defined(__linux__) 66#if defined(HAVE_LINUX_MAGIC_H) 67#include <linux/magic.h> 68#else 69#if defined(HAVE_LINUX_NFS_FS_H) 70#include <linux/nfs_fs.h> 71#endif 72#if defined(HAVE_LINUX_SMB_H) 73#include <linux/smb.h> 74#endif 75#endif 76#include <sys/vfs.h> 77#else 78#include <sys/mount.h> 79#endif 80#define STATVFS statfs 81#define FSTATVFS fstatfs 82#define STATVFS_F_FRSIZE(vfs) static_cast<uint64_t>(vfs.f_bsize) 83#endif 84 85#if defined(__NetBSD__) 86#define STATVFS_F_FLAG(vfs) (vfs).f_flag 87#else 88#define STATVFS_F_FLAG(vfs) (vfs).f_flags 89#endif 90 91using namespace llvm; 92 93namespace llvm { 94namespace sys { 95namespace fs { 96#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \ 97 defined(__minix) || defined(__FreeBSD_kernel__) || defined(__linux__) || \ 98 defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX) 99static int 100test_dir(char ret[PATH_MAX], const char *dir, const char *bin) 101{ 102 struct stat sb; 103 char fullpath[PATH_MAX]; 104 105 snprintf(fullpath, PATH_MAX, "%s/%s", dir, bin); 106 if (!realpath(fullpath, ret)) 107 return 1; 108 if (stat(fullpath, &sb) != 0) 109 return 1; 110 111 return 0; 112} 113 114static char * 115getprogpath(char ret[PATH_MAX], const char *bin) 116{ 117 char *pv, *s, *t; 118 119 /* First approach: absolute path. */ 120 if (bin[0] == '/') { 121 if (test_dir(ret, "/", bin) == 0) 122 return ret; 123 return nullptr; 124 } 125 126 /* Second approach: relative path. */ 127 if (strchr(bin, '/')) { 128 char cwd[PATH_MAX]; 129 if (!getcwd(cwd, PATH_MAX)) 130 return nullptr; 131 if (test_dir(ret, cwd, bin) == 0) 132 return ret; 133 return nullptr; 134 } 135 136 /* Third approach: $PATH */ 137 if ((pv = getenv("PATH")) == nullptr) 138 return nullptr; 139 s = pv = strdup(pv); 140 if (!pv) 141 return nullptr; 142 while ((t = strsep(&s, ":")) != nullptr) { 143 if (test_dir(ret, t, bin) == 0) { 144 free(pv); 145 return ret; 146 } 147 } 148 free(pv); 149 return nullptr; 150} 151#endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__ 152 153/// GetMainExecutable - Return the path to the main executable, given the 154/// value of argv[0] from program startup. 155std::string getMainExecutable(const char *argv0, void *MainAddr) { 156#if defined(__APPLE__) 157 // On OS X the executable path is saved to the stack by dyld. Reading it 158 // from there is much faster than calling dladdr, especially for large 159 // binaries with symbols. 160 char exe_path[MAXPATHLEN]; 161 uint32_t size = sizeof(exe_path); 162 if (_NSGetExecutablePath(exe_path, &size) == 0) { 163 char link_path[MAXPATHLEN]; 164 if (realpath(exe_path, link_path)) 165 return link_path; 166 } 167#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \ 168 defined(__minix) || defined(__DragonFly__) || \ 169 defined(__FreeBSD_kernel__) || defined(_AIX) 170 char exe_path[PATH_MAX]; 171 172 if (getprogpath(exe_path, argv0) != NULL) 173 return exe_path; 174#elif defined(__linux__) || defined(__CYGWIN__) 175 char exe_path[MAXPATHLEN]; 176 StringRef aPath("/proc/self/exe"); 177 if (sys::fs::exists(aPath)) { 178 // /proc is not always mounted under Linux (chroot for example). 179 ssize_t len = readlink(aPath.str().c_str(), exe_path, sizeof(exe_path)); 180 if (len >= 0) 181 return std::string(exe_path, len); 182 } else { 183 // Fall back to the classical detection. 184 if (getprogpath(exe_path, argv0)) 185 return exe_path; 186 } 187#elif defined(HAVE_DLFCN_H) && defined(HAVE_DLADDR) 188 // Use dladdr to get executable path if available. 189 Dl_info DLInfo; 190 int err = dladdr(MainAddr, &DLInfo); 191 if (err == 0) 192 return ""; 193 194 // If the filename is a symlink, we need to resolve and return the location of 195 // the actual executable. 196 char link_path[MAXPATHLEN]; 197 if (realpath(DLInfo.dli_fname, link_path)) 198 return link_path; 199#else 200#error GetMainExecutable is not implemented on this host yet. 201#endif 202 return ""; 203} 204 205TimePoint<> basic_file_status::getLastAccessedTime() const { 206 return toTimePoint(fs_st_atime); 207} 208 209TimePoint<> basic_file_status::getLastModificationTime() const { 210 return toTimePoint(fs_st_mtime); 211} 212 213UniqueID file_status::getUniqueID() const { 214 return UniqueID(fs_st_dev, fs_st_ino); 215} 216 217uint32_t file_status::getLinkCount() const { 218 return fs_st_nlinks; 219} 220 221ErrorOr<space_info> disk_space(const Twine &Path) { 222 struct STATVFS Vfs; 223 if (::STATVFS(Path.str().c_str(), &Vfs)) 224 return std::error_code(errno, std::generic_category()); 225 auto FrSize = STATVFS_F_FRSIZE(Vfs); 226 space_info SpaceInfo; 227 SpaceInfo.capacity = static_cast<uint64_t>(Vfs.f_blocks) * FrSize; 228 SpaceInfo.free = static_cast<uint64_t>(Vfs.f_bfree) * FrSize; 229 SpaceInfo.available = static_cast<uint64_t>(Vfs.f_bavail) * FrSize; 230 return SpaceInfo; 231} 232 233std::error_code current_path(SmallVectorImpl<char> &result) { 234 result.clear(); 235 236 const char *pwd = ::getenv("PWD"); 237 llvm::sys::fs::file_status PWDStatus, DotStatus; 238 if (pwd && llvm::sys::path::is_absolute(pwd) && 239 !llvm::sys::fs::status(pwd, PWDStatus) && 240 !llvm::sys::fs::status(".", DotStatus) && 241 PWDStatus.getUniqueID() == DotStatus.getUniqueID()) { 242 result.append(pwd, pwd + strlen(pwd)); 243 return std::error_code(); 244 } 245 246#ifdef MAXPATHLEN 247 result.reserve(MAXPATHLEN); 248#else 249// For GNU Hurd 250 result.reserve(1024); 251#endif 252 253 while (true) { 254 if (::getcwd(result.data(), result.capacity()) == nullptr) { 255 // See if there was a real error. 256 if (errno != ENOMEM) 257 return std::error_code(errno, std::generic_category()); 258 // Otherwise there just wasn't enough space. 259 result.reserve(result.capacity() * 2); 260 } else 261 break; 262 } 263 264 result.set_size(strlen(result.data())); 265 return std::error_code(); 266} 267 268std::error_code set_current_path(const Twine &path) { 269 SmallString<128> path_storage; 270 StringRef p = path.toNullTerminatedStringRef(path_storage); 271 272 if (::chdir(p.begin()) == -1) 273 return std::error_code(errno, std::generic_category()); 274 275 return std::error_code(); 276} 277 278std::error_code create_directory(const Twine &path, bool IgnoreExisting, 279 perms Perms) { 280 SmallString<128> path_storage; 281 StringRef p = path.toNullTerminatedStringRef(path_storage); 282 283 if (::mkdir(p.begin(), Perms) == -1) { 284 if (errno != EEXIST || !IgnoreExisting) 285 return std::error_code(errno, std::generic_category()); 286 } 287 288 return std::error_code(); 289} 290 291// Note that we are using symbolic link because hard links are not supported by 292// all filesystems (SMB doesn't). 293std::error_code create_link(const Twine &to, const Twine &from) { 294 // Get arguments. 295 SmallString<128> from_storage; 296 SmallString<128> to_storage; 297 StringRef f = from.toNullTerminatedStringRef(from_storage); 298 StringRef t = to.toNullTerminatedStringRef(to_storage); 299 300 if (::symlink(t.begin(), f.begin()) == -1) 301 return std::error_code(errno, std::generic_category()); 302 303 return std::error_code(); 304} 305 306std::error_code create_hard_link(const Twine &to, const Twine &from) { 307 // Get arguments. 308 SmallString<128> from_storage; 309 SmallString<128> to_storage; 310 StringRef f = from.toNullTerminatedStringRef(from_storage); 311 StringRef t = to.toNullTerminatedStringRef(to_storage); 312 313 if (::link(t.begin(), f.begin()) == -1) 314 return std::error_code(errno, std::generic_category()); 315 316 return std::error_code(); 317} 318 319std::error_code remove(const Twine &path, bool IgnoreNonExisting) { 320 SmallString<128> path_storage; 321 StringRef p = path.toNullTerminatedStringRef(path_storage); 322 323 struct stat buf; 324 if (lstat(p.begin(), &buf) != 0) { 325 if (errno != ENOENT || !IgnoreNonExisting) 326 return std::error_code(errno, std::generic_category()); 327 return std::error_code(); 328 } 329 330 // Note: this check catches strange situations. In all cases, LLVM should 331 // only be involved in the creation and deletion of regular files. This 332 // check ensures that what we're trying to erase is a regular file. It 333 // effectively prevents LLVM from erasing things like /dev/null, any block 334 // special file, or other things that aren't "regular" files. 335 if (!S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode) && !S_ISLNK(buf.st_mode)) 336 return make_error_code(errc::operation_not_permitted); 337 338 if (::remove(p.begin()) == -1) { 339 if (errno != ENOENT || !IgnoreNonExisting) 340 return std::error_code(errno, std::generic_category()); 341 } 342 343 return std::error_code(); 344} 345 346static bool is_local_impl(struct STATVFS &Vfs) { 347#if defined(__linux__) 348#ifndef NFS_SUPER_MAGIC 349#define NFS_SUPER_MAGIC 0x6969 350#endif 351#ifndef SMB_SUPER_MAGIC 352#define SMB_SUPER_MAGIC 0x517B 353#endif 354#ifndef CIFS_MAGIC_NUMBER 355#define CIFS_MAGIC_NUMBER 0xFF534D42 356#endif 357 switch ((uint32_t)Vfs.f_type) { 358 case NFS_SUPER_MAGIC: 359 case SMB_SUPER_MAGIC: 360 case CIFS_MAGIC_NUMBER: 361 return false; 362 default: 363 return true; 364 } 365#elif defined(__CYGWIN__) 366 // Cygwin doesn't expose this information; would need to use Win32 API. 367 return false; 368#elif defined(__Fuchsia__) 369 // Fuchsia doesn't yet support remote filesystem mounts. 370 return true; 371#elif defined(__sun) 372 // statvfs::f_basetype contains a null-terminated FSType name of the mounted target 373 StringRef fstype(Vfs.f_basetype); 374 // NFS is the only non-local fstype?? 375 return !fstype.equals("nfs"); 376#else 377 return !!(STATVFS_F_FLAG(Vfs) & MNT_LOCAL); 378#endif 379} 380 381std::error_code is_local(const Twine &Path, bool &Result) { 382 struct STATVFS Vfs; 383 if (::STATVFS(Path.str().c_str(), &Vfs)) 384 return std::error_code(errno, std::generic_category()); 385 386 Result = is_local_impl(Vfs); 387 return std::error_code(); 388} 389 390std::error_code is_local(int FD, bool &Result) { 391 struct STATVFS Vfs; 392 if (::FSTATVFS(FD, &Vfs)) 393 return std::error_code(errno, std::generic_category()); 394 395 Result = is_local_impl(Vfs); 396 return std::error_code(); 397} 398 399std::error_code rename(const Twine &from, const Twine &to) { 400 // Get arguments. 401 SmallString<128> from_storage; 402 SmallString<128> to_storage; 403 StringRef f = from.toNullTerminatedStringRef(from_storage); 404 StringRef t = to.toNullTerminatedStringRef(to_storage); 405 406 if (::rename(f.begin(), t.begin()) == -1) 407 return std::error_code(errno, std::generic_category()); 408 409 return std::error_code(); 410} 411 412std::error_code resize_file(int FD, uint64_t Size) { 413#if defined(HAVE_POSIX_FALLOCATE) 414 // If we have posix_fallocate use it. Unlike ftruncate it always allocates 415 // space, so we get an error if the disk is full. 416 if (int Err = ::posix_fallocate(FD, 0, Size)) { 417 if (Err != EINVAL && Err != EOPNOTSUPP) 418 return std::error_code(Err, std::generic_category()); 419 } 420#endif 421 // Use ftruncate as a fallback. It may or may not allocate space. At least on 422 // OS X with HFS+ it does. 423 if (::ftruncate(FD, Size) == -1) 424 return std::error_code(errno, std::generic_category()); 425 426 return std::error_code(); 427} 428 429static int convertAccessMode(AccessMode Mode) { 430 switch (Mode) { 431 case AccessMode::Exist: 432 return F_OK; 433 case AccessMode::Write: 434 return W_OK; 435 case AccessMode::Execute: 436 return R_OK | X_OK; // scripts also need R_OK. 437 } 438 llvm_unreachable("invalid enum"); 439} 440 441std::error_code access(const Twine &Path, AccessMode Mode) { 442 SmallString<128> PathStorage; 443 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 444 445 if (::access(P.begin(), convertAccessMode(Mode)) == -1) 446 return std::error_code(errno, std::generic_category()); 447 448 if (Mode == AccessMode::Execute) { 449 // Don't say that directories are executable. 450 struct stat buf; 451 if (0 != stat(P.begin(), &buf)) 452 return errc::permission_denied; 453 if (!S_ISREG(buf.st_mode)) 454 return errc::permission_denied; 455 } 456 457 return std::error_code(); 458} 459 460bool can_execute(const Twine &Path) { 461 return !access(Path, AccessMode::Execute); 462} 463 464bool equivalent(file_status A, file_status B) { 465 assert(status_known(A) && status_known(B)); 466 return A.fs_st_dev == B.fs_st_dev && 467 A.fs_st_ino == B.fs_st_ino; 468} 469 470std::error_code equivalent(const Twine &A, const Twine &B, bool &result) { 471 file_status fsA, fsB; 472 if (std::error_code ec = status(A, fsA)) 473 return ec; 474 if (std::error_code ec = status(B, fsB)) 475 return ec; 476 result = equivalent(fsA, fsB); 477 return std::error_code(); 478} 479 480static void expandTildeExpr(SmallVectorImpl<char> &Path) { 481 StringRef PathStr(Path.begin(), Path.size()); 482 if (PathStr.empty() || !PathStr.startswith("~")) 483 return; 484 485 PathStr = PathStr.drop_front(); 486 StringRef Expr = 487 PathStr.take_until([](char c) { return path::is_separator(c); }); 488 StringRef Remainder = PathStr.substr(Expr.size() + 1); 489 SmallString<128> Storage; 490 if (Expr.empty()) { 491 // This is just ~/..., resolve it to the current user's home dir. 492 if (!path::home_directory(Storage)) { 493 // For some reason we couldn't get the home directory. Just exit. 494 return; 495 } 496 497 // Overwrite the first character and insert the rest. 498 Path[0] = Storage[0]; 499 Path.insert(Path.begin() + 1, Storage.begin() + 1, Storage.end()); 500 return; 501 } 502 503 // This is a string of the form ~username/, look up this user's entry in the 504 // password database. 505 struct passwd *Entry = nullptr; 506 std::string User = Expr.str(); 507 Entry = ::getpwnam(User.c_str()); 508 509 if (!Entry) { 510 // Unable to look up the entry, just return back the original path. 511 return; 512 } 513 514 Storage = Remainder; 515 Path.clear(); 516 Path.append(Entry->pw_dir, Entry->pw_dir + strlen(Entry->pw_dir)); 517 llvm::sys::path::append(Path, Storage); 518} 519 520static std::error_code fillStatus(int StatRet, const struct stat &Status, 521 file_status &Result) { 522 if (StatRet != 0) { 523 std::error_code ec(errno, std::generic_category()); 524 if (ec == errc::no_such_file_or_directory) 525 Result = file_status(file_type::file_not_found); 526 else 527 Result = file_status(file_type::status_error); 528 return ec; 529 } 530 531 file_type Type = file_type::type_unknown; 532 533 if (S_ISDIR(Status.st_mode)) 534 Type = file_type::directory_file; 535 else if (S_ISREG(Status.st_mode)) 536 Type = file_type::regular_file; 537 else if (S_ISBLK(Status.st_mode)) 538 Type = file_type::block_file; 539 else if (S_ISCHR(Status.st_mode)) 540 Type = file_type::character_file; 541 else if (S_ISFIFO(Status.st_mode)) 542 Type = file_type::fifo_file; 543 else if (S_ISSOCK(Status.st_mode)) 544 Type = file_type::socket_file; 545 else if (S_ISLNK(Status.st_mode)) 546 Type = file_type::symlink_file; 547 548 perms Perms = static_cast<perms>(Status.st_mode) & all_perms; 549 Result = file_status(Type, Perms, Status.st_dev, Status.st_nlink, 550 Status.st_ino, Status.st_atime, Status.st_mtime, 551 Status.st_uid, Status.st_gid, Status.st_size); 552 553 return std::error_code(); 554} 555 556std::error_code status(const Twine &Path, file_status &Result, bool Follow) { 557 SmallString<128> PathStorage; 558 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 559 560 struct stat Status; 561 int StatRet = (Follow ? ::stat : ::lstat)(P.begin(), &Status); 562 return fillStatus(StatRet, Status, Result); 563} 564 565std::error_code status(int FD, file_status &Result) { 566 struct stat Status; 567 int StatRet = ::fstat(FD, &Status); 568 return fillStatus(StatRet, Status, Result); 569} 570 571std::error_code setPermissions(const Twine &Path, perms Permissions) { 572 SmallString<128> PathStorage; 573 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 574 575 if (::chmod(P.begin(), Permissions)) 576 return std::error_code(errno, std::generic_category()); 577 return std::error_code(); 578} 579 580std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time) { 581#if defined(HAVE_FUTIMENS) 582 timespec Times[2]; 583 Times[0] = Times[1] = sys::toTimeSpec(Time); 584 if (::futimens(FD, Times)) 585 return std::error_code(errno, std::generic_category()); 586 return std::error_code(); 587#elif defined(HAVE_FUTIMES) 588 timeval Times[2]; 589 Times[0] = Times[1] = sys::toTimeVal( 590 std::chrono::time_point_cast<std::chrono::microseconds>(Time)); 591 if (::futimes(FD, Times)) 592 return std::error_code(errno, std::generic_category()); 593 return std::error_code(); 594#else 595#warning Missing futimes() and futimens() 596 return make_error_code(errc::function_not_supported); 597#endif 598} 599 600std::error_code mapped_file_region::init(int FD, uint64_t Offset, 601 mapmode Mode) { 602 assert(Size != 0); 603 604 int flags = (Mode == readwrite) ? MAP_SHARED : MAP_PRIVATE; 605 int prot = (Mode == readonly) ? PROT_READ : (PROT_READ | PROT_WRITE); 606#if defined(__APPLE__) 607 //---------------------------------------------------------------------- 608 // Newer versions of MacOSX have a flag that will allow us to read from 609 // binaries whose code signature is invalid without crashing by using 610 // the MAP_RESILIENT_CODESIGN flag. Also if a file from removable media 611 // is mapped we can avoid crashing and return zeroes to any pages we try 612 // to read if the media becomes unavailable by using the 613 // MAP_RESILIENT_MEDIA flag. These flags are only usable when mapping 614 // with PROT_READ, so take care not to specify them otherwise. 615 //---------------------------------------------------------------------- 616 if (Mode == readonly) { 617#if defined(MAP_RESILIENT_CODESIGN) 618 flags |= MAP_RESILIENT_CODESIGN; 619#endif 620#if defined(MAP_RESILIENT_MEDIA) 621 flags |= MAP_RESILIENT_MEDIA; 622#endif 623 } 624#endif // #if defined (__APPLE__) 625 626 Mapping = ::mmap(nullptr, Size, prot, flags, FD, Offset); 627 if (Mapping == MAP_FAILED) 628 return std::error_code(errno, std::generic_category()); 629 return std::error_code(); 630} 631 632mapped_file_region::mapped_file_region(int fd, mapmode mode, size_t length, 633 uint64_t offset, std::error_code &ec) 634 : Size(length), Mapping(), FD(fd), Mode(mode) { 635 (void)FD; 636 (void)Mode; 637 ec = init(fd, offset, mode); 638 if (ec) 639 Mapping = nullptr; 640} 641 642mapped_file_region::~mapped_file_region() { 643 if (Mapping) 644 ::munmap(Mapping, Size); 645} 646 647size_t mapped_file_region::size() const { 648 assert(Mapping && "Mapping failed but used anyway!"); 649 return Size; 650} 651 652char *mapped_file_region::data() const { 653 assert(Mapping && "Mapping failed but used anyway!"); 654 return reinterpret_cast<char*>(Mapping); 655} 656 657const char *mapped_file_region::const_data() const { 658 assert(Mapping && "Mapping failed but used anyway!"); 659 return reinterpret_cast<const char*>(Mapping); 660} 661 662int mapped_file_region::alignment() { 663 return Process::getPageSize(); 664} 665 666std::error_code detail::directory_iterator_construct(detail::DirIterState &it, 667 StringRef path, 668 bool follow_symlinks) { 669 SmallString<128> path_null(path); 670 DIR *directory = ::opendir(path_null.c_str()); 671 if (!directory) 672 return std::error_code(errno, std::generic_category()); 673 674 it.IterationHandle = reinterpret_cast<intptr_t>(directory); 675 // Add something for replace_filename to replace. 676 path::append(path_null, "."); 677 it.CurrentEntry = directory_entry(path_null.str(), follow_symlinks); 678 return directory_iterator_increment(it); 679} 680 681std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) { 682 if (it.IterationHandle) 683 ::closedir(reinterpret_cast<DIR *>(it.IterationHandle)); 684 it.IterationHandle = 0; 685 it.CurrentEntry = directory_entry(); 686 return std::error_code(); 687} 688 689std::error_code detail::directory_iterator_increment(detail::DirIterState &it) { 690 errno = 0; 691 dirent *cur_dir = ::readdir(reinterpret_cast<DIR *>(it.IterationHandle)); 692 if (cur_dir == nullptr && errno != 0) { 693 return std::error_code(errno, std::generic_category()); 694 } else if (cur_dir != nullptr) { 695 StringRef name(cur_dir->d_name); 696 if ((name.size() == 1 && name[0] == '.') || 697 (name.size() == 2 && name[0] == '.' && name[1] == '.')) 698 return directory_iterator_increment(it); 699 it.CurrentEntry.replace_filename(name); 700 } else 701 return directory_iterator_destruct(it); 702 703 return std::error_code(); 704} 705 706ErrorOr<basic_file_status> directory_entry::status() const { 707 file_status s; 708 if (auto EC = fs::status(Path, s, FollowSymlinks)) 709 return EC; 710 return s; 711} 712 713#if !defined(F_GETPATH) 714static bool hasProcSelfFD() { 715 // If we have a /proc filesystem mounted, we can quickly establish the 716 // real name of the file with readlink 717 static const bool Result = (::access("/proc/self/fd", R_OK) == 0); 718 return Result; 719} 720#endif 721 722std::error_code openFileForRead(const Twine &Name, int &ResultFD, 723 SmallVectorImpl<char> *RealPath) { 724 SmallString<128> Storage; 725 StringRef P = Name.toNullTerminatedStringRef(Storage); 726 int OpenFlags = O_RDONLY; 727#ifdef O_CLOEXEC 728 OpenFlags |= O_CLOEXEC; 729#endif 730 if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags)) < 0) 731 return std::error_code(errno, std::generic_category()); 732#ifndef O_CLOEXEC 733 int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC); 734 (void)r; 735 assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed"); 736#endif 737 // Attempt to get the real name of the file, if the user asked 738 if(!RealPath) 739 return std::error_code(); 740 RealPath->clear(); 741#if defined(F_GETPATH) 742 // When F_GETPATH is availble, it is the quickest way to get 743 // the real path name. 744 char Buffer[MAXPATHLEN]; 745 if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1) 746 RealPath->append(Buffer, Buffer + strlen(Buffer)); 747#else 748 char Buffer[PATH_MAX]; 749 if (hasProcSelfFD()) { 750 char ProcPath[64]; 751 snprintf(ProcPath, sizeof(ProcPath), "/proc/self/fd/%d", ResultFD); 752 ssize_t CharCount = ::readlink(ProcPath, Buffer, sizeof(Buffer)); 753 if (CharCount > 0) 754 RealPath->append(Buffer, Buffer + CharCount); 755 } else { 756 // Use ::realpath to get the real path name 757 if (::realpath(P.begin(), Buffer) != nullptr) 758 RealPath->append(Buffer, Buffer + strlen(Buffer)); 759 } 760#endif 761 return std::error_code(); 762} 763 764std::error_code openFileForWrite(const Twine &Name, int &ResultFD, 765 sys::fs::OpenFlags Flags, unsigned Mode) { 766 // Verify that we don't have both "append" and "excl". 767 assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) && 768 "Cannot specify both 'excl' and 'append' file creation flags!"); 769 770 int OpenFlags = O_CREAT; 771 772#ifdef O_CLOEXEC 773 OpenFlags |= O_CLOEXEC; 774#endif 775 776 if (Flags & F_RW) 777 OpenFlags |= O_RDWR; 778 else 779 OpenFlags |= O_WRONLY; 780 781 if (Flags & F_Append) 782 OpenFlags |= O_APPEND; 783 else if (!(Flags & F_NoTrunc)) 784 OpenFlags |= O_TRUNC; 785 786 if (Flags & F_Excl) 787 OpenFlags |= O_EXCL; 788 789 SmallString<128> Storage; 790 StringRef P = Name.toNullTerminatedStringRef(Storage); 791 if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags, Mode)) < 0) 792 return std::error_code(errno, std::generic_category()); 793#ifndef O_CLOEXEC 794 int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC); 795 (void)r; 796 assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed"); 797#endif 798 return std::error_code(); 799} 800 801template <typename T> 802static std::error_code remove_directories_impl(const T &Entry, 803 bool IgnoreErrors) { 804 std::error_code EC; 805 directory_iterator Begin(Entry, EC, false); 806 directory_iterator End; 807 while (Begin != End) { 808 auto &Item = *Begin; 809 ErrorOr<basic_file_status> st = Item.status(); 810 if (!st && !IgnoreErrors) 811 return st.getError(); 812 813 if (is_directory(*st)) { 814 EC = remove_directories_impl(Item, IgnoreErrors); 815 if (EC && !IgnoreErrors) 816 return EC; 817 } 818 819 EC = fs::remove(Item.path(), true); 820 if (EC && !IgnoreErrors) 821 return EC; 822 823 Begin.increment(EC); 824 if (EC && !IgnoreErrors) 825 return EC; 826 } 827 return std::error_code(); 828} 829 830std::error_code remove_directories(const Twine &path, bool IgnoreErrors) { 831 auto EC = remove_directories_impl(path, IgnoreErrors); 832 if (EC && !IgnoreErrors) 833 return EC; 834 EC = fs::remove(path, true); 835 if (EC && !IgnoreErrors) 836 return EC; 837 return std::error_code(); 838} 839 840std::error_code real_path(const Twine &path, SmallVectorImpl<char> &dest, 841 bool expand_tilde) { 842 dest.clear(); 843 if (path.isTriviallyEmpty()) 844 return std::error_code(); 845 846 if (expand_tilde) { 847 SmallString<128> Storage; 848 path.toVector(Storage); 849 expandTildeExpr(Storage); 850 return real_path(Storage, dest, false); 851 } 852 853 SmallString<128> Storage; 854 StringRef P = path.toNullTerminatedStringRef(Storage); 855 char Buffer[PATH_MAX]; 856 if (::realpath(P.begin(), Buffer) == nullptr) 857 return std::error_code(errno, std::generic_category()); 858 dest.append(Buffer, Buffer + strlen(Buffer)); 859 return std::error_code(); 860} 861 862} // end namespace fs 863 864namespace path { 865 866bool home_directory(SmallVectorImpl<char> &result) { 867 char *RequestedDir = getenv("HOME"); 868 if (!RequestedDir) { 869 struct passwd *pw = getpwuid(getuid()); 870 if (pw && pw->pw_dir) 871 RequestedDir = pw->pw_dir; 872 } 873 if (!RequestedDir) 874 return false; 875 876 result.clear(); 877 result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 878 return true; 879} 880 881static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) { 882 #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR) 883 // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR. 884 // macros defined in <unistd.h> on darwin >= 9 885 int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR 886 : _CS_DARWIN_USER_CACHE_DIR; 887 size_t ConfLen = confstr(ConfName, nullptr, 0); 888 if (ConfLen > 0) { 889 do { 890 Result.resize(ConfLen); 891 ConfLen = confstr(ConfName, Result.data(), Result.size()); 892 } while (ConfLen > 0 && ConfLen != Result.size()); 893 894 if (ConfLen > 0) { 895 assert(Result.back() == 0); 896 Result.pop_back(); 897 return true; 898 } 899 900 Result.clear(); 901 } 902 #endif 903 return false; 904} 905 906static bool getUserCacheDir(SmallVectorImpl<char> &Result) { 907 // First try using XDG_CACHE_HOME env variable, 908 // as specified in XDG Base Directory Specification at 909 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 910 if (const char *XdgCacheDir = std::getenv("XDG_CACHE_HOME")) { 911 Result.clear(); 912 Result.append(XdgCacheDir, XdgCacheDir + strlen(XdgCacheDir)); 913 return true; 914 } 915 916 // Try Darwin configuration query 917 if (getDarwinConfDir(false, Result)) 918 return true; 919 920 // Use "$HOME/.cache" if $HOME is available 921 if (home_directory(Result)) { 922 append(Result, ".cache"); 923 return true; 924 } 925 926 return false; 927} 928 929static const char *getEnvTempDir() { 930 // Check whether the temporary directory is specified by an environment 931 // variable. 932 const char *EnvironmentVariables[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"}; 933 for (const char *Env : EnvironmentVariables) { 934 if (const char *Dir = std::getenv(Env)) 935 return Dir; 936 } 937 938 return nullptr; 939} 940 941static const char *getDefaultTempDir(bool ErasedOnReboot) { 942#ifdef P_tmpdir 943 if ((bool)P_tmpdir) 944 return P_tmpdir; 945#endif 946 947 if (ErasedOnReboot) 948 return "/tmp"; 949 return "/var/tmp"; 950} 951 952void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) { 953 Result.clear(); 954 955 if (ErasedOnReboot) { 956 // There is no env variable for the cache directory. 957 if (const char *RequestedDir = getEnvTempDir()) { 958 Result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 959 return; 960 } 961 } 962 963 if (getDarwinConfDir(ErasedOnReboot, Result)) 964 return; 965 966 const char *RequestedDir = getDefaultTempDir(ErasedOnReboot); 967 Result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 968} 969 970} // end namespace path 971 972} // end namespace sys 973} // end namespace llvm 974