X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSystem%2FUnix%2FPath.cpp;h=99923335c5aab2a9f289a0775fdec0da30d65637;hb=af2f208e7c727f75ee279d63c6b722da0d75fced;hp=e655ef40cdf9d8d99af5ad0622389a207c93e526;hpb=732f92d56ebca7229bea69fdec6b5609f135ff76;p=oota-llvm.git diff --git a/lib/System/Unix/Path.cpp b/lib/System/Unix/Path.cpp index e655ef40cdf..99923335c5a 100644 --- a/lib/System/Unix/Path.cpp +++ b/lib/System/Unix/Path.cpp @@ -16,20 +16,42 @@ //=== is guaranteed to work on *all* UNIX variants. //===----------------------------------------------------------------------===// -#include -#include +#include "llvm/Config/alloca.h" #include "Unix.h" +#if HAVE_SYS_STAT_H #include +#endif +#if HAVE_FCNTL_H #include +#endif +#if HAVE_UTIME_H #include -#include +#endif +#if HAVE_TIME_H +#include +#endif +#if HAVE_DIRENT_H +# include +# define NAMLEN(dirent) strlen((dirent)->d_name) +#else +# define dirent direct +# define NAMLEN(dirent) (dirent)->d_namlen +# if HAVE_SYS_NDIR_H +# include +# endif +# if HAVE_SYS_DIR_H +# include +# endif +# if HAVE_NDIR_H +# include +# endif +#endif + namespace llvm { using namespace sys; -Path::Path(const std::string& unverified_path) - : path(unverified_path) -{ +Path::Path(const std::string& unverified_path) : path(unverified_path) { if (unverified_path.empty()) return; if (this->isValid()) @@ -39,6 +61,21 @@ Path::Path(const std::string& unverified_path) ThrowErrno(unverified_path + ": path is not valid"); } +bool +Path::isValid() const { + if (path.empty()) + return false; + else if (path.length() >= MAXPATHLEN) + return false; +#if defined(HAVE_REALPATH) + char pathname[MAXPATHLEN]; + if (0 == realpath(path.c_str(), pathname)) + if (errno != EACCES && errno != EIO && errno != ENOENT && errno != ENOTDIR) + return false; +#endif + return true; +} + Path Path::GetRootDirectory() { Path result; @@ -46,6 +83,79 @@ Path::GetRootDirectory() { return result; } +Path +Path::GetTemporaryDirectory() { +#if defined(HAVE_MKDTEMP) + // The best way is with mkdtemp but that's not available on many systems, + // Linux and FreeBSD have it. Others probably won't. + char pathname[MAXPATHLEN]; + strcpy(pathname,"/tmp/llvm_XXXXXX"); + if (0 == mkdtemp(pathname)) + ThrowErrno(std::string(pathname) + ": Can't create temporary directory"); + Path result; + result.setDirectory(pathname); + assert(result.isValid() && "mkdtemp didn't create a valid pathname!"); + return result; +#elif defined(HAVE_MKSTEMP) + // If no mkdtemp is available, mkstemp can be used to create a temporary file + // which is then removed and created as a directory. We prefer this over + // mktemp because of mktemp's inherent security and threading risks. We still + // have a slight race condition from the time the temporary file is created to + // the time it is re-created as a directoy. + char pathname[MAXPATHLEN]; + strcpy(pathname, "/tmp/llvm_XXXXXX"); + int fd = 0; + if (-1 == (fd = mkstemp(pathname))) + ThrowErrno(std::string(pathname) + ": Can't create temporary directory"); + ::close(fd); + ::unlink(pathname); // start race condition, ignore errors + if (-1 == ::mkdir(pathname, S_IRWXU)) // end race condition + ThrowErrno(std::string(pathname) + ": Can't create temporary directory"); + Path result; + result.setDirectory(pathname); + assert(result.isValid() && "mkstemp didn't create a valid pathname!"); + return result; +#elif defined(HAVE_MKTEMP) + // If a system doesn't have mkdtemp(3) or mkstemp(3) but it does have + // mktemp(3) then we'll assume that system (e.g. AIX) has a reasonable + // implementation of mktemp(3) and doesn't follow BSD 4.3's lead of replacing + // the XXXXXX with the pid of the process and a letter. That leads to only + // twenty six temporary files that can be generated. + char pathname[MAXPATHLEN]; + strcpy(pathname, "/tmp/llvm_XXXXXX"); + char *TmpName = ::mktemp(pathname); + if (TmpName == 0) + throw std::string(TmpName) + ": Can't create unique directory name"; + if (-1 == ::mkdir(TmpName, S_IRWXU)) + ThrowErrno(std::string(TmpName) + ": Can't create temporary directory"); + Path result; + result.setDirectory(TmpName); + assert(result.isValid() && "mktemp didn't create a valid pathname!"); + return result; +#else + // This is the worst case implementation. tempnam(3) leaks memory unless its + // on an SVID2 (or later) system. On BSD 4.3 it leaks. tmpnam(3) has thread + // issues. The mktemp(3) function doesn't have enough variability in the + // temporary name generated. So, we provide our own implementation that + // increments an integer from a random number seeded by the current time. This + // should be sufficiently unique that we don't have many collisions between + // processes. Generally LLVM processes don't run very long and don't use very + // many temporary files so this shouldn't be a big issue for LLVM. + static time_t num = ::time(0); + char pathname[MAXPATHLEN]; + do { + num++; + sprintf(pathname, "/tmp/llvm_%010u", unsigned(num)); + } while ( 0 == access(pathname, F_OK ) ); + if (-1 == ::mkdir(pathname, S_IRWXU)) + ThrowErrno(std::string(pathname) + ": Can't create temporary directory"); + Path result; + result.setDirectory(pathname); + assert(result.isValid() && "mkstemp didn't create a valid pathname!"); + return result; +#endif +} + static void getPathList(const char*path, std::vector& Paths) { const char* at = path; const char* delim = strchr(at, ':'); @@ -64,6 +174,7 @@ static void getPathList(const char*path, std::vector& Paths) { Paths.push_back(tmpPath); } + void Path::GetSystemLibraryPaths(std::vector& Paths) { #ifdef LTDL_SHLIBPATH_VAR @@ -85,13 +196,6 @@ Path::GetBytecodeLibraryPaths(std::vector& Paths) { if (env_var != 0) { getPathList(env_var,Paths); } -#ifdef LLVMGCCDIR - { - Path tmpPath(std::string(LLVMGCCDIR) + "bytecode-libs/"); - if (tmpPath.readable()) - Paths.push_back(tmpPath); - } -#endif #ifdef LLVM_LIBDIR { Path tmpPath; @@ -108,14 +212,6 @@ Path::GetLLVMDefaultConfigDir() { return Path("/etc/llvm/"); } -Path -Path::GetLLVMConfigDir() { - Path result; - if (result.setDirectory(LLVM_ETCDIR)) - return result; - return GetLLVMDefaultConfigDir(); -} - Path Path::GetUserHomeDirectory() { const char* home = getenv("HOME"); @@ -256,6 +352,42 @@ Path::getStatusInfo(StatusInfo& info) const { path += '/'; } +static bool AddPermissionBits(const std::string& Filename, int bits) { + // Get the umask value from the operating system. We want to use it + // when changing the file's permissions. Since calling umask() sets + // the umask and returns its old value, we must call it a second + // time to reset it to the user's preference. + int mask = umask(0777); // The arg. to umask is arbitrary. + umask(mask); // Restore the umask. + + // Get the file's current mode. + struct stat st; + if ((stat(Filename.c_str(), &st)) == -1) + return false; + + // Change the file to have whichever permissions bits from 'bits' + // that the umask would not disable. + if ((chmod(Filename.c_str(), (st.st_mode | (bits & ~mask)))) == -1) + return false; + + return true; +} + +void Path::makeReadable() { + if (!AddPermissionBits(path,0444)) + ThrowErrno(path + ": can't make file readable"); +} + +void Path::makeWriteable() { + if (!AddPermissionBits(path,0222)) + ThrowErrno(path + ": can't make file writable"); +} + +void Path::makeExecutable() { + if (!AddPermissionBits(path,0111)) + ThrowErrno(path + ": can't make file executable"); +} + bool Path::getDirectoryContents(std::set& result) const { if (!isDirectory()) @@ -290,7 +422,7 @@ Path::setDirectory(const std::string& a_path) { Path save(*this); path = a_path; size_t last = a_path.size() -1; - if (last != 0 && a_path[last] != '/') + if (a_path[last] != '/') path += '/'; if (!isValid()) { path = save.path; @@ -453,26 +585,25 @@ Path::createFile() { } bool -Path::createTemporaryFile() { +Path::createTemporaryFile(bool reuse_current) { // Make sure we're dealing with a file - if (!isFile()) return false; + if (!isFile()) + return false; - // Append the filename filler - char pathname[MAXPATHLEN]; - path.copy(pathname,MAXPATHLEN); - pathname[path.length()] = 0; - strcat(pathname,"XXXXXX"); - int fd = ::mkstemp(pathname); - if (fd < 0) { - ThrowErrno(path + ": Can't create temporary file"); + // Make this into a unique file name + makeUnique( reuse_current ); + + // create the file + int outFile = ::open(path.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0666); + if (outFile != -1) { + ::close(outFile); + return true; } - path = pathname; - ::close(fd); - return true; + return false; } bool -Path::destroyDirectory(bool remove_contents) { +Path::destroyDirectory(bool remove_contents) const { // Make sure we're dealing with a directory if (!isDirectory()) return false; @@ -500,7 +631,7 @@ Path::destroyDirectory(bool remove_contents) { } bool -Path::destroyFile() { +Path::destroyFile() const { if (!isFile()) return false; if (0 != unlink(path.c_str())) ThrowErrno(path + ": Can't destroy file"); @@ -529,6 +660,93 @@ Path::setStatusInfo(const StatusInfo& si) const { return true; } +void +sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) { + int inFile = -1; + int outFile = -1; + try { + inFile = ::open(Src.c_str(), O_RDONLY); + if (inFile == -1) + ThrowErrno("Cannnot open source file to copy: " + Src.toString()); + + outFile = ::open(Dest.c_str(), O_WRONLY|O_CREAT, 0666); + if (outFile == -1) + ThrowErrno("Cannnot create destination file for copy: " +Dest.toString()); + + char Buffer[16*1024]; + while (ssize_t Amt = ::read(inFile, Buffer, 16*1024)) { + if (Amt == -1) { + if (errno != EINTR && errno != EAGAIN) + ThrowErrno("Can't read source file: " + Src.toString()); + } else { + char *BufPtr = Buffer; + while (Amt) { + ssize_t AmtWritten = ::write(outFile, BufPtr, Amt); + if (AmtWritten == -1) { + if (errno != EINTR && errno != EAGAIN) + ThrowErrno("Can't write destination file: " + Dest.toString()); + } else { + Amt -= AmtWritten; + BufPtr += AmtWritten; + } + } + } + } + ::close(inFile); + ::close(outFile); + } catch (...) { + if (inFile != -1) + ::close(inFile); + if (outFile != -1) + ::close(outFile); + throw; + } +} + +void +Path::makeUnique(bool reuse_current) { + if (reuse_current && !exists()) + return; // File doesn't exist already, just use it! + + // Append an XXXXXX pattern to the end of the file for use with mkstemp, + // mktemp or our own implementation. + char *FNBuffer = (char*) alloca(path.size()+8); + path.copy(FNBuffer,path.size()); + strcpy(FNBuffer+path.size(), "-XXXXXX"); + +#if defined(HAVE_MKSTEMP) + int TempFD; + if ((TempFD = mkstemp(FNBuffer)) == -1) { + ThrowErrno("Cannot make unique filename for '" + path + "'"); + } + + // We don't need to hold the temp file descriptor... we will trust that no one + // will overwrite/delete the file before we can open it again. + close(TempFD); + + // Save the name + path = FNBuffer; +#elif defined(HAVE_MKTEMP) + // If we don't have mkstemp, use the old and obsolete mktemp function. + if (mktemp(FNBuffer) == 0) { + ThrowErrno("Cannot make unique filename for '" + path + "'"); + } + + // Save the name + path = FNBuffer; +#else + // Okay, looks like we have to do it all by our lonesome. + static unsigned FCounter = 0; + unsigned offset = path.size() + 1; + while ( FCounter < 999999 && exists()) { + sprintf(FNBuffer+offset,"%06u",++FCounter); + path = FNBuffer; + } + if (FCounter > 999999) + throw std::string("Cannot make unique filename for '" + path + "'"); +#endif + +} } // vim: sw=2