lib/System/Unix/Path.inc

   1 //===- llvm/System/Unix/Path.cpp - Unix Path Implementation -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Reid Spencer and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Unix specific portion of the Path class.
  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 <llvm/Config/config.h>
  20 #include <llvm/Config/alloca.h>
  21 #include "Unix.h"
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <utime.h>
  25 #include <dirent.h>
  26
  27 namespace llvm {
  28 using namespace sys;
  29
  30 Path::Path(std::string unverified_path)
  31   : path(unverified_path)
  32 {
  33   if (unverified_path.empty())
  34     return;
  35   if (this->isValid())
  36     return;
  37   // oops, not valid.
  38   path.clear();
  39   ThrowErrno(unverified_path + ": path is not valid");
  40 }
  41
  42 Path
  43 Path::GetRootDirectory() {
  44   Path result;
  45   result.setDirectory("/");
  46   return result;
  47 }
  48
  49 static void getPathList(const char*path, std::vector<sys::Path>& Paths) {
  50   const char* at = path;
  51   const char* delim = strchr(at, ':');
  52   Path tmpPath;
  53   while( delim != 0 ) {
  54     std::string tmp(at, size_t(delim-at));
  55     if (tmpPath.setDirectory(tmp))
  56       if (tmpPath.readable())
  57         Paths.push_back(tmpPath);
  58     at = delim + 1;
  59     delim = strchr(at, ':');
  60   }
  61   if (*at != 0)
  62     if (tmpPath.setDirectory(std::string(at)))
  63       if (tmpPath.readable())
  64         Paths.push_back(tmpPath);
  65
  66 }
  67 void
  68 Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
  69 #ifdef LTDL_SHLIBPATH_VAR
  70   char* env_var = getenv(LTDL_SHLIBPATH_VAR);
  71   if (env_var != 0) {
  72     getPathList(env_var,Paths);
  73   }
  74 #endif
  75   // FIXME: Should this look at LD_LIBRARY_PATH too?
  76   Paths.push_back(sys::Path("/usr/local/lib/"));
  77   Paths.push_back(sys::Path("/usr/X11R6/lib/"));
  78   Paths.push_back(sys::Path("/usr/lib/"));
  79   Paths.push_back(sys::Path("/lib/"));
  80 }
  81
  82 void
  83 Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
  84   char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
  85   if (env_var != 0) {
  86     getPathList(env_var,Paths);
  87   }
  88 #ifdef LLVMGCCDIR
  89   {
  90     Path tmpPath(std::string(LLVMGCCDIR) + "bytecode-libs/");
  91     if (tmpPath.readable())
  92       Paths.push_back(tmpPath);
  93   }
  94 #endif
  95 #ifdef LLVM_LIBDIR
  96   {
  97     Path tmpPath;
  98     if (tmpPath.setDirectory(LLVM_LIBDIR))
  99       if (tmpPath.readable())
 100         Paths.push_back(tmpPath);
 101   }
 102 #endif
 103   GetSystemLibraryPaths(Paths);
 104 }
 105
 106 Path
 107 Path::GetLLVMDefaultConfigDir() {
 108   return Path("/etc/llvm/");
 109 }
 110
 111 Path
 112 Path::GetLLVMConfigDir() {
 113   Path result;
 114   if (result.setDirectory(LLVM_ETCDIR))
 115     return result;
 116   return GetLLVMDefaultConfigDir();
 117 }
 118
 119 Path
 120 Path::GetUserHomeDirectory() {
 121   const char* home = getenv("HOME");
 122   if (home) {
 123     Path result;
 124     if (result.setDirectory(home))
 125       return result;
 126   }
 127   return GetRootDirectory();
 128 }
 129
 130 bool
 131 Path::isFile() const {
 132   return (isValid() && path[path.length()-1] != '/');
 133 }
 134
 135 bool
 136 Path::isDirectory() const {
 137   return (isValid() && path[path.length()-1] == '/');
 138 }
 139
 140 std::string
 141 Path::getBasename() const {
 142   // Find the last slash
 143   size_t slash = path.rfind('/');
 144   if (slash == std::string::npos)
 145     slash = 0;
 146   else
 147     slash++;
 148
 149   return path.substr(slash, path.rfind('.'));
 150 }
 151
 152 bool Path::hasMagicNumber(const std::string &Magic) const {
 153   size_t len = Magic.size();
 154   assert(len < 1024 && "Request for magic string too long");
 155   char* buf = (char*) alloca(1 + len);
 156   int fd = ::open(path.c_str(),O_RDONLY);
 157   if (fd < 0)
 158     return false;
 159   size_t read_len = ::read(fd, buf, len);
 160   close(fd);
 161   if (len != read_len)
 162     return false;
 163   buf[len] = '\0';
 164   return Magic == buf;
 165 }
 166
 167 bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
 168   if (!isFile())
 169     return false;
 170   assert(len < 1024 && "Request for magic string too long");
 171   char* buf = (char*) alloca(1 + len);
 172   int fd = ::open(path.c_str(),O_RDONLY);
 173   if (fd < 0)
 174     return false;
 175   ssize_t bytes_read = ::read(fd, buf, len);
 176   ::close(fd);
 177   if (ssize_t(len) != bytes_read) {
 178     Magic.clear();
 179     return false;
 180   }
 181   Magic.assign(buf,len);
 182   return true;
 183 }
 184
 185 bool
 186 Path::isBytecodeFile() const {
 187   char buffer[ 4];
 188   buffer[0] = 0;
 189   int fd = ::open(path.c_str(),O_RDONLY);
 190   if (fd < 0)
 191     return false;
 192   ssize_t bytes_read = ::read(fd, buffer, 4);
 193   ::close(fd);
 194   if (4 != bytes_read)
 195     return false;
 196
 197   return (buffer[0] == 'l' && buffer[1] == 'l' && buffer[2] == 'v' &&
 198       (buffer[3] == 'c' || buffer[3] == 'm'));
 199 }
 200
 201 bool
 202 Path::exists() const {
 203   return 0 == access(path.c_str(), F_OK );
 204 }
 205
 206 bool
 207 Path::readable() const {
 208   return 0 == access(path.c_str(), F_OK | R_OK );
 209 }
 210
 211 bool
 212 Path::writable() const {
 213   return 0 == access(path.c_str(), F_OK | W_OK );
 214 }
 215
 216 bool
 217 Path::executable() const {
 218   return 0 == access(path.c_str(), R_OK | X_OK );
 219 }
 220
 221 std::string
 222 Path::getLast() const {
 223   // Find the last slash
 224   size_t pos = path.rfind('/');
 225
 226   // Handle the corner cases
 227   if (pos == std::string::npos)
 228     return path;
 229
 230   // If the last character is a slash
 231   if (pos == path.length()-1) {
 232     // Find the second to last slash
 233     size_t pos2 = path.rfind('/', pos-1);
 234     if (pos2 == std::string::npos)
 235       return path.substr(0,pos);
 236     else
 237       return path.substr(pos2+1,pos-pos2-1);
 238   }
 239   // Return everything after the last slash
 240   return path.substr(pos+1);
 241 }
 242
 243 void
 244 Path::getStatusInfo(StatusInfo& info) const {
 245   struct stat buf;
 246   if (0 != stat(path.c_str(), &buf)) {
 247     ThrowErrno(std::string("Can't get status: ")+path);
 248   }
 249   info.fileSize = buf.st_size;
 250   info.modTime.fromEpochTime(buf.st_mtime);
 251   info.mode = buf.st_mode;
 252   info.user = buf.st_uid;
 253   info.group = buf.st_gid;
 254   info.isDir = S_ISDIR(buf.st_mode);
 255   if (info.isDir && path[path.length()-1] != '/')
 256     path += '/';
 257 }
 258
 259 bool
 260 Path::getDirectoryContents(std::set<Path>& result) const {
 261   if (!isDirectory())
 262     return false;
 263   DIR* direntries = ::opendir(path.c_str());
 264   if (direntries == 0)
 265     ThrowErrno(path + ": can't open directory");
 266
 267   result.clear();
 268   struct dirent* de = ::readdir(direntries);
 269   while (de != 0) {
 270     if (de->d_name[0] != '.') {
 271       Path aPath(path + (const char*)de->d_name);
 272       struct stat buf;
 273       if (0 != stat(aPath.path.c_str(), &buf))
 274         ThrowErrno(aPath.path + ": can't get status");
 275       if (S_ISDIR(buf.st_mode))
 276         aPath.path += "/";
 277       result.insert(aPath);
 278     }
 279     de = ::readdir(direntries);
 280   }
 281
 282   closedir(direntries);
 283   return true;
 284 }
 285
 286 bool
 287 Path::setDirectory(const std::string& a_path) {
 288   if (a_path.size() == 0)
 289     return false;
 290   Path save(*this);
 291   path = a_path;
 292   size_t last = a_path.size() -1;
 293   if (last != 0 && a_path[last] != '/')
 294     path += '/';
 295   if (!isValid()) {
 296     path = save.path;
 297     return false;
 298   }
 299   return true;
 300 }
 301
 302 bool
 303 Path::setFile(const std::string& a_path) {
 304   if (a_path.size() == 0)
 305     return false;
 306   Path save(*this);
 307   path = a_path;
 308   size_t last = a_path.size() - 1;
 309   while (last > 0 && a_path[last] == '/')
 310     last--;
 311   path.erase(last+1);
 312   if (!isValid()) {
 313     path = save.path;
 314     return false;
 315   }
 316   return true;
 317 }
 318
 319 bool
 320 Path::appendDirectory(const std::string& dir) {
 321   if (isFile())
 322     return false;
 323   Path save(*this);
 324   path += dir;
 325   path += "/";
 326   if (!isValid()) {
 327     path = save.path;
 328     return false;
 329   }
 330   return true;
 331 }
 332
 333 bool
 334 Path::elideDirectory() {
 335   if (isFile())
 336     return false;
 337   size_t slashpos = path.rfind('/',path.size());
 338   if (slashpos == 0 || slashpos == std::string::npos)
 339     return false;
 340   if (slashpos == path.size() - 1)
 341     slashpos = path.rfind('/',slashpos-1);
 342   if (slashpos == std::string::npos)
 343     return false;
 344   path.erase(slashpos);
 345   return true;
 346 }
 347
 348 bool
 349 Path::appendFile(const std::string& file) {
 350   if (!isDirectory())
 351     return false;
 352   Path save(*this);
 353   path += file;
 354   if (!isValid()) {
 355     path = save.path;
 356     return false;
 357   }
 358   return true;
 359 }
 360
 361 bool
 362 Path::elideFile() {
 363   if (isDirectory())
 364     return false;
 365   size_t slashpos = path.rfind('/',path.size());
 366   if (slashpos == std::string::npos)
 367     return false;
 368   path.erase(slashpos+1);
 369   return true;
 370 }
 371
 372 bool
 373 Path::appendSuffix(const std::string& suffix) {
 374   if (isDirectory())
 375     return false;
 376   Path save(*this);
 377   path.append(".");
 378   path.append(suffix);
 379   if (!isValid()) {
 380     path = save.path;
 381     return false;
 382   }
 383   return true;
 384 }
 385
 386 bool
 387 Path::elideSuffix() {
 388   if (isDirectory()) return false;
 389   size_t dotpos = path.rfind('.',path.size());
 390   size_t slashpos = path.rfind('/',path.size());
 391   if (slashpos != std::string::npos && dotpos != std::string::npos &&
 392       dotpos > slashpos) {
 393     path.erase(dotpos, path.size()-dotpos);
 394     return true;
 395   }
 396   return false;
 397 }
 398
 399
 400 bool
 401 Path::createDirectory( bool create_parents) {
 402   // Make sure we're dealing with a directory
 403   if (!isDirectory()) return false;
 404
 405   // Get a writeable copy of the path name
 406   char pathname[MAXPATHLEN];
 407   path.copy(pathname,MAXPATHLEN);
 408
 409   // Null-terminate the last component
 410   int lastchar = path.length() - 1 ;
 411   if (pathname[lastchar] == '/')
 412     pathname[lastchar] = 0;
 413   else
 414     pathname[lastchar+1] = 0;
 415
 416   // If we're supposed to create intermediate directories
 417   if ( create_parents ) {
 418     // Find the end of the initial name component
 419     char * next = strchr(pathname,'/');
 420     if ( pathname[0] == '/')
 421       next = strchr(&pathname[1],'/');
 422
 423     // Loop through the directory components until we're done
 424     while ( next != 0 ) {
 425       *next = 0;
 426       if (0 != access(pathname, F_OK | R_OK | W_OK))
 427         if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
 428           ThrowErrno(std::string(pathname) + ": Can't create directory");
 429       char* save = next;
 430       next = strchr(next+1,'/');
 431       *save = '/';
 432     }
 433   }
 434
 435   if (0 != access(pathname, F_OK | R_OK))
 436     if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
 437       ThrowErrno(std::string(pathname) + ": Can't create directory");
 438   return true;
 439 }
 440
 441 bool
 442 Path::createFile() {
 443   // Make sure we're dealing with a file
 444   if (!isFile()) return false;
 445
 446   // Create the file
 447   int fd = ::creat(path.c_str(), S_IRUSR | S_IWUSR);
 448   if (fd < 0)
 449     ThrowErrno(path + ": Can't create file");
 450   ::close(fd);
 451
 452   return true;
 453 }
 454
 455 bool
 456 Path::createTemporaryFile() {
 457   // Make sure we're dealing with a file
 458   if (!isFile()) return false;
 459
 460   // Append the filename filler
 461   char pathname[MAXPATHLEN];
 462   path.copy(pathname,MAXPATHLEN);
 463   pathname[path.length()] = 0;
 464   strcat(pathname,"XXXXXX");
 465   int fd = ::mkstemp(pathname);
 466   if (fd < 0) {
 467     ThrowErrno(path + ": Can't create temporary file");
 468   }
 469   path = pathname;
 470   ::close(fd);
 471   return true;
 472 }
 473
 474 bool
 475 Path::destroyDirectory(bool remove_contents) {
 476   // Make sure we're dealing with a directory
 477   if (!isDirectory()) return false;
 478
 479   // If it doesn't exist, we're done.
 480   if (!exists()) return true;
 481
 482   if (remove_contents) {
 483     // Recursively descend the directory to remove its content
 484     std::string cmd("/bin/rm -rf ");
 485     cmd += path;
 486     system(cmd.c_str());
 487   } else {
 488     // Otherwise, try to just remove the one directory
 489     char pathname[MAXPATHLEN];
 490     path.copy(pathname,MAXPATHLEN);
 491     int lastchar = path.length() - 1 ;
 492     if (pathname[lastchar] == '/')
 493       pathname[lastchar] = 0;
 494     else
 495       pathname[lastchar+1] = 0;
 496     if ( 0 != rmdir(pathname))
 497       ThrowErrno(std::string(pathname) + ": Can't destroy directory");
 498   }
 499   return true;
 500 }
 501
 502 bool
 503 Path::destroyFile() {
 504   if (!isFile()) return false;
 505   if (0 != unlink(path.c_str()))
 506     ThrowErrno(path + ": Can't destroy file");
 507   return true;
 508 }
 509
 510 bool
 511 Path::renameFile(const Path& newName) {
 512   if (!isFile()) return false;
 513   if (0 != rename(path.c_str(), newName.c_str()))
 514     ThrowErrno(std::string("can't rename ") + path + " as " +
 515                newName.toString());
 516   return true;
 517 }
 518
 519 bool
 520 Path::setStatusInfo(const StatusInfo& si) const {
 521   if (!isFile()) return false;
 522   struct utimbuf utb;
 523   utb.actime = si.modTime.toPosixTime();
 524   utb.modtime = utb.actime;
 525   if (0 != ::utime(path.c_str(),&utb))
 526     ThrowErrno(path + ": can't set file modification time");
 527   if (0 != ::chmod(path.c_str(),si.mode))
 528     ThrowErrno(path + ": can't set mode");
 529   return true;
 530 }
 531
 532 }
 533
 534 // vim: sw=2