base/files/file_util_posix.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_util.h"
   6
   7 #include <dirent.h>
   8 #include <errno.h>
   9 #include <fcntl.h>
  10 #include <libgen.h>
  11 #include <limits.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/errno.h>
  16 #include <sys/mman.h>
  17 #include <sys/param.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <sys/types.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23
  24 #if defined(OS_MACOSX)
  25 #include <AvailabilityMacros.h>
  26 #include "base/mac/foundation_util.h"
  27 #elif !defined(OS_CHROMEOS) && defined(USE_GLIB)
  28 #include <glib.h>  // for g_get_home_dir()
  29 #endif
  30
  31 #include <fstream>
  32
  33 #include "base/basictypes.h"
  34 #include "base/files/file_enumerator.h"
  35 #include "base/files/file_path.h"
  36 #include "base/files/scoped_file.h"
  37 #include "base/logging.h"
  38 #include "base/memory/scoped_ptr.h"
  39 #include "base/memory/singleton.h"
  40 #include "base/path_service.h"
  41 #include "base/posix/eintr_wrapper.h"
  42 #include "base/stl_util.h"
  43 #include "base/strings/string_util.h"
  44 #include "base/strings/stringprintf.h"
  45 #include "base/strings/sys_string_conversions.h"
  46 #include "base/strings/utf_string_conversions.h"
  47 #include "base/sys_info.h"
  48 #include "base/threading/thread_restrictions.h"
  49 #include "base/time/time.h"
  50
  51 #if defined(OS_ANDROID)
  52 #include "base/android/content_uri_utils.h"
  53 #include "base/os_compat_android.h"
  54 #endif
  55
  56 #if !defined(OS_IOS)
  57 #include <grp.h>
  58 #endif
  59
  60 namespace base {
  61
  62 namespace {
  63
  64 #if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL)
  65 static int CallStat(const char *path, stat_wrapper_t *sb) {
  66   ThreadRestrictions::AssertIOAllowed();
  67   return stat(path, sb);
  68 }
  69 static int CallLstat(const char *path, stat_wrapper_t *sb) {
  70   ThreadRestrictions::AssertIOAllowed();
  71   return lstat(path, sb);
  72 }
  73 #else  //  defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL)
  74 static int CallStat(const char *path, stat_wrapper_t *sb) {
  75   ThreadRestrictions::AssertIOAllowed();
  76   return stat64(path, sb);
  77 }
  78 static int CallLstat(const char *path, stat_wrapper_t *sb) {
  79   ThreadRestrictions::AssertIOAllowed();
  80   return lstat64(path, sb);
  81 }
  82 #endif  // !(defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL))
  83
  84 // Helper for NormalizeFilePath(), defined below.
  85 bool RealPath(const FilePath& path, FilePath* real_path) {
  86   ThreadRestrictions::AssertIOAllowed();  // For realpath().
  87   FilePath::CharType buf[PATH_MAX];
  88   if (!realpath(path.value().c_str(), buf))
  89     return false;
  90
  91   *real_path = FilePath(buf);
  92   return true;
  93 }
  94
  95 // Helper for VerifyPathControlledByUser.
  96 bool VerifySpecificPathControlledByUser(const FilePath& path,
  97                                         uid_t owner_uid,
  98                                         const std::set<gid_t>& group_gids) {
  99   stat_wrapper_t stat_info;
 100   if (CallLstat(path.value().c_str(), &stat_info) != 0) {
 101     DPLOG(ERROR) << "Failed to get information on path "
 102                  << path.value();
 103     return false;
 104   }
 105
 106   if (S_ISLNK(stat_info.st_mode)) {
 107     DLOG(ERROR) << "Path " << path.value()
 108                << " is a symbolic link.";
 109     return false;
 110   }
 111
 112   if (stat_info.st_uid != owner_uid) {
 113     DLOG(ERROR) << "Path " << path.value()
 114                 << " is owned by the wrong user.";
 115     return false;
 116   }
 117
 118   if ((stat_info.st_mode & S_IWGRP) &&
 119       !ContainsKey(group_gids, stat_info.st_gid)) {
 120     DLOG(ERROR) << "Path " << path.value()
 121                 << " is writable by an unprivileged group.";
 122     return false;
 123   }
 124
 125   if (stat_info.st_mode & S_IWOTH) {
 126     DLOG(ERROR) << "Path " << path.value()
 127                 << " is writable by any user.";
 128     return false;
 129   }
 130
 131   return true;
 132 }
 133
 134 std::string TempFileName() {
 135 #if defined(OS_MACOSX)
 136   return StringPrintf(".%s.XXXXXX", base::mac::BaseBundleID());
 137 #endif
 138
 139 #if defined(GOOGLE_CHROME_BUILD)
 140   return std::string(".com.google.Chrome.XXXXXX");
 141 #else
 142   return std::string(".org.chromium.Chromium.XXXXXX");
 143 #endif
 144 }
 145
 146 // Creates and opens a temporary file in |directory|, returning the
 147 // file descriptor. |path| is set to the temporary file path.
 148 // This function does NOT unlink() the file.
 149 int CreateAndOpenFdForTemporaryFile(FilePath directory, FilePath* path) {
 150   ThreadRestrictions::AssertIOAllowed();  // For call to mkstemp().
 151   *path = directory.Append(base::TempFileName());
 152   const std::string& tmpdir_string = path->value();
 153   // this should be OK since mkstemp just replaces characters in place
 154   char* buffer = const_cast<char*>(tmpdir_string.c_str());
 155
 156   return HANDLE_EINTR(mkstemp(buffer));
 157 }
 158
 159 #if defined(OS_LINUX)
 160 // Determine if /dev/shm files can be mapped and then mprotect'd PROT_EXEC.
 161 // This depends on the mount options used for /dev/shm, which vary among
 162 // different Linux distributions and possibly local configuration.  It also
 163 // depends on details of kernel--ChromeOS uses the noexec option for /dev/shm
 164 // but its kernel allows mprotect with PROT_EXEC anyway.
 165 bool DetermineDevShmExecutable() {
 166   bool result = false;
 167   FilePath path;
 168
 169   ScopedFD fd(CreateAndOpenFdForTemporaryFile(FilePath("/dev/shm"), &path));
 170   if (fd.is_valid()) {
 171     DeleteFile(path, false);
 172     long sysconf_result = sysconf(_SC_PAGESIZE);
 173     CHECK_GE(sysconf_result, 0);
 174     size_t pagesize = static_cast<size_t>(sysconf_result);
 175     CHECK_GE(sizeof(pagesize), sizeof(sysconf_result));
 176     void* mapping = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, fd.get(), 0);
 177     if (mapping != MAP_FAILED) {
 178       if (mprotect(mapping, pagesize, PROT_READ | PROT_EXEC) == 0)
 179         result = true;
 180       munmap(mapping, pagesize);
 181     }
 182   }
 183   return result;
 184 }
 185 #endif  // defined(OS_LINUX)
 186
 187 }  // namespace
 188
 189 FilePath MakeAbsoluteFilePath(const FilePath& input) {
 190   ThreadRestrictions::AssertIOAllowed();
 191   char full_path[PATH_MAX];
 192   if (realpath(input.value().c_str(), full_path) == NULL)
 193     return FilePath();
 194   return FilePath(full_path);
 195 }
 196
 197 // TODO(erikkay): The Windows version of this accepts paths like "foo/bar/*"
 198 // which works both with and without the recursive flag.  I'm not sure we need
 199 // that functionality. If not, remove from file_util_win.cc, otherwise add it
 200 // here.
 201 bool DeleteFile(const FilePath& path, bool recursive) {
 202   ThreadRestrictions::AssertIOAllowed();
 203   const char* path_str = path.value().c_str();
 204   stat_wrapper_t file_info;
 205   int test = CallLstat(path_str, &file_info);
 206   if (test != 0) {
 207     // The Windows version defines this condition as success.
 208     bool ret = (errno == ENOENT || errno == ENOTDIR);
 209     return ret;
 210   }
 211   if (!S_ISDIR(file_info.st_mode))
 212     return (unlink(path_str) == 0);
 213   if (!recursive)
 214     return (rmdir(path_str) == 0);
 215
 216   bool success = true;
 217   std::stack<std::string> directories;
 218   directories.push(path.value());
 219   FileEnumerator traversal(path, true,
 220       FileEnumerator::FILES | FileEnumerator::DIRECTORIES |
 221       FileEnumerator::SHOW_SYM_LINKS);
 222   for (FilePath current = traversal.Next(); success && !current.empty();
 223        current = traversal.Next()) {
 224     if (traversal.GetInfo().IsDirectory())
 225       directories.push(current.value());
 226     else
 227       success = (unlink(current.value().c_str()) == 0);
 228   }
 229
 230   while (success && !directories.empty()) {
 231     FilePath dir = FilePath(directories.top());
 232     directories.pop();
 233     success = (rmdir(dir.value().c_str()) == 0);
 234   }
 235   return success;
 236 }
 237
 238 bool ReplaceFile(const FilePath& from_path,
 239                  const FilePath& to_path,
 240                  File::Error* error) {
 241   ThreadRestrictions::AssertIOAllowed();
 242   if (rename(from_path.value().c_str(), to_path.value().c_str()) == 0)
 243     return true;
 244   if (error)
 245     *error = File::OSErrorToFileError(errno);
 246   return false;
 247 }
 248
 249 bool CopyDirectory(const FilePath& from_path,
 250                    const FilePath& to_path,
 251                    bool recursive) {
 252   ThreadRestrictions::AssertIOAllowed();
 253   // Some old callers of CopyDirectory want it to support wildcards.
 254   // After some discussion, we decided to fix those callers.
 255   // Break loudly here if anyone tries to do this.
 256   DCHECK(to_path.value().find('*') == std::string::npos);
 257   DCHECK(from_path.value().find('*') == std::string::npos);
 258
 259   if (from_path.value().size() >= PATH_MAX) {
 260     return false;
 261   }
 262
 263   // This function does not properly handle destinations within the source
 264   FilePath real_to_path = to_path;
 265   if (PathExists(real_to_path)) {
 266     real_to_path = MakeAbsoluteFilePath(real_to_path);
 267     if (real_to_path.empty())
 268       return false;
 269   } else {
 270     real_to_path = MakeAbsoluteFilePath(real_to_path.DirName());
 271     if (real_to_path.empty())
 272       return false;
 273   }
 274   FilePath real_from_path = MakeAbsoluteFilePath(from_path);
 275   if (real_from_path.empty())
 276     return false;
 277   if (real_to_path.value().size() >= real_from_path.value().size() &&
 278       real_to_path.value().compare(0, real_from_path.value().size(),
 279                                    real_from_path.value()) == 0) {
 280     return false;
 281   }
 282
 283   int traverse_type = FileEnumerator::FILES | FileEnumerator::SHOW_SYM_LINKS;
 284   if (recursive)
 285     traverse_type |= FileEnumerator::DIRECTORIES;
 286   FileEnumerator traversal(from_path, recursive, traverse_type);
 287
 288   // We have to mimic windows behavior here. |to_path| may not exist yet,
 289   // start the loop with |to_path|.
 290   struct stat from_stat;
 291   FilePath current = from_path;
 292   if (stat(from_path.value().c_str(), &from_stat) < 0) {
 293     DLOG(ERROR) << "CopyDirectory() couldn't stat source directory: "
 294                 << from_path.value() << " errno = " << errno;
 295     return false;
 296   }
 297   struct stat to_path_stat;
 298   FilePath from_path_base = from_path;
 299   if (recursive && stat(to_path.value().c_str(), &to_path_stat) == 0 &&
 300       S_ISDIR(to_path_stat.st_mode)) {
 301     // If the destination already exists and is a directory, then the
 302     // top level of source needs to be copied.
 303     from_path_base = from_path.DirName();
 304   }
 305
 306   // The Windows version of this function assumes that non-recursive calls
 307   // will always have a directory for from_path.
 308   // TODO(maruel): This is not necessary anymore.
 309   DCHECK(recursive || S_ISDIR(from_stat.st_mode));
 310
 311   bool success = true;
 312   while (success && !current.empty()) {
 313     // current is the source path, including from_path, so append
 314     // the suffix after from_path to to_path to create the target_path.
 315     FilePath target_path(to_path);
 316     if (from_path_base != current) {
 317       if (!from_path_base.AppendRelativePath(current, &target_path)) {
 318         success = false;
 319         break;
 320       }
 321     }
 322
 323     if (S_ISDIR(from_stat.st_mode)) {
 324       if (mkdir(target_path.value().c_str(), from_stat.st_mode & 01777) != 0 &&
 325           errno != EEXIST) {
 326         DLOG(ERROR) << "CopyDirectory() couldn't create directory: "
 327                     << target_path.value() << " errno = " << errno;
 328         success = false;
 329       }
 330     } else if (S_ISREG(from_stat.st_mode)) {
 331       if (!CopyFile(current, target_path)) {
 332         DLOG(ERROR) << "CopyDirectory() couldn't create file: "
 333                     << target_path.value();
 334         success = false;
 335       }
 336     } else {
 337       DLOG(WARNING) << "CopyDirectory() skipping non-regular file: "
 338                     << current.value();
 339     }
 340
 341     current = traversal.Next();
 342     if (!current.empty())
 343       from_stat = traversal.GetInfo().stat();
 344   }
 345
 346   return success;
 347 }
 348
 349 bool PathExists(const FilePath& path) {
 350   ThreadRestrictions::AssertIOAllowed();
 351 #if defined(OS_ANDROID)
 352   if (path.IsContentUri()) {
 353     return ContentUriExists(path);
 354   }
 355 #endif
 356   return access(path.value().c_str(), F_OK) == 0;
 357 }
 358
 359 bool PathIsWritable(const FilePath& path) {
 360   ThreadRestrictions::AssertIOAllowed();
 361   return access(path.value().c_str(), W_OK) == 0;
 362 }
 363
 364 bool DirectoryExists(const FilePath& path) {
 365   ThreadRestrictions::AssertIOAllowed();
 366   stat_wrapper_t file_info;
 367   if (CallStat(path.value().c_str(), &file_info) == 0)
 368     return S_ISDIR(file_info.st_mode);
 369   return false;
 370 }
 371
 372 bool ReadFromFD(int fd, char* buffer, size_t bytes) {
 373   size_t total_read = 0;
 374   while (total_read < bytes) {
 375     ssize_t bytes_read =
 376         HANDLE_EINTR(read(fd, buffer + total_read, bytes - total_read));
 377     if (bytes_read <= 0)
 378       break;
 379     total_read += bytes_read;
 380   }
 381   return total_read == bytes;
 382 }
 383
 384 bool CreateSymbolicLink(const FilePath& target_path,
 385                         const FilePath& symlink_path) {
 386   DCHECK(!symlink_path.empty());
 387   DCHECK(!target_path.empty());
 388   return ::symlink(target_path.value().c_str(),
 389                    symlink_path.value().c_str()) != -1;
 390 }
 391
 392 bool ReadSymbolicLink(const FilePath& symlink_path, FilePath* target_path) {
 393   DCHECK(!symlink_path.empty());
 394   DCHECK(target_path);
 395   char buf[PATH_MAX];
 396   ssize_t count = ::readlink(symlink_path.value().c_str(), buf, arraysize(buf));
 397
 398   if (count <= 0) {
 399     target_path->clear();
 400     return false;
 401   }
 402
 403   *target_path = FilePath(FilePath::StringType(buf, count));
 404   return true;
 405 }
 406
 407 bool GetPosixFilePermissions(const FilePath& path, int* mode) {
 408   ThreadRestrictions::AssertIOAllowed();
 409   DCHECK(mode);
 410
 411   stat_wrapper_t file_info;
 412   // Uses stat(), because on symbolic link, lstat() does not return valid
 413   // permission bits in st_mode
 414   if (CallStat(path.value().c_str(), &file_info) != 0)
 415     return false;
 416
 417   *mode = file_info.st_mode & FILE_PERMISSION_MASK;
 418   return true;
 419 }
 420
 421 bool SetPosixFilePermissions(const FilePath& path,
 422                              int mode) {
 423   ThreadRestrictions::AssertIOAllowed();
 424   DCHECK((mode & ~FILE_PERMISSION_MASK) == 0);
 425
 426   // Calls stat() so that we can preserve the higher bits like S_ISGID.
 427   stat_wrapper_t stat_buf;
 428   if (CallStat(path.value().c_str(), &stat_buf) != 0)
 429     return false;
 430
 431   // Clears the existing permission bits, and adds the new ones.
 432   mode_t updated_mode_bits = stat_buf.st_mode & ~FILE_PERMISSION_MASK;
 433   updated_mode_bits |= mode & FILE_PERMISSION_MASK;
 434
 435   if (HANDLE_EINTR(chmod(path.value().c_str(), updated_mode_bits)) != 0)
 436     return false;
 437
 438   return true;
 439 }
 440
 441 #if !defined(OS_MACOSX)
 442 // This is implemented in file_util_mac.mm for Mac.
 443 bool GetTempDir(FilePath* path) {
 444   const char* tmp = getenv("TMPDIR");
 445   if (tmp) {
 446     *path = FilePath(tmp);
 447   } else {
 448 #if defined(OS_ANDROID)
 449     return PathService::Get(base::DIR_CACHE, path);
 450 #else
 451     *path = FilePath("/tmp");
 452 #endif
 453   }
 454   return true;
 455 }
 456 #endif  // !defined(OS_MACOSX)
 457
 458 #if !defined(OS_MACOSX)  // Mac implementation is in file_util_mac.mm.
 459 FilePath GetHomeDir() {
 460 #if defined(OS_CHROMEOS)
 461   if (SysInfo::IsRunningOnChromeOS()) {
 462     // On Chrome OS chrome::DIR_USER_DATA is overridden with a primary user
 463     // homedir once it becomes available. Return / as the safe option.
 464     return FilePath("/");
 465   }
 466 #endif
 467
 468   const char* home_dir = getenv("HOME");
 469   if (home_dir && home_dir[0])
 470     return FilePath(home_dir);
 471
 472 #if defined(OS_ANDROID)
 473   DLOG(WARNING) << "OS_ANDROID: Home directory lookup not yet implemented.";
 474 #elif defined(USE_GLIB) && !defined(OS_CHROMEOS)
 475   // g_get_home_dir calls getpwent, which can fall through to LDAP calls so
 476   // this may do I/O. However, it should be rare that $HOME is not defined and
 477   // this is typically called from the path service which has no threading
 478   // restrictions. The path service will cache the result which limits the
 479   // badness of blocking on I/O. As a result, we don't have a thread
 480   // restriction here.
 481   home_dir = g_get_home_dir();
 482   if (home_dir && home_dir[0])
 483     return FilePath(home_dir);
 484 #endif
 485
 486   FilePath rv;
 487   if (GetTempDir(&rv))
 488     return rv;
 489
 490   // Last resort.
 491   return FilePath("/tmp");
 492 }
 493 #endif  // !defined(OS_MACOSX)
 494
 495 bool CreateTemporaryFile(FilePath* path) {
 496   ThreadRestrictions::AssertIOAllowed();  // For call to close().
 497   FilePath directory;
 498   if (!GetTempDir(&directory))
 499     return false;
 500   int fd = CreateAndOpenFdForTemporaryFile(directory, path);
 501   if (fd < 0)
 502     return false;
 503   close(fd);
 504   return true;
 505 }
 506
 507 FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* path) {
 508   int fd = CreateAndOpenFdForTemporaryFile(dir, path);
 509   if (fd < 0)
 510     return NULL;
 511
 512   FILE* file = fdopen(fd, "a+");
 513   if (!file)
 514     close(fd);
 515   return file;
 516 }
 517
 518 bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
 519   ThreadRestrictions::AssertIOAllowed();  // For call to close().
 520   int fd = CreateAndOpenFdForTemporaryFile(dir, temp_file);
 521   return ((fd >= 0) && !IGNORE_EINTR(close(fd)));
 522 }
 523
 524 static bool CreateTemporaryDirInDirImpl(const FilePath& base_dir,
 525                                         const FilePath::StringType& name_tmpl,
 526                                         FilePath* new_dir) {
 527   ThreadRestrictions::AssertIOAllowed();  // For call to mkdtemp().
 528   DCHECK(name_tmpl.find("XXXXXX") != FilePath::StringType::npos)
 529       << "Directory name template must contain \"XXXXXX\".";
 530
 531   FilePath sub_dir = base_dir.Append(name_tmpl);
 532   std::string sub_dir_string = sub_dir.value();
 533
 534   // this should be OK since mkdtemp just replaces characters in place
 535   char* buffer = const_cast<char*>(sub_dir_string.c_str());
 536   char* dtemp = mkdtemp(buffer);
 537   if (!dtemp) {
 538     DPLOG(ERROR) << "mkdtemp";
 539     return false;
 540   }
 541   *new_dir = FilePath(dtemp);
 542   return true;
 543 }
 544
 545 bool CreateTemporaryDirInDir(const FilePath& base_dir,
 546                              const FilePath::StringType& prefix,
 547                              FilePath* new_dir) {
 548   FilePath::StringType mkdtemp_template = prefix;
 549   mkdtemp_template.append(FILE_PATH_LITERAL("XXXXXX"));
 550   return CreateTemporaryDirInDirImpl(base_dir, mkdtemp_template, new_dir);
 551 }
 552
 553 bool CreateNewTempDirectory(const FilePath::StringType& prefix,
 554                             FilePath* new_temp_path) {
 555   FilePath tmpdir;
 556   if (!GetTempDir(&tmpdir))
 557     return false;
 558
 559   return CreateTemporaryDirInDirImpl(tmpdir, TempFileName(), new_temp_path);
 560 }
 561
 562 bool CreateDirectoryAndGetError(const FilePath& full_path,
 563                                 File::Error* error) {
 564   ThreadRestrictions::AssertIOAllowed();  // For call to mkdir().
 565   std::vector<FilePath> subpaths;
 566
 567   // Collect a list of all parent directories.
 568   FilePath last_path = full_path;
 569   subpaths.push_back(full_path);
 570   for (FilePath path = full_path.DirName();
 571        path.value() != last_path.value(); path = path.DirName()) {
 572     subpaths.push_back(path);
 573     last_path = path;
 574   }
 575
 576   // Iterate through the parents and create the missing ones.
 577   for (std::vector<FilePath>::reverse_iterator i = subpaths.rbegin();
 578        i != subpaths.rend(); ++i) {
 579     if (DirectoryExists(*i))
 580       continue;
 581     if (mkdir(i->value().c_str(), 0700) == 0)
 582       continue;
 583     // Mkdir failed, but it might have failed with EEXIST, or some other error
 584     // due to the the directory appearing out of thin air. This can occur if
 585     // two processes are trying to create the same file system tree at the same
 586     // time. Check to see if it exists and make sure it is a directory.
 587     int saved_errno = errno;
 588     if (!DirectoryExists(*i)) {
 589       if (error)
 590         *error = File::OSErrorToFileError(saved_errno);
 591       return false;
 592     }
 593   }
 594   return true;
 595 }
 596
 597 bool NormalizeFilePath(const FilePath& path, FilePath* normalized_path) {
 598   FilePath real_path_result;
 599   if (!RealPath(path, &real_path_result))
 600     return false;
 601
 602   // To be consistant with windows, fail if |real_path_result| is a
 603   // directory.
 604   stat_wrapper_t file_info;
 605   if (CallStat(real_path_result.value().c_str(), &file_info) != 0 ||
 606       S_ISDIR(file_info.st_mode))
 607     return false;
 608
 609   *normalized_path = real_path_result;
 610   return true;
 611 }
 612
 613 // TODO(rkc): Refactor GetFileInfo and FileEnumerator to handle symlinks
 614 // correctly. http://code.google.com/p/chromium-os/issues/detail?id=15948
 615 bool IsLink(const FilePath& file_path) {
 616   stat_wrapper_t st;
 617   // If we can't lstat the file, it's safe to assume that the file won't at
 618   // least be a 'followable' link.
 619   if (CallLstat(file_path.value().c_str(), &st) != 0)
 620     return false;
 621
 622   if (S_ISLNK(st.st_mode))
 623     return true;
 624   else
 625     return false;
 626 }
 627
 628 bool GetFileInfo(const FilePath& file_path, File::Info* results) {
 629   stat_wrapper_t file_info;
 630 #if defined(OS_ANDROID)
 631   if (file_path.IsContentUri()) {
 632     File file = OpenContentUriForRead(file_path);
 633     if (!file.IsValid())
 634       return false;
 635     return file.GetInfo(results);
 636   } else {
 637 #endif  // defined(OS_ANDROID)
 638     if (CallStat(file_path.value().c_str(), &file_info) != 0)
 639       return false;
 640 #if defined(OS_ANDROID)
 641   }
 642 #endif  // defined(OS_ANDROID)
 643
 644   results->FromStat(file_info);
 645   return true;
 646 }
 647
 648 FILE* OpenFile(const FilePath& filename, const char* mode) {
 649   ThreadRestrictions::AssertIOAllowed();
 650   FILE* result = NULL;
 651   do {
 652     result = fopen(filename.value().c_str(), mode);
 653   } while (!result && errno == EINTR);
 654   return result;
 655 }
 656
 657 // NaCl doesn't implement system calls to open files directly.
 658 #if !defined(OS_NACL)
 659 FILE* FileToFILE(File file, const char* mode) {
 660   FILE* stream = fdopen(file.GetPlatformFile(), mode);
 661   if (stream)
 662     file.TakePlatformFile();
 663   return stream;
 664 }
 665 #endif  // !defined(OS_NACL)
 666
 667 int ReadFile(const FilePath& filename, char* data, int max_size) {
 668   ThreadRestrictions::AssertIOAllowed();
 669   int fd = HANDLE_EINTR(open(filename.value().c_str(), O_RDONLY));
 670   if (fd < 0)
 671     return -1;
 672
 673   ssize_t bytes_read = HANDLE_EINTR(read(fd, data, max_size));
 674   if (IGNORE_EINTR(close(fd)) < 0)
 675     return -1;
 676   return bytes_read;
 677 }
 678
 679 int WriteFile(const FilePath& filename, const char* data, int size) {
 680   ThreadRestrictions::AssertIOAllowed();
 681   int fd = HANDLE_EINTR(creat(filename.value().c_str(), 0640));
 682   if (fd < 0)
 683     return -1;
 684
 685   int bytes_written = WriteFileDescriptor(fd, data, size);
 686   if (IGNORE_EINTR(close(fd)) < 0)
 687     return -1;
 688   return bytes_written;
 689 }
 690
 691 int WriteFileDescriptor(const int fd, const char* data, int size) {
 692   // Allow for partial writes.
 693   ssize_t bytes_written_total = 0;
 694   for (ssize_t bytes_written_partial = 0; bytes_written_total < size;
 695        bytes_written_total += bytes_written_partial) {
 696     bytes_written_partial =
 697         HANDLE_EINTR(write(fd, data + bytes_written_total,
 698                            size - bytes_written_total));
 699     if (bytes_written_partial < 0)
 700       return -1;
 701   }
 702
 703   return bytes_written_total;
 704 }
 705
 706 int AppendToFile(const FilePath& filename, const char* data, int size) {
 707   ThreadRestrictions::AssertIOAllowed();
 708   int fd = HANDLE_EINTR(open(filename.value().c_str(), O_WRONLY | O_APPEND));
 709   if (fd < 0)
 710     return -1;
 711
 712   int bytes_written = WriteFileDescriptor(fd, data, size);
 713   if (IGNORE_EINTR(close(fd)) < 0)
 714     return -1;
 715   return bytes_written;
 716 }
 717
 718 // Gets the current working directory for the process.
 719 bool GetCurrentDirectory(FilePath* dir) {
 720   // getcwd can return ENOENT, which implies it checks against the disk.
 721   ThreadRestrictions::AssertIOAllowed();
 722
 723   char system_buffer[PATH_MAX] = "";
 724   if (!getcwd(system_buffer, sizeof(system_buffer))) {
 725     NOTREACHED();
 726     return false;
 727   }
 728   *dir = FilePath(system_buffer);
 729   return true;
 730 }
 731
 732 // Sets the current working directory for the process.
 733 bool SetCurrentDirectory(const FilePath& path) {
 734   ThreadRestrictions::AssertIOAllowed();
 735   int ret = chdir(path.value().c_str());
 736   return !ret;
 737 }
 738
 739 bool VerifyPathControlledByUser(const FilePath& base,
 740                                 const FilePath& path,
 741                                 uid_t owner_uid,
 742                                 const std::set<gid_t>& group_gids) {
 743   if (base != path && !base.IsParent(path)) {
 744      DLOG(ERROR) << "|base| must be a subdirectory of |path|.  base = \""
 745                  << base.value() << "\", path = \"" << path.value() << "\"";
 746      return false;
 747   }
 748
 749   std::vector<FilePath::StringType> base_components;
 750   std::vector<FilePath::StringType> path_components;
 751
 752   base.GetComponents(&base_components);
 753   path.GetComponents(&path_components);
 754
 755   std::vector<FilePath::StringType>::const_iterator ib, ip;
 756   for (ib = base_components.begin(), ip = path_components.begin();
 757        ib != base_components.end(); ++ib, ++ip) {
 758     // |base| must be a subpath of |path|, so all components should match.
 759     // If these CHECKs fail, look at the test that base is a parent of
 760     // path at the top of this function.
 761     DCHECK(ip != path_components.end());
 762     DCHECK(*ip == *ib);
 763   }
 764
 765   FilePath current_path = base;
 766   if (!VerifySpecificPathControlledByUser(current_path, owner_uid, group_gids))
 767     return false;
 768
 769   for (; ip != path_components.end(); ++ip) {
 770     current_path = current_path.Append(*ip);
 771     if (!VerifySpecificPathControlledByUser(
 772             current_path, owner_uid, group_gids))
 773       return false;
 774   }
 775   return true;
 776 }
 777
 778 #if defined(OS_MACOSX) && !defined(OS_IOS)
 779 bool VerifyPathControlledByAdmin(const FilePath& path) {
 780   const unsigned kRootUid = 0;
 781   const FilePath kFileSystemRoot("/");
 782
 783   // The name of the administrator group on mac os.
 784   const char* const kAdminGroupNames[] = {
 785     "admin",
 786     "wheel"
 787   };
 788
 789   // Reading the groups database may touch the file system.
 790   ThreadRestrictions::AssertIOAllowed();
 791
 792   std::set<gid_t> allowed_group_ids;
 793   for (int i = 0, ie = arraysize(kAdminGroupNames); i < ie; ++i) {
 794     struct group *group_record = getgrnam(kAdminGroupNames[i]);
 795     if (!group_record) {
 796       DPLOG(ERROR) << "Could not get the group ID of group \""
 797                    << kAdminGroupNames[i] << "\".";
 798       continue;
 799     }
 800
 801     allowed_group_ids.insert(group_record->gr_gid);
 802   }
 803
 804   return VerifyPathControlledByUser(
 805       kFileSystemRoot, path, kRootUid, allowed_group_ids);
 806 }
 807 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 808
 809 int GetMaximumPathComponentLength(const FilePath& path) {
 810   ThreadRestrictions::AssertIOAllowed();
 811   return pathconf(path.value().c_str(), _PC_NAME_MAX);
 812 }
 813
 814 #if !defined(OS_ANDROID)
 815 // This is implemented in file_util_android.cc for that platform.
 816 bool GetShmemTempDir(bool executable, FilePath* path) {
 817 #if defined(OS_LINUX)
 818   bool use_dev_shm = true;
 819   if (executable) {
 820     static const bool s_dev_shm_executable = DetermineDevShmExecutable();
 821     use_dev_shm = s_dev_shm_executable;
 822   }
 823   if (use_dev_shm) {
 824     *path = FilePath("/dev/shm");
 825     return true;
 826   }
 827 #endif
 828   return GetTempDir(path);
 829 }
 830 #endif  // !defined(OS_ANDROID)
 831
 832 // -----------------------------------------------------------------------------
 833
 834 namespace internal {
 835
 836 bool MoveUnsafe(const FilePath& from_path, const FilePath& to_path) {
 837   ThreadRestrictions::AssertIOAllowed();
 838   // Windows compatibility: if to_path exists, from_path and to_path
 839   // must be the same type, either both files, or both directories.
 840   stat_wrapper_t to_file_info;
 841   if (CallStat(to_path.value().c_str(), &to_file_info) == 0) {
 842     stat_wrapper_t from_file_info;
 843     if (CallStat(from_path.value().c_str(), &from_file_info) == 0) {
 844       if (S_ISDIR(to_file_info.st_mode) != S_ISDIR(from_file_info.st_mode))
 845         return false;
 846     } else {
 847       return false;
 848     }
 849   }
 850
 851   if (rename(from_path.value().c_str(), to_path.value().c_str()) == 0)
 852     return true;
 853
 854   if (!CopyDirectory(from_path, to_path, true))
 855     return false;
 856
 857   DeleteFile(from_path, true);
 858   return true;
 859 }
 860
 861 #if !defined(OS_MACOSX)
 862 // Mac has its own implementation, this is for all other Posix systems.
 863 bool CopyFileUnsafe(const FilePath& from_path, const FilePath& to_path) {
 864   ThreadRestrictions::AssertIOAllowed();
 865   int infile = HANDLE_EINTR(open(from_path.value().c_str(), O_RDONLY));
 866   if (infile < 0)
 867     return false;
 868
 869   int outfile = HANDLE_EINTR(creat(to_path.value().c_str(), 0666));
 870   if (outfile < 0) {
 871     close(infile);
 872     return false;
 873   }
 874
 875   const size_t kBufferSize = 32768;
 876   std::vector<char> buffer(kBufferSize);
 877   bool result = true;
 878
 879   while (result) {
 880     ssize_t bytes_read = HANDLE_EINTR(read(infile, &buffer[0], buffer.size()));
 881     if (bytes_read < 0) {
 882       result = false;
 883       break;
 884     }
 885     if (bytes_read == 0)
 886       break;
 887     // Allow for partial writes
 888     ssize_t bytes_written_per_read = 0;
 889     do {
 890       ssize_t bytes_written_partial = HANDLE_EINTR(write(
 891           outfile,
 892           &buffer[bytes_written_per_read],
 893           bytes_read - bytes_written_per_read));
 894       if (bytes_written_partial < 0) {
 895         result = false;
 896         break;
 897       }
 898       bytes_written_per_read += bytes_written_partial;
 899     } while (bytes_written_per_read < bytes_read);
 900   }
 901
 902   if (IGNORE_EINTR(close(infile)) < 0)
 903     result = false;
 904   if (IGNORE_EINTR(close(outfile)) < 0)
 905     result = false;
 906
 907   return result;
 908 }
 909 #endif  // !defined(OS_MACOSX)
 910
 911 }  // namespace internal
 912 }  // namespace base