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.
5 #include "base/file_util.h"
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"
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;
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();
44 bool Move(const FilePath& from_path, const FilePath& to_path) {
45 if (from_path.ReferencesParent() || to_path.ReferencesParent())
47 return internal::MoveUnsafe(from_path, to_path);
50 bool CopyFile(const FilePath& from_path, const FilePath& to_path) {
51 if (from_path.ReferencesParent() || to_path.ReferencesParent())
53 return internal::CopyFileUnsafe(from_path, to_path);
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);
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())
70 const int BUFFER_SIZE = 2056;
71 char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
73 file1.read(buffer1, BUFFER_SIZE);
74 file2.read(buffer2, BUFFER_SIZE);
76 if ((file1.eof() != file2.eof()) ||
77 (file1.gcount() != file2.gcount()) ||
78 (memcmp(buffer1, buffer2, file1.gcount()))) {
83 } while (!file1.eof() || !file2.eof());
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);
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())
100 std::string line1, line2;
101 getline(file1, line1);
102 getline(file2, line2);
104 // Check for mismatched EOF states, or any error state.
105 if ((file1.eof() != file2.eof()) ||
106 file1.bad() || file2.bad()) {
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)
114 else if (end1 + 1 < line1.length())
115 line1.erase(end1 + 1);
117 std::string::size_type end2 = line2.find_last_not_of("\r\n");
118 if (end2 == std::string::npos)
120 else if (end2 + 1 < line2.length())
121 line2.erase(end2 + 1);
125 } while (!file1.eof() || !file2.eof());
130 bool ReadFileToString(const FilePath& path,
131 std::string* contents,
135 if (path.ReferencesParent())
137 FILE* file = OpenFile(path, "rb");
145 bool read_status = true;
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) {
151 contents->append(buf, std::min(len, max_size - size));
153 if ((max_size - size) < len) {
160 read_status = read_status && !ferror(file);
166 bool ReadFileToString(const FilePath& path, std::string* contents) {
167 return ReadFileToString(path, contents, std::numeric_limits<size_t>::max());
170 bool IsDirectoryEmpty(const FilePath& dir_path) {
171 FileEnumerator files(dir_path, false,
172 FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
173 if (files.Next().empty())
178 FILE* CreateAndOpenTemporaryFile(FilePath* path) {
180 if (!GetTempDir(&directory))
183 return CreateAndOpenTemporaryFileInDir(directory, path);
186 bool CreateDirectory(const FilePath& full_path) {
187 return CreateDirectoryAndGetError(full_path, NULL);
190 bool GetFileSize(const FilePath& file_path, int64* file_size) {
192 if (!GetFileInfo(file_path, &info))
194 *file_size = info.size;
198 bool TouchFile(const FilePath& path,
199 const Time& last_accessed,
200 const Time& last_modified) {
201 int flags = File::FLAG_OPEN | File::FLAG_WRITE_ATTRIBUTES;
204 // On Windows, FILE_FLAG_BACKUP_SEMANTICS is needed to open a directory.
205 if (DirectoryExists(path))
206 flags |= File::FLAG_BACKUP_SEMANTICS;
209 File file(path, flags);
213 return file.SetTimes(last_accessed, last_modified);
216 bool CloseFile(FILE* file) {
219 return fclose(file) == 0;
222 bool TruncateFile(FILE* file) {
225 long current_offset = ftell(file);
226 if (current_offset == -1)
229 int fd = _fileno(file);
230 if (_chsize(fd, current_offset) != 0)
233 int fd = fileno(file);
234 if (ftruncate(fd, current_offset) != 0)
240 int GetUniquePathNumber(const FilePath& path,
241 const FilePath::StringType& suffix) {
242 bool have_suffix = !suffix.empty();
243 if (!PathExists(path) &&
244 (!have_suffix || !PathExists(FilePath(path.value() + suffix)))) {
249 for (int count = 1; count <= kMaxUniqueFiles; ++count) {
250 new_path = path.InsertBeforeExtensionASCII(StringPrintf(" (%d)", count));
251 if (!PathExists(new_path) &&
252 (!have_suffix || !PathExists(FilePath(new_path.value() + suffix)))) {