Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2010 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/file_util.h"
      6 
      7 #if defined(OS_WIN)
      8 #include <io.h>
      9 #endif
     10 #include <stdio.h>
     11 
     12 #include <fstream>
     13 
     14 #include "base/file_path.h"
     15 #include "base/logging.h"
     16 #include "base/string_piece.h"
     17 #include "base/string_util.h"
     18 #include "base/utf_string_conversions.h"
     19 
     20 namespace {
     21 
     22 const FilePath::CharType kExtensionSeparator = FILE_PATH_LITERAL('.');
     23 
     24 }  // namespace
     25 
     26 namespace file_util {
     27 
     28 bool EndsWithSeparator(const FilePath& path) {
     29   FilePath::StringType value = path.value();
     30   if (value.empty())
     31     return false;
     32 
     33   return FilePath::IsSeparator(value[value.size() - 1]);
     34 }
     35 
     36 bool EnsureEndsWithSeparator(FilePath* path) {
     37   if (!DirectoryExists(*path))
     38     return false;
     39 
     40   if (EndsWithSeparator(*path))
     41     return true;
     42 
     43   FilePath::StringType& path_str =
     44       const_cast<FilePath::StringType&>(path->value());
     45   path_str.append(&FilePath::kSeparators[0], 1);
     46 
     47   return true;
     48 }
     49 
     50 FilePath::StringType GetFileExtensionFromPath(const FilePath& path) {
     51   FilePath::StringType file_name = path.BaseName().value();
     52   const FilePath::StringType::size_type last_dot =
     53       file_name.rfind(kExtensionSeparator);
     54   return FilePath::StringType(last_dot == FilePath::StringType::npos ?
     55                               FILE_PATH_LITERAL("") :
     56                               file_name, last_dot+1);
     57 }
     58 
     59 void InsertBeforeExtension(FilePath* path, const FilePath::StringType& suffix) {
     60   FilePath::StringType& value =
     61       const_cast<FilePath::StringType&>(path->value());
     62 
     63   const FilePath::StringType::size_type last_dot =
     64       value.rfind(kExtensionSeparator);
     65   const FilePath::StringType::size_type last_separator =
     66       value.find_last_of(FilePath::StringType(FilePath::kSeparators));
     67 
     68   if (last_dot == FilePath::StringType::npos ||
     69       (last_separator != std::wstring::npos && last_dot < last_separator)) {
     70     // The path looks something like "C:\pics.old\jojo" or "C:\pics\jojo".
     71     // We should just append the suffix to the entire path.
     72     value.append(suffix);
     73     return;
     74   }
     75 
     76   value.insert(last_dot, suffix);
     77 }
     78 
     79 bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) {
     80   // We open the file in binary format even if they are text files because
     81   // we are just comparing that bytes are exactly same in both files and not
     82   // doing anything smart with text formatting.
     83   std::ifstream file1(filename1.value().c_str(),
     84                       std::ios::in | std::ios::binary);
     85   std::ifstream file2(filename2.value().c_str(),
     86                       std::ios::in | std::ios::binary);
     87 
     88   // Even if both files aren't openable (and thus, in some sense, "equal"),
     89   // any unusable file yields a result of "false".
     90   if (!file1.is_open() || !file2.is_open())
     91     return false;
     92 
     93   const int BUFFER_SIZE = 2056;
     94   char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
     95   do {
     96     file1.read(buffer1, BUFFER_SIZE);
     97     file2.read(buffer2, BUFFER_SIZE);
     98 
     99     if ((file1.eof() != file2.eof()) ||
    100         (file1.gcount() != file2.gcount()) ||
    101         (memcmp(buffer1, buffer2, file1.gcount()))) {
    102       file1.close();
    103       file2.close();
    104       return false;
    105     }
    106   } while (!file1.eof() || !file2.eof());
    107 
    108   file1.close();
    109   file2.close();
    110   return true;
    111 }
    112 
    113 bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2) {
    114   std::ifstream file1(filename1.value().c_str(), std::ios::in);
    115   std::ifstream file2(filename2.value().c_str(), std::ios::in);
    116 
    117   // Even if both files aren't openable (and thus, in some sense, "equal"),
    118   // any unusable file yields a result of "false".
    119   if (!file1.is_open() || !file2.is_open())
    120     return false;
    121 
    122   do {
    123     std::string line1, line2;
    124     getline(file1, line1);
    125     getline(file2, line2);
    126 
    127     // Check for mismatched EOF states, or any error state.
    128     if ((file1.eof() != file2.eof()) ||
    129         file1.bad() || file2.bad()) {
    130       return false;
    131     }
    132 
    133     // Trim all '\r' and '\n' characters from the end of the line.
    134     std::string::size_type end1 = line1.find_last_not_of("\r\n");
    135     if (end1 == std::string::npos)
    136       line1.clear();
    137     else if (end1 + 1 < line1.length())
    138       line1.erase(end1 + 1);
    139 
    140     std::string::size_type end2 = line2.find_last_not_of("\r\n");
    141     if (end2 == std::string::npos)
    142       line2.clear();
    143     else if (end2 + 1 < line2.length())
    144       line2.erase(end2 + 1);
    145 
    146     if (line1 != line2)
    147       return false;
    148   } while (!file1.eof() || !file2.eof());
    149 
    150   return true;
    151 }
    152 
    153 bool ReadFileToString(const FilePath& path, std::string* contents) {
    154   FILE* file = OpenFile(path, "rb");
    155   if (!file) {
    156     return false;
    157   }
    158 
    159   char buf[1 << 16];
    160   size_t len;
    161   while ((len = fread(buf, 1, sizeof(buf), file)) > 0) {
    162     if (contents)
    163       contents->append(buf, len);
    164   }
    165   CloseFile(file);
    166 
    167   return true;
    168 }
    169 
    170 bool IsDirectoryEmpty(const FilePath& dir_path) {
    171   FileEnumerator files(dir_path, false,
    172       static_cast<FileEnumerator::FILE_TYPE>(
    173           FileEnumerator::FILES | FileEnumerator::DIRECTORIES));
    174   if (files.Next().value().empty())
    175     return true;
    176   return false;
    177 }
    178 
    179 FILE* CreateAndOpenTemporaryFile(FilePath* path) {
    180   FilePath directory;
    181   if (!GetTempDir(&directory))
    182     return NULL;
    183 
    184   return CreateAndOpenTemporaryFileInDir(directory, path);
    185 }
    186 
    187 bool GetFileSize(const FilePath& file_path, int64* file_size) {
    188   base::PlatformFileInfo info;
    189   if (!GetFileInfo(file_path, &info))
    190     return false;
    191   *file_size = info.size;
    192   return true;
    193 }
    194 
    195 bool IsDot(const FilePath& path) {
    196   return FILE_PATH_LITERAL(".") == path.BaseName().value();
    197 }
    198 
    199 bool IsDotDot(const FilePath& path) {
    200   return FILE_PATH_LITERAL("..") == path.BaseName().value();
    201 }
    202 
    203 bool TouchFile(const FilePath& path,
    204                const base::Time& last_accessed,
    205                const base::Time& last_modified) {
    206   base::PlatformFile file =
    207       base::CreatePlatformFile(path,
    208                                base::PLATFORM_FILE_OPEN |
    209                                base::PLATFORM_FILE_WRITE_ATTRIBUTES,
    210                                NULL, NULL);
    211   if (file != base::kInvalidPlatformFileValue) {
    212     bool result = base::TouchPlatformFile(file, last_accessed, last_modified);
    213     base::ClosePlatformFile(file);
    214     return result;
    215   }
    216 
    217   return false;
    218 }
    219 
    220 bool SetLastModifiedTime(const FilePath& path,
    221                          const base::Time& last_modified) {
    222   return TouchFile(path, last_modified, last_modified);
    223 }
    224 
    225 bool CloseFile(FILE* file) {
    226   if (file == NULL)
    227     return true;
    228   return fclose(file) == 0;
    229 }
    230 
    231 bool TruncateFile(FILE* file) {
    232   if (file == NULL)
    233     return false;
    234   long current_offset = ftell(file);
    235   if (current_offset == -1)
    236     return false;
    237 #if defined(OS_WIN)
    238   int fd = _fileno(file);
    239   if (_chsize(fd, current_offset) != 0)
    240     return false;
    241 #else
    242   int fd = fileno(file);
    243   if (ftruncate(fd, current_offset) != 0)
    244     return false;
    245 #endif
    246   return true;
    247 }
    248 
    249 bool ContainsPath(const FilePath &parent, const FilePath& child) {
    250   FilePath abs_parent = FilePath(parent);
    251   FilePath abs_child = FilePath(child);
    252 
    253   if (!file_util::AbsolutePath(&abs_parent) ||
    254       !file_util::AbsolutePath(&abs_child))
    255     return false;
    256 
    257 #if defined(OS_WIN)
    258   // file_util::AbsolutePath() does not flatten case on Windows, so we must do
    259   // a case-insensitive compare.
    260   if (!StartsWith(abs_child.value(), abs_parent.value(), false))
    261 #else
    262   if (!StartsWithASCII(abs_child.value(), abs_parent.value(), true))
    263 #endif
    264     return false;
    265 
    266   // file_util::AbsolutePath() normalizes '/' to '\' on Windows, so we only need
    267   // to check kSeparators[0].
    268   if (abs_child.value().length() <= abs_parent.value().length() ||
    269       abs_child.value()[abs_parent.value().length()] !=
    270           FilePath::kSeparators[0])
    271     return false;
    272 
    273   return true;
    274 }
    275 
    276 int64 ComputeDirectorySize(const FilePath& root_path) {
    277   int64 running_size = 0;
    278   FileEnumerator file_iter(root_path, true, FileEnumerator::FILES);
    279   for (FilePath current = file_iter.Next(); !current.empty();
    280        current = file_iter.Next()) {
    281     FileEnumerator::FindInfo info;
    282     file_iter.GetFindInfo(&info);
    283 #if defined(OS_WIN)
    284     LARGE_INTEGER li = { info.nFileSizeLow, info.nFileSizeHigh };
    285     running_size += li.QuadPart;
    286 #else
    287     running_size += info.stat.st_size;
    288 #endif
    289   }
    290   return running_size;
    291 }
    292 
    293 int64 ComputeFilesSize(const FilePath& directory,
    294                        const FilePath::StringType& pattern) {
    295   int64 running_size = 0;
    296   FileEnumerator file_iter(directory, false, FileEnumerator::FILES, pattern);
    297   for (FilePath current = file_iter.Next(); !current.empty();
    298        current = file_iter.Next()) {
    299     FileEnumerator::FindInfo info;
    300     file_iter.GetFindInfo(&info);
    301 #if defined(OS_WIN)
    302     LARGE_INTEGER li = { info.nFileSizeLow, info.nFileSizeHigh };
    303     running_size += li.QuadPart;
    304 #else
    305     running_size += info.stat.st_size;
    306 #endif
    307   }
    308   return running_size;
    309 }
    310 
    311 ///////////////////////////////////////////////
    312 // MemoryMappedFile
    313 
    314 MemoryMappedFile::~MemoryMappedFile() {
    315   CloseHandles();
    316 }
    317 
    318 bool MemoryMappedFile::Initialize(const FilePath& file_name) {
    319   if (IsValid())
    320     return false;
    321 
    322   if (!MapFileToMemory(file_name)) {
    323     CloseHandles();
    324     return false;
    325   }
    326 
    327   return true;
    328 }
    329 
    330 bool MemoryMappedFile::Initialize(base::PlatformFile file) {
    331   if (IsValid())
    332     return false;
    333 
    334   file_ = file;
    335 
    336   if (!MapFileToMemoryInternal()) {
    337     CloseHandles();
    338     return false;
    339   }
    340 
    341   return true;
    342 }
    343 
    344 bool MemoryMappedFile::IsValid() const {
    345   return data_ != NULL;
    346 }
    347 
    348 bool MemoryMappedFile::MapFileToMemory(const FilePath& file_name) {
    349   file_ = base::CreatePlatformFile(
    350       file_name, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
    351       NULL, NULL);
    352 
    353   if (file_ == base::kInvalidPlatformFileValue) {
    354     LOG(ERROR) << "Couldn't open " << file_name.value();
    355     return false;
    356   }
    357 
    358   return MapFileToMemoryInternal();
    359 }
    360 
    361 // Deprecated functions ----------------------------------------------------
    362 
    363 #if defined(OS_WIN)
    364 void AppendToPath(std::wstring* path, const std::wstring& new_ending) {
    365   if (!path) {
    366     NOTREACHED();
    367     return;  // Don't crash in this function in release builds.
    368   }
    369 
    370   if (!EndsWithSeparator(FilePath(*path)))
    371     path->push_back(FilePath::kSeparators[0]);
    372   path->append(new_ending);
    373 }
    374 
    375 bool CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
    376                    bool recursive) {
    377   return CopyDirectory(FilePath::FromWStringHack(from_path),
    378                        FilePath::FromWStringHack(to_path),
    379                        recursive);
    380 }
    381 bool Delete(const std::wstring& path, bool recursive) {
    382   return Delete(FilePath::FromWStringHack(path), recursive);
    383 }
    384 std::wstring GetFileExtensionFromPath(const std::wstring& path) {
    385   FilePath::StringType extension =
    386       GetFileExtensionFromPath(FilePath::FromWStringHack(path));
    387   return extension;
    388 }
    389 FILE* OpenFile(const std::wstring& filename, const char* mode) {
    390   return OpenFile(FilePath::FromWStringHack(filename), mode);
    391 }
    392 int ReadFile(const std::wstring& filename, char* data, int size) {
    393   return ReadFile(FilePath::FromWStringHack(filename), data, size);
    394 }
    395 int WriteFile(const std::wstring& filename, const char* data, int size) {
    396   return WriteFile(FilePath::FromWStringHack(filename), data, size);
    397 }
    398 #endif  // OS_WIN
    399 
    400 ///////////////////////////////////////////////
    401 // FileEnumerator
    402 //
    403 // Note: the main logic is in file_util_<platform>.cc
    404 
    405 bool FileEnumerator::ShouldSkip(const FilePath& path) {
    406   FilePath::StringType basename = path.BaseName().value();
    407   return IsDot(path) || (IsDotDot(path) && !(INCLUDE_DOT_DOT & file_type_));
    408 }
    409 
    410 }  // namespace
    411