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(__sun) 369 // statvfs::f_basetype contains a null-terminated FSType name of the mounted target 370 StringRef fstype(Vfs.f_basetype); 371 // NFS is the only non-local fstype?? 372 return !fstype.equals("nfs"); 373#else 374 return !!(STATVFS_F_FLAG(Vfs) & MNT_LOCAL); 375#endif 376} 377 378std::error_code is_local(const Twine &Path, bool &Result) { 379 struct STATVFS Vfs; 380 if (::STATVFS(Path.str().c_str(), &Vfs)) 381 return std::error_code(errno, std::generic_category()); 382 383 Result = is_local_impl(Vfs); 384 return std::error_code(); 385} 386 387std::error_code is_local(int FD, bool &Result) { 388 struct STATVFS Vfs; 389 if (::FSTATVFS(FD, &Vfs)) 390 return std::error_code(errno, std::generic_category()); 391 392 Result = is_local_impl(Vfs); 393 return std::error_code(); 394} 395 396std::error_code rename(const Twine &from, const Twine &to) { 397 // Get arguments. 398 SmallString<128> from_storage; 399 SmallString<128> to_storage; 400 StringRef f = from.toNullTerminatedStringRef(from_storage); 401 StringRef t = to.toNullTerminatedStringRef(to_storage); 402 403 if (::rename(f.begin(), t.begin()) == -1) 404 return std::error_code(errno, std::generic_category()); 405 406 return std::error_code(); 407} 408 409std::error_code resize_file(int FD, uint64_t Size) { 410#if defined(HAVE_POSIX_FALLOCATE) 411 // If we have posix_fallocate use it. Unlike ftruncate it always allocates 412 // space, so we get an error if the disk is full. 413 if (int Err = ::posix_fallocate(FD, 0, Size)) { 414 if (Err != EINVAL && Err != EOPNOTSUPP) 415 return std::error_code(Err, std::generic_category()); 416 } 417#endif 418 // Use ftruncate as a fallback. It may or may not allocate space. At least on 419 // OS X with HFS+ it does. 420 if (::ftruncate(FD, Size) == -1) 421 return std::error_code(errno, std::generic_category()); 422 423 return std::error_code(); 424} 425 426static int convertAccessMode(AccessMode Mode) { 427 switch (Mode) { 428 case AccessMode::Exist: 429 return F_OK; 430 case AccessMode::Write: 431 return W_OK; 432 case AccessMode::Execute: 433 return R_OK | X_OK; // scripts also need R_OK. 434 } 435 llvm_unreachable("invalid enum"); 436} 437 438std::error_code access(const Twine &Path, AccessMode Mode) { 439 SmallString<128> PathStorage; 440 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 441 442 if (::access(P.begin(), convertAccessMode(Mode)) == -1) 443 return std::error_code(errno, std::generic_category()); 444 445 if (Mode == AccessMode::Execute) { 446 // Don't say that directories are executable. 447 struct stat buf; 448 if (0 != stat(P.begin(), &buf)) 449 return errc::permission_denied; 450 if (!S_ISREG(buf.st_mode)) 451 return errc::permission_denied; 452 } 453 454 return std::error_code(); 455} 456 457bool can_execute(const Twine &Path) { 458 return !access(Path, AccessMode::Execute); 459} 460 461bool equivalent(file_status A, file_status B) { 462 assert(status_known(A) && status_known(B)); 463 return A.fs_st_dev == B.fs_st_dev && 464 A.fs_st_ino == B.fs_st_ino; 465} 466 467std::error_code equivalent(const Twine &A, const Twine &B, bool &result) { 468 file_status fsA, fsB; 469 if (std::error_code ec = status(A, fsA)) 470 return ec; 471 if (std::error_code ec = status(B, fsB)) 472 return ec; 473 result = equivalent(fsA, fsB); 474 return std::error_code(); 475} 476 477static void expandTildeExpr(SmallVectorImpl<char> &Path) { 478 StringRef PathStr(Path.begin(), Path.size()); 479 if (PathStr.empty() || !PathStr.startswith("~")) 480 return; 481 482 PathStr = PathStr.drop_front(); 483 StringRef Expr = 484 PathStr.take_until([](char c) { return path::is_separator(c); }); 485 StringRef Remainder = PathStr.substr(Expr.size() + 1); 486 SmallString<128> Storage; 487 if (Expr.empty()) { 488 // This is just ~/..., resolve it to the current user's home dir. 489 if (!path::home_directory(Storage)) { 490 // For some reason we couldn't get the home directory. Just exit. 491 return; 492 } 493 494 // Overwrite the first character and insert the rest. 495 Path[0] = Storage[0]; 496 Path.insert(Path.begin() + 1, Storage.begin() + 1, Storage.end()); 497 return; 498 } 499 500 // This is a string of the form ~username/, look up this user's entry in the 501 // password database. 502 struct passwd *Entry = nullptr; 503 std::string User = Expr.str(); 504 Entry = ::getpwnam(User.c_str()); 505 506 if (!Entry) { 507 // Unable to look up the entry, just return back the original path. 508 return; 509 } 510 511 Storage = Remainder; 512 Path.clear(); 513 Path.append(Entry->pw_dir, Entry->pw_dir + strlen(Entry->pw_dir)); 514 llvm::sys::path::append(Path, Storage); 515} 516 517static std::error_code fillStatus(int StatRet, const struct stat &Status, 518 file_status &Result) { 519 if (StatRet != 0) { 520 std::error_code ec(errno, std::generic_category()); 521 if (ec == errc::no_such_file_or_directory) 522 Result = file_status(file_type::file_not_found); 523 else 524 Result = file_status(file_type::status_error); 525 return ec; 526 } 527 528 file_type Type = file_type::type_unknown; 529 530 if (S_ISDIR(Status.st_mode)) 531 Type = file_type::directory_file; 532 else if (S_ISREG(Status.st_mode)) 533 Type = file_type::regular_file; 534 else if (S_ISBLK(Status.st_mode)) 535 Type = file_type::block_file; 536 else if (S_ISCHR(Status.st_mode)) 537 Type = file_type::character_file; 538 else if (S_ISFIFO(Status.st_mode)) 539 Type = file_type::fifo_file; 540 else if (S_ISSOCK(Status.st_mode)) 541 Type = file_type::socket_file; 542 else if (S_ISLNK(Status.st_mode)) 543 Type = file_type::symlink_file; 544 545 perms Perms = static_cast<perms>(Status.st_mode) & all_perms; 546 Result = file_status(Type, Perms, Status.st_dev, Status.st_nlink, 547 Status.st_ino, Status.st_atime, Status.st_mtime, 548 Status.st_uid, Status.st_gid, Status.st_size); 549 550 return std::error_code(); 551} 552 553std::error_code status(const Twine &Path, file_status &Result, bool Follow) { 554 SmallString<128> PathStorage; 555 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 556 557 struct stat Status; 558 int StatRet = (Follow ? ::stat : ::lstat)(P.begin(), &Status); 559 return fillStatus(StatRet, Status, Result); 560} 561 562std::error_code status(int FD, file_status &Result) { 563 struct stat Status; 564 int StatRet = ::fstat(FD, &Status); 565 return fillStatus(StatRet, Status, Result); 566} 567 568std::error_code setPermissions(const Twine &Path, perms Permissions) { 569 SmallString<128> PathStorage; 570 StringRef P = Path.toNullTerminatedStringRef(PathStorage); 571 572 if (::chmod(P.begin(), Permissions)) 573 return std::error_code(errno, std::generic_category()); 574 return std::error_code(); 575} 576 577std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time) { 578#if defined(HAVE_FUTIMENS) 579 timespec Times[2]; 580 Times[0] = Times[1] = sys::toTimeSpec(Time); 581 if (::futimens(FD, Times)) 582 return std::error_code(errno, std::generic_category()); 583 return std::error_code(); 584#elif defined(HAVE_FUTIMES) 585 timeval Times[2]; 586 Times[0] = Times[1] = sys::toTimeVal( 587 std::chrono::time_point_cast<std::chrono::microseconds>(Time)); 588 if (::futimes(FD, Times)) 589 return std::error_code(errno, std::generic_category()); 590 return std::error_code(); 591#else 592#warning Missing futimes() and futimens() 593 return make_error_code(errc::function_not_supported); 594#endif 595} 596 597std::error_code mapped_file_region::init(int FD, uint64_t Offset, 598 mapmode Mode) { 599 assert(Size != 0); 600 601 int flags = (Mode == readwrite) ? MAP_SHARED : MAP_PRIVATE; 602 int prot = (Mode == readonly) ? PROT_READ : (PROT_READ | PROT_WRITE); 603#if defined(__APPLE__) 604 //---------------------------------------------------------------------- 605 // Newer versions of MacOSX have a flag that will allow us to read from 606 // binaries whose code signature is invalid without crashing by using 607 // the MAP_RESILIENT_CODESIGN flag. Also if a file from removable media 608 // is mapped we can avoid crashing and return zeroes to any pages we try 609 // to read if the media becomes unavailable by using the 610 // MAP_RESILIENT_MEDIA flag. These flags are only usable when mapping 611 // with PROT_READ, so take care not to specify them otherwise. 612 //---------------------------------------------------------------------- 613 if (Mode == readonly) { 614#if defined(MAP_RESILIENT_CODESIGN) 615 flags |= MAP_RESILIENT_CODESIGN; 616#endif 617#if defined(MAP_RESILIENT_MEDIA) 618 flags |= MAP_RESILIENT_MEDIA; 619#endif 620 } 621#endif // #if defined (__APPLE__) 622 623 Mapping = ::mmap(nullptr, Size, prot, flags, FD, Offset); 624 if (Mapping == MAP_FAILED) 625 return std::error_code(errno, std::generic_category()); 626 return std::error_code(); 627} 628 629mapped_file_region::mapped_file_region(int fd, mapmode mode, size_t length, 630 uint64_t offset, std::error_code &ec) 631 : Size(length), Mapping(), FD(fd), Mode(mode) { 632 (void)FD; 633 (void)Mode; 634 ec = init(fd, offset, mode); 635 if (ec) 636 Mapping = nullptr; 637} 638 639mapped_file_region::~mapped_file_region() { 640 if (Mapping) 641 ::munmap(Mapping, Size); 642} 643 644size_t mapped_file_region::size() const { 645 assert(Mapping && "Mapping failed but used anyway!"); 646 return Size; 647} 648 649char *mapped_file_region::data() const { 650 assert(Mapping && "Mapping failed but used anyway!"); 651 return reinterpret_cast<char*>(Mapping); 652} 653 654const char *mapped_file_region::const_data() const { 655 assert(Mapping && "Mapping failed but used anyway!"); 656 return reinterpret_cast<const char*>(Mapping); 657} 658 659int mapped_file_region::alignment() { 660 return Process::getPageSize(); 661} 662 663std::error_code detail::directory_iterator_construct(detail::DirIterState &it, 664 StringRef path, 665 bool follow_symlinks) { 666 SmallString<128> path_null(path); 667 DIR *directory = ::opendir(path_null.c_str()); 668 if (!directory) 669 return std::error_code(errno, std::generic_category()); 670 671 it.IterationHandle = reinterpret_cast<intptr_t>(directory); 672 // Add something for replace_filename to replace. 673 path::append(path_null, "."); 674 it.CurrentEntry = directory_entry(path_null.str(), follow_symlinks); 675 return directory_iterator_increment(it); 676} 677 678std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) { 679 if (it.IterationHandle) 680 ::closedir(reinterpret_cast<DIR *>(it.IterationHandle)); 681 it.IterationHandle = 0; 682 it.CurrentEntry = directory_entry(); 683 return std::error_code(); 684} 685 686std::error_code detail::directory_iterator_increment(detail::DirIterState &it) { 687 errno = 0; 688 dirent *cur_dir = ::readdir(reinterpret_cast<DIR *>(it.IterationHandle)); 689 if (cur_dir == nullptr && errno != 0) { 690 return std::error_code(errno, std::generic_category()); 691 } else if (cur_dir != nullptr) { 692 StringRef name(cur_dir->d_name); 693 if ((name.size() == 1 && name[0] == '.') || 694 (name.size() == 2 && name[0] == '.' && name[1] == '.')) 695 return directory_iterator_increment(it); 696 it.CurrentEntry.replace_filename(name); 697 } else 698 return directory_iterator_destruct(it); 699 700 return std::error_code(); 701} 702 703ErrorOr<basic_file_status> directory_entry::status() const { 704 file_status s; 705 if (auto EC = fs::status(Path, s, FollowSymlinks)) 706 return EC; 707 return s; 708} 709 710#if !defined(F_GETPATH) 711static bool hasProcSelfFD() { 712 // If we have a /proc filesystem mounted, we can quickly establish the 713 // real name of the file with readlink 714 static const bool Result = (::access("/proc/self/fd", R_OK) == 0); 715 return Result; 716} 717#endif 718 719std::error_code openFileForRead(const Twine &Name, int &ResultFD, 720 SmallVectorImpl<char> *RealPath) { 721 SmallString<128> Storage; 722 StringRef P = Name.toNullTerminatedStringRef(Storage); 723 int OpenFlags = O_RDONLY; 724#ifdef O_CLOEXEC 725 OpenFlags |= O_CLOEXEC; 726#endif 727 if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags)) < 0) 728 return std::error_code(errno, std::generic_category()); 729#ifndef O_CLOEXEC 730 int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC); 731 (void)r; 732 assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed"); 733#endif 734 // Attempt to get the real name of the file, if the user asked 735 if(!RealPath) 736 return std::error_code(); 737 RealPath->clear(); 738#if defined(F_GETPATH) 739 // When F_GETPATH is availble, it is the quickest way to get 740 // the real path name. 741 char Buffer[MAXPATHLEN]; 742 if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1) 743 RealPath->append(Buffer, Buffer + strlen(Buffer)); 744#else 745 char Buffer[PATH_MAX]; 746 if (hasProcSelfFD()) { 747 char ProcPath[64]; 748 snprintf(ProcPath, sizeof(ProcPath), "/proc/self/fd/%d", ResultFD); 749 ssize_t CharCount = ::readlink(ProcPath, Buffer, sizeof(Buffer)); 750 if (CharCount > 0) 751 RealPath->append(Buffer, Buffer + CharCount); 752 } else { 753 // Use ::realpath to get the real path name 754 if (::realpath(P.begin(), Buffer) != nullptr) 755 RealPath->append(Buffer, Buffer + strlen(Buffer)); 756 } 757#endif 758 return std::error_code(); 759} 760 761std::error_code openFileForWrite(const Twine &Name, int &ResultFD, 762 sys::fs::OpenFlags Flags, unsigned Mode) { 763 // Verify that we don't have both "append" and "excl". 764 assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) && 765 "Cannot specify both 'excl' and 'append' file creation flags!"); 766 767 int OpenFlags = O_CREAT; 768 769#ifdef O_CLOEXEC 770 OpenFlags |= O_CLOEXEC; 771#endif 772 773 if (Flags & F_RW) 774 OpenFlags |= O_RDWR; 775 else 776 OpenFlags |= O_WRONLY; 777 778 if (Flags & F_Append) 779 OpenFlags |= O_APPEND; 780 else if (!(Flags & F_NoTrunc)) 781 OpenFlags |= O_TRUNC; 782 783 if (Flags & F_Excl) 784 OpenFlags |= O_EXCL; 785 786 SmallString<128> Storage; 787 StringRef P = Name.toNullTerminatedStringRef(Storage); 788 if ((ResultFD = sys::RetryAfterSignal(-1, open, P.begin(), OpenFlags, Mode)) < 0) 789 return std::error_code(errno, std::generic_category()); 790#ifndef O_CLOEXEC 791 int r = fcntl(ResultFD, F_SETFD, FD_CLOEXEC); 792 (void)r; 793 assert(r == 0 && "fcntl(F_SETFD, FD_CLOEXEC) failed"); 794#endif 795 return std::error_code(); 796} 797 798template <typename T> 799static std::error_code remove_directories_impl(const T &Entry, 800 bool IgnoreErrors) { 801 std::error_code EC; 802 directory_iterator Begin(Entry, EC, false); 803 directory_iterator End; 804 while (Begin != End) { 805 auto &Item = *Begin; 806 ErrorOr<basic_file_status> st = Item.status(); 807 if (!st && !IgnoreErrors) 808 return st.getError(); 809 810 if (is_directory(*st)) { 811 EC = remove_directories_impl(Item, IgnoreErrors); 812 if (EC && !IgnoreErrors) 813 return EC; 814 } 815 816 EC = fs::remove(Item.path(), true); 817 if (EC && !IgnoreErrors) 818 return EC; 819 820 Begin.increment(EC); 821 if (EC && !IgnoreErrors) 822 return EC; 823 } 824 return std::error_code(); 825} 826 827std::error_code remove_directories(const Twine &path, bool IgnoreErrors) { 828 auto EC = remove_directories_impl(path, IgnoreErrors); 829 if (EC && !IgnoreErrors) 830 return EC; 831 EC = fs::remove(path, true); 832 if (EC && !IgnoreErrors) 833 return EC; 834 return std::error_code(); 835} 836 837std::error_code real_path(const Twine &path, SmallVectorImpl<char> &dest, 838 bool expand_tilde) { 839 dest.clear(); 840 if (path.isTriviallyEmpty()) 841 return std::error_code(); 842 843 if (expand_tilde) { 844 SmallString<128> Storage; 845 path.toVector(Storage); 846 expandTildeExpr(Storage); 847 return real_path(Storage, dest, false); 848 } 849 850 SmallString<128> Storage; 851 StringRef P = path.toNullTerminatedStringRef(Storage); 852 char Buffer[PATH_MAX]; 853 if (::realpath(P.begin(), Buffer) == nullptr) 854 return std::error_code(errno, std::generic_category()); 855 dest.append(Buffer, Buffer + strlen(Buffer)); 856 return std::error_code(); 857} 858 859} // end namespace fs 860 861namespace path { 862 863bool home_directory(SmallVectorImpl<char> &result) { 864 char *RequestedDir = getenv("HOME"); 865 if (!RequestedDir) { 866 struct passwd *pw = getpwuid(getuid()); 867 if (pw && pw->pw_dir) 868 RequestedDir = pw->pw_dir; 869 } 870 if (!RequestedDir) 871 return false; 872 873 result.clear(); 874 result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 875 return true; 876} 877 878static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) { 879 #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR) 880 // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR. 881 // macros defined in <unistd.h> on darwin >= 9 882 int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR 883 : _CS_DARWIN_USER_CACHE_DIR; 884 size_t ConfLen = confstr(ConfName, nullptr, 0); 885 if (ConfLen > 0) { 886 do { 887 Result.resize(ConfLen); 888 ConfLen = confstr(ConfName, Result.data(), Result.size()); 889 } while (ConfLen > 0 && ConfLen != Result.size()); 890 891 if (ConfLen > 0) { 892 assert(Result.back() == 0); 893 Result.pop_back(); 894 return true; 895 } 896 897 Result.clear(); 898 } 899 #endif 900 return false; 901} 902 903static bool getUserCacheDir(SmallVectorImpl<char> &Result) { 904 // First try using XDG_CACHE_HOME env variable, 905 // as specified in XDG Base Directory Specification at 906 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 907 if (const char *XdgCacheDir = std::getenv("XDG_CACHE_HOME")) { 908 Result.clear(); 909 Result.append(XdgCacheDir, XdgCacheDir + strlen(XdgCacheDir)); 910 return true; 911 } 912 913 // Try Darwin configuration query 914 if (getDarwinConfDir(false, Result)) 915 return true; 916 917 // Use "$HOME/.cache" if $HOME is available 918 if (home_directory(Result)) { 919 append(Result, ".cache"); 920 return true; 921 } 922 923 return false; 924} 925 926static const char *getEnvTempDir() { 927 // Check whether the temporary directory is specified by an environment 928 // variable. 929 const char *EnvironmentVariables[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"}; 930 for (const char *Env : EnvironmentVariables) { 931 if (const char *Dir = std::getenv(Env)) 932 return Dir; 933 } 934 935 return nullptr; 936} 937 938static const char *getDefaultTempDir(bool ErasedOnReboot) { 939#ifdef P_tmpdir 940 if ((bool)P_tmpdir) 941 return P_tmpdir; 942#endif 943 944 if (ErasedOnReboot) 945 return "/tmp"; 946 return "/var/tmp"; 947} 948 949void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) { 950 Result.clear(); 951 952 if (ErasedOnReboot) { 953 // There is no env variable for the cache directory. 954 if (const char *RequestedDir = getEnvTempDir()) { 955 Result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 956 return; 957 } 958 } 959 960 if (getDarwinConfDir(ErasedOnReboot, Result)) 961 return; 962 963 const char *RequestedDir = getDefaultTempDir(ErasedOnReboot); 964 Result.append(RequestedDir, RequestedDir + strlen(RequestedDir)); 965} 966 967} // end namespace path 968 969} // end namespace sys 970} // end namespace llvm 971