base/file_util.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/file_util.h"
   6
   7 #if defined(OS_WIN)
   8 #include <io.h>
   9 #endif
  10 #include <stdio.h>
  11
  12 #include <fstream>
  13 #include <limits>
  14
  15 #include "base/files/file_enumerator.h"
  16 #include "base/files/file_path.h"
  17 #include "base/logging.h"
  18 #include "base/strings/string_piece.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/utf_string_conversions.h"
  22
  23 namespace base {
  24
  25 namespace {
  26
  27 // The maximum number of 'uniquified' files we will try to create.
  28 // This is used when the filename we're trying to download is already in use,
  29 // so we create a new unique filename by appending " (nnn)" before the
  30 // extension, where 1 <= nnn <= kMaxUniqueFiles.
  31 // Also used by code that cleans up said files.
  32 static const int kMaxUniqueFiles = 100;
  33
  34 }  // namespace
  35
  36 int64 ComputeDirectorySize(const FilePath& root_path) {
  37   int64 running_size = 0;
  38   FileEnumerator file_iter(root_path, true, FileEnumerator::FILES);
  39   while (!file_iter.Next().empty())
  40     running_size += file_iter.GetInfo().GetSize();
  41   return running_size;
  42 }
  43
  44 bool Move(const FilePath& from_path, const FilePath& to_path) {
  45   if (from_path.ReferencesParent() || to_path.ReferencesParent())
  46     return false;
  47   return internal::MoveUnsafe(from_path, to_path);
  48 }
  49
  50 bool CopyFile(const FilePath& from_path, const FilePath& to_path) {
  51   if (from_path.ReferencesParent() || to_path.ReferencesParent())
  52     return false;
  53   return internal::CopyFileUnsafe(from_path, to_path);
  54 }
  55
  56 bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) {
  57   // We open the file in binary format even if they are text files because
  58   // we are just comparing that bytes are exactly same in both files and not
  59   // doing anything smart with text formatting.
  60   std::ifstream file1(filename1.value().c_str(),
  61                       std::ios::in | std::ios::binary);
  62   std::ifstream file2(filename2.value().c_str(),
  63                       std::ios::in | std::ios::binary);
  64
  65   // Even if both files aren't openable (and thus, in some sense, "equal"),
  66   // any unusable file yields a result of "false".
  67   if (!file1.is_open() || !file2.is_open())
  68     return false;
  69
  70   const int BUFFER_SIZE = 2056;
  71   char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
  72   do {
  73     file1.read(buffer1, BUFFER_SIZE);
  74     file2.read(buffer2, BUFFER_SIZE);
  75
  76     if ((file1.eof() != file2.eof()) ||
  77         (file1.gcount() != file2.gcount()) ||
  78         (memcmp(buffer1, buffer2, file1.gcount()))) {
  79       file1.close();
  80       file2.close();
  81       return false;
  82     }
  83   } while (!file1.eof() || !file2.eof());
  84
  85   file1.close();
  86   file2.close();
  87   return true;
  88 }
  89
  90 bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2) {
  91   std::ifstream file1(filename1.value().c_str(), std::ios::in);
  92   std::ifstream file2(filename2.value().c_str(), std::ios::in);
  93
  94   // Even if both files aren't openable (and thus, in some sense, "equal"),
  95   // any unusable file yields a result of "false".
  96   if (!file1.is_open() || !file2.is_open())
  97     return false;
  98
  99   do {
 100     std::string line1, line2;
 101     getline(file1, line1);
 102     getline(file2, line2);
 103
 104     // Check for mismatched EOF states, or any error state.
 105     if ((file1.eof() != file2.eof()) ||
 106         file1.bad() || file2.bad()) {
 107       return false;
 108     }
 109
 110     // Trim all '\r' and '\n' characters from the end of the line.
 111     std::string::size_type end1 = line1.find_last_not_of("\r\n");
 112     if (end1 == std::string::npos)
 113       line1.clear();
 114     else if (end1 + 1 < line1.length())
 115       line1.erase(end1 + 1);
 116
 117     std::string::size_type end2 = line2.find_last_not_of("\r\n");
 118     if (end2 == std::string::npos)
 119       line2.clear();
 120     else if (end2 + 1 < line2.length())
 121       line2.erase(end2 + 1);
 122
 123     if (line1 != line2)
 124       return false;
 125   } while (!file1.eof() || !file2.eof());
 126
 127   return true;
 128 }
 129
 130 bool ReadFileToString(const FilePath& path,
 131                       std::string* contents,
 132                       size_t max_size) {
 133   if (contents)
 134     contents->clear();
 135   if (path.ReferencesParent())
 136     return false;
 137   FILE* file = OpenFile(path, "rb");
 138   if (!file) {
 139     return false;
 140   }
 141
 142   char buf[1 << 16];
 143   size_t len;
 144   size_t size = 0;
 145   bool read_status = true;
 146
 147   // Many files supplied in |path| have incorrect size (proc files etc).
 148   // Hence, the file is read sequentially as opposed to a one-shot read.
 149   while ((len = fread(buf, 1, sizeof(buf), file)) > 0) {
 150     if (contents)
 151       contents->append(buf, std::min(len, max_size - size));
 152
 153     if ((max_size - size) < len) {
 154       read_status = false;
 155       break;
 156     }
 157
 158     size += len;
 159   }
 160   CloseFile(file);
 161
 162   return read_status;
 163 }
 164
 165 bool ReadFileToString(const FilePath& path, std::string* contents) {
 166   return ReadFileToString(path, contents, std::numeric_limits<size_t>::max());
 167 }
 168
 169 bool IsDirectoryEmpty(const FilePath& dir_path) {
 170   FileEnumerator files(dir_path, false,
 171       FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
 172   if (files.Next().empty())
 173     return true;
 174   return false;
 175 }
 176
 177 FILE* CreateAndOpenTemporaryFile(FilePath* path) {
 178   FilePath directory;
 179   if (!GetTempDir(&directory))
 180     return NULL;
 181
 182   return CreateAndOpenTemporaryFileInDir(directory, path);
 183 }
 184
 185 bool CreateDirectory(const FilePath& full_path) {
 186   return CreateDirectoryAndGetError(full_path, NULL);
 187 }
 188
 189 bool GetFileSize(const FilePath& file_path, int64* file_size) {
 190   File::Info info;
 191   if (!GetFileInfo(file_path, &info))
 192     return false;
 193   *file_size = info.size;
 194   return true;
 195 }
 196
 197 bool TouchFile(const FilePath& path,
 198                const Time& last_accessed,
 199                const Time& last_modified) {
 200   int flags = File::FLAG_OPEN | File::FLAG_WRITE_ATTRIBUTES;
 201
 202 #if defined(OS_WIN)
 203   // On Windows, FILE_FLAG_BACKUP_SEMANTICS is needed to open a directory.
 204   if (DirectoryExists(path))
 205     flags |= File::FLAG_BACKUP_SEMANTICS;
 206 #endif  // OS_WIN
 207
 208   File file(path, flags);
 209   if (!file.IsValid())
 210     return false;
 211
 212   return file.SetTimes(last_accessed, last_modified);
 213 }
 214
 215 bool CloseFile(FILE* file) {
 216   if (file == NULL)
 217     return true;
 218   return fclose(file) == 0;
 219 }
 220
 221 bool TruncateFile(FILE* file) {
 222   if (file == NULL)
 223     return false;
 224   long current_offset = ftell(file);
 225   if (current_offset == -1)
 226     return false;
 227 #if defined(OS_WIN)
 228   int fd = _fileno(file);
 229   if (_chsize(fd, current_offset) != 0)
 230     return false;
 231 #else
 232   int fd = fileno(file);
 233   if (ftruncate(fd, current_offset) != 0)
 234     return false;
 235 #endif
 236   return true;
 237 }
 238
 239 }  // namespace base
 240
 241 // -----------------------------------------------------------------------------
 242
 243 namespace file_util {
 244
 245 using base::FilePath;
 246 using base::kMaxUniqueFiles;
 247
 248 int GetUniquePathNumber(
 249     const FilePath& path,
 250     const FilePath::StringType& suffix) {
 251   bool have_suffix = !suffix.empty();
 252   if (!PathExists(path) &&
 253       (!have_suffix || !PathExists(FilePath(path.value() + suffix)))) {
 254     return 0;
 255   }
 256
 257   FilePath new_path;
 258   for (int count = 1; count <= kMaxUniqueFiles; ++count) {
 259     new_path =
 260         path.InsertBeforeExtensionASCII(base::StringPrintf(" (%d)", count));
 261     if (!PathExists(new_path) &&
 262         (!have_suffix || !PathExists(FilePath(new_path.value() + suffix)))) {
 263       return count;
 264     }
 265   }
 266
 267   return -1;
 268 }
 269
 270 }  // namespace file_util