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