src/storage/browser/fileapi/native_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 "storage/browser/fileapi/native_file_util.h"
   6
   7 #include "base/files/file.h"
   8 #include "base/files/file_enumerator.h"
   9 #include "base/files/file_util.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "storage/browser/fileapi/file_system_operation_context.h"
  12 #include "storage/browser/fileapi/file_system_url.h"
  13
  14 namespace storage {
  15
  16 namespace {
  17
  18 // Sets permissions on directory at |dir_path| based on the target platform.
  19 // Returns true on success, or false otherwise.
  20 //
  21 // TODO(benchan): Find a better place outside webkit to host this function.
  22 bool SetPlatformSpecificDirectoryPermissions(const base::FilePath& dir_path) {
  23 #if defined(OS_CHROMEOS)
  24     // System daemons on Chrome OS may run as a user different than the Chrome
  25     // process but need to access files under the directories created here.
  26     // Because of that, grant the execute permission on the created directory
  27     // to group and other users.
  28     if (HANDLE_EINTR(chmod(dir_path.value().c_str(),
  29                            S_IRWXU | S_IXGRP | S_IXOTH)) != 0) {
  30       return false;
  31     }
  32 #endif
  33     // Keep the directory permissions unchanged on non-Chrome OS platforms.
  34     return true;
  35 }
  36
  37 // Copies a file |from| to |to|, and ensure the written content is synced to
  38 // the disk. This is essentially base::CopyFile followed by fsync().
  39 bool CopyFileAndSync(const base::FilePath& from, const base::FilePath& to) {
  40   base::File infile(from, base::File::FLAG_OPEN | base::File::FLAG_READ);
  41   if (!infile.IsValid()) {
  42     return false;
  43   }
  44
  45   base::File outfile(to,
  46                      base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  47   if (!outfile.IsValid()) {
  48     return false;
  49   }
  50
  51   const int kBufferSize = 32768;
  52   std::vector<char> buffer(kBufferSize);
  53
  54   for (;;) {
  55     int bytes_read = infile.ReadAtCurrentPos(&buffer[0], kBufferSize);
  56     if (bytes_read < 0)
  57       return false;
  58     if (bytes_read == 0)
  59       break;
  60     for (int bytes_written = 0; bytes_written < bytes_read; ) {
  61       int bytes_written_partial = outfile.WriteAtCurrentPos(
  62           &buffer[bytes_written], bytes_read - bytes_written);
  63       if (bytes_written_partial < 0)
  64         return false;
  65       bytes_written += bytes_written_partial;
  66     }
  67   }
  68
  69   return outfile.Flush();
  70 }
  71
  72 }  // namespace
  73
  74 using base::PlatformFile;
  75
  76 class NativeFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  77  public:
  78   NativeFileEnumerator(const base::FilePath& root_path,
  79                        bool recursive,
  80                        int file_type)
  81     : file_enum_(root_path, recursive, file_type) {
  82   }
  83
  84   virtual ~NativeFileEnumerator() {}
  85
  86   virtual base::FilePath Next() OVERRIDE;
  87   virtual int64 Size() OVERRIDE;
  88   virtual base::Time LastModifiedTime() OVERRIDE;
  89   virtual bool IsDirectory() OVERRIDE;
  90
  91  private:
  92   base::FileEnumerator file_enum_;
  93   base::FileEnumerator::FileInfo file_util_info_;
  94 };
  95
  96 base::FilePath NativeFileEnumerator::Next() {
  97   base::FilePath rv = file_enum_.Next();
  98   if (!rv.empty())
  99     file_util_info_ = file_enum_.GetInfo();
 100   return rv;
 101 }
 102
 103 int64 NativeFileEnumerator::Size() {
 104   return file_util_info_.GetSize();
 105 }
 106
 107 base::Time NativeFileEnumerator::LastModifiedTime() {
 108   return file_util_info_.GetLastModifiedTime();
 109 }
 110
 111 bool NativeFileEnumerator::IsDirectory() {
 112   return file_util_info_.IsDirectory();
 113 }
 114
 115 NativeFileUtil::CopyOrMoveMode NativeFileUtil::CopyOrMoveModeForDestination(
 116     const FileSystemURL& dest_url, bool copy) {
 117   if (copy) {
 118     return dest_url.mount_option().copy_sync_option() == COPY_SYNC_OPTION_SYNC ?
 119         COPY_SYNC : COPY_NOSYNC;
 120   }
 121   return MOVE;
 122 }
 123
 124 base::File NativeFileUtil::CreateOrOpen(const base::FilePath& path,
 125                                         int file_flags) {
 126   if (!base::DirectoryExists(path.DirName())) {
 127     // If its parent does not exist, should return NOT_FOUND error.
 128     return base::File(base::File::FILE_ERROR_NOT_FOUND);
 129   }
 130
 131   // TODO(rvargas): Check |file_flags| instead. See bug 356358.
 132   if (base::DirectoryExists(path))
 133     return base::File(base::File::FILE_ERROR_NOT_A_FILE);
 134
 135   return base::File(path, file_flags);
 136 }
 137
 138 base::File::Error NativeFileUtil::EnsureFileExists(
 139     const base::FilePath& path,
 140     bool* created) {
 141   if (!base::DirectoryExists(path.DirName()))
 142     // If its parent does not exist, should return NOT_FOUND error.
 143     return base::File::FILE_ERROR_NOT_FOUND;
 144
 145   // Tries to create the |path| exclusively.  This should fail
 146   // with base::File::FILE_ERROR_EXISTS if the path already exists.
 147   base::File file(path, base::File::FLAG_CREATE | base::File::FLAG_READ);
 148
 149   if (file.IsValid()) {
 150     if (created)
 151       *created = file.created();
 152     return base::File::FILE_OK;
 153   }
 154
 155   base::File::Error error_code = file.error_details();
 156   if (error_code == base::File::FILE_ERROR_EXISTS) {
 157     // Make sure created_ is false.
 158     if (created)
 159       *created = false;
 160     error_code = base::File::FILE_OK;
 161   }
 162   return error_code;
 163 }
 164
 165 base::File::Error NativeFileUtil::CreateDirectory(
 166     const base::FilePath& path,
 167     bool exclusive,
 168     bool recursive) {
 169   // If parent dir of file doesn't exist.
 170   if (!recursive && !base::PathExists(path.DirName()))
 171     return base::File::FILE_ERROR_NOT_FOUND;
 172
 173   bool path_exists = base::PathExists(path);
 174   if (exclusive && path_exists)
 175     return base::File::FILE_ERROR_EXISTS;
 176
 177   // If file exists at the path.
 178   if (path_exists && !base::DirectoryExists(path))
 179     return base::File::FILE_ERROR_EXISTS;
 180
 181   if (!base::CreateDirectory(path))
 182     return base::File::FILE_ERROR_FAILED;
 183
 184   if (!SetPlatformSpecificDirectoryPermissions(path)) {
 185     // Since some file systems don't support permission setting, we do not treat
 186     // an error from the function as the failure of copying. Just log it.
 187     LOG(WARNING) << "Setting directory permission failed: "
 188         << path.AsUTF8Unsafe();
 189   }
 190
 191   return base::File::FILE_OK;
 192 }
 193
 194 base::File::Error NativeFileUtil::GetFileInfo(
 195     const base::FilePath& path,
 196     base::File::Info* file_info) {
 197   if (!base::PathExists(path))
 198     return base::File::FILE_ERROR_NOT_FOUND;
 199
 200   if (!base::GetFileInfo(path, file_info))
 201     return base::File::FILE_ERROR_FAILED;
 202   return base::File::FILE_OK;
 203 }
 204
 205 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
 206     NativeFileUtil::CreateFileEnumerator(const base::FilePath& root_path,
 207                                          bool recursive) {
 208   return make_scoped_ptr(new NativeFileEnumerator(
 209       root_path, recursive,
 210       base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES))
 211       .PassAs<FileSystemFileUtil::AbstractFileEnumerator>();
 212 }
 213
 214 base::File::Error NativeFileUtil::Touch(
 215     const base::FilePath& path,
 216     const base::Time& last_access_time,
 217     const base::Time& last_modified_time) {
 218   if (!base::TouchFile(path, last_access_time, last_modified_time))
 219     return base::File::FILE_ERROR_FAILED;
 220   return base::File::FILE_OK;
 221 }
 222
 223 base::File::Error NativeFileUtil::Truncate(const base::FilePath& path,
 224                                            int64 length) {
 225   base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_WRITE);
 226   if (!file.IsValid())
 227     return file.error_details();
 228
 229   if (!file.SetLength(length))
 230     return base::File::FILE_ERROR_FAILED;
 231
 232   return base::File::FILE_OK;
 233 }
 234
 235 bool NativeFileUtil::PathExists(const base::FilePath& path) {
 236   return base::PathExists(path);
 237 }
 238
 239 bool NativeFileUtil::DirectoryExists(const base::FilePath& path) {
 240   return base::DirectoryExists(path);
 241 }
 242
 243 base::File::Error NativeFileUtil::CopyOrMoveFile(
 244     const base::FilePath& src_path,
 245     const base::FilePath& dest_path,
 246     FileSystemOperation::CopyOrMoveOption option,
 247     CopyOrMoveMode mode) {
 248   base::File::Info info;
 249   base::File::Error error = NativeFileUtil::GetFileInfo(src_path, &info);
 250   if (error != base::File::FILE_OK)
 251     return error;
 252   if (info.is_directory)
 253     return base::File::FILE_ERROR_NOT_A_FILE;
 254   base::Time last_modified = info.last_modified;
 255
 256   error = NativeFileUtil::GetFileInfo(dest_path, &info);
 257   if (error != base::File::FILE_OK &&
 258       error != base::File::FILE_ERROR_NOT_FOUND)
 259     return error;
 260   if (info.is_directory)
 261     return base::File::FILE_ERROR_INVALID_OPERATION;
 262   if (error == base::File::FILE_ERROR_NOT_FOUND) {
 263     error = NativeFileUtil::GetFileInfo(dest_path.DirName(), &info);
 264     if (error != base::File::FILE_OK)
 265       return error;
 266     if (!info.is_directory)
 267       return base::File::FILE_ERROR_NOT_FOUND;
 268   }
 269
 270   switch (mode) {
 271     case COPY_NOSYNC:
 272       if (!base::CopyFile(src_path, dest_path))
 273         return base::File::FILE_ERROR_FAILED;
 274       break;
 275     case COPY_SYNC:
 276       if (!CopyFileAndSync(src_path, dest_path))
 277         return base::File::FILE_ERROR_FAILED;
 278       break;
 279     case MOVE:
 280       if (!base::Move(src_path, dest_path))
 281         return base::File::FILE_ERROR_FAILED;
 282       break;
 283   }
 284
 285   // Preserve the last modified time. Do not return error here even if
 286   // the setting is failed, because the copy itself is successfully done.
 287   if (option == FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED)
 288     base::TouchFile(dest_path, last_modified, last_modified);
 289
 290   return base::File::FILE_OK;
 291 }
 292
 293 base::File::Error NativeFileUtil::DeleteFile(const base::FilePath& path) {
 294   if (!base::PathExists(path))
 295     return base::File::FILE_ERROR_NOT_FOUND;
 296   if (base::DirectoryExists(path))
 297     return base::File::FILE_ERROR_NOT_A_FILE;
 298   if (!base::DeleteFile(path, false))
 299     return base::File::FILE_ERROR_FAILED;
 300   return base::File::FILE_OK;
 301 }
 302
 303 base::File::Error NativeFileUtil::DeleteDirectory(const base::FilePath& path) {
 304   if (!base::PathExists(path))
 305     return base::File::FILE_ERROR_NOT_FOUND;
 306   if (!base::DirectoryExists(path))
 307     return base::File::FILE_ERROR_NOT_A_DIRECTORY;
 308   if (!base::IsDirectoryEmpty(path))
 309     return base::File::FILE_ERROR_NOT_EMPTY;
 310   if (!base::DeleteFile(path, false))
 311     return base::File::FILE_ERROR_FAILED;
 312   return base::File::FILE_OK;
 313 }
 314
 315 }  // namespace storage