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