src/webkit/browser/fileapi/external_mount_points.cc

   1 // Copyright (c) 2013 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 "webkit/browser/fileapi/external_mount_points.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/path_service.h"
  10 #include "base/stl_util.h"
  11 #include "webkit/browser/fileapi/file_system_url.h"
  12
  13 namespace {
  14
  15 // Normalizes file path so it has normalized separators and ends with exactly
  16 // one separator. Paths have to be normalized this way for use in
  17 // GetVirtualPath method. Separators cannot be completely stripped, or
  18 // GetVirtualPath could not working in some edge cases.
  19 // For example, /a/b/c(1)/d would be erroneously resolved as c/d if the
  20 // following mount points were registered: "/a/b/c", "/a/b/c(1)". (Note:
  21 // "/a/b/c" < "/a/b/c(1)" < "/a/b/c/").
  22 base::FilePath NormalizeFilePath(const base::FilePath& path) {
  23   if (path.empty())
  24     return path;
  25
  26   base::FilePath::StringType path_str = path.StripTrailingSeparators().value();
  27   if (!base::FilePath::IsSeparator(path_str[path_str.length() - 1]))
  28     path_str.append(FILE_PATH_LITERAL("/"));
  29
  30   return base::FilePath(path_str).NormalizePathSeparators();
  31 }
  32
  33 // Wrapper around ref-counted ExternalMountPoints that will be used to lazily
  34 // create and initialize LazyInstance system ExternalMountPoints.
  35 class SystemMountPointsLazyWrapper {
  36  public:
  37   SystemMountPointsLazyWrapper()
  38       : system_mount_points_(fileapi::ExternalMountPoints::CreateRefCounted()) {
  39   }
  40
  41   ~SystemMountPointsLazyWrapper() {}
  42
  43   fileapi::ExternalMountPoints* get() {
  44     return system_mount_points_.get();
  45   }
  46
  47  private:
  48   scoped_refptr<fileapi::ExternalMountPoints> system_mount_points_;
  49 };
  50
  51 base::LazyInstance<SystemMountPointsLazyWrapper>::Leaky
  52     g_external_mount_points = LAZY_INSTANCE_INITIALIZER;
  53
  54 }  // namespace
  55
  56 namespace fileapi {
  57
  58 class ExternalMountPoints::Instance {
  59  public:
  60   Instance(FileSystemType type,
  61            const base::FilePath& path,
  62            const FileSystemMountOption& mount_option)
  63       : type_(type),
  64         path_(path.StripTrailingSeparators()),
  65         mount_option_(mount_option) {}
  66   ~Instance() {}
  67
  68   FileSystemType type() const { return type_; }
  69   const base::FilePath& path() const { return path_; }
  70   const FileSystemMountOption& mount_option() const { return mount_option_; }
  71
  72  private:
  73   const FileSystemType type_;
  74   const base::FilePath path_;
  75   const FileSystemMountOption mount_option_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(Instance);
  78 };
  79
  80 //--------------------------------------------------------------------------
  81
  82 // static
  83 ExternalMountPoints* ExternalMountPoints::GetSystemInstance() {
  84   return g_external_mount_points.Pointer()->get();
  85 }
  86
  87 // static
  88 scoped_refptr<ExternalMountPoints> ExternalMountPoints::CreateRefCounted() {
  89   return new ExternalMountPoints();
  90 }
  91
  92 bool ExternalMountPoints::RegisterFileSystem(
  93     const std::string& mount_name,
  94     FileSystemType type,
  95     const FileSystemMountOption& mount_option,
  96     const base::FilePath& path_in) {
  97   // COPY_SYNC_OPTION_SYNC is only applicable to native local file system.
  98   DCHECK(type == kFileSystemTypeNativeLocal ||
  99          mount_option.copy_sync_option() != COPY_SYNC_OPTION_SYNC);
 100
 101   base::AutoLock locker(lock_);
 102
 103   base::FilePath path = NormalizeFilePath(path_in);
 104   if (!ValidateNewMountPoint(mount_name, path))
 105     return false;
 106
 107   instance_map_[mount_name] = new Instance(type, path, mount_option);
 108   if (!path.empty())
 109     path_to_name_map_.insert(std::make_pair(path, mount_name));
 110   return true;
 111 }
 112
 113 bool ExternalMountPoints::HandlesFileSystemMountType(
 114     FileSystemType type) const {
 115   return type == kFileSystemTypeExternal ||
 116          type == kFileSystemTypeNativeForPlatformApp;
 117 }
 118
 119 bool ExternalMountPoints::RevokeFileSystem(const std::string& mount_name) {
 120   base::AutoLock locker(lock_);
 121   NameToInstance::iterator found = instance_map_.find(mount_name);
 122   if (found == instance_map_.end())
 123     return false;
 124   Instance* instance = found->second;
 125   path_to_name_map_.erase(NormalizeFilePath(instance->path()));
 126   delete found->second;
 127   instance_map_.erase(found);
 128   return true;
 129 }
 130
 131 bool ExternalMountPoints::GetRegisteredPath(
 132     const std::string& filesystem_id, base::FilePath* path) const {
 133   DCHECK(path);
 134   base::AutoLock locker(lock_);
 135   NameToInstance::const_iterator found = instance_map_.find(filesystem_id);
 136   if (found == instance_map_.end())
 137     return false;
 138   *path = found->second->path();
 139   return true;
 140 }
 141
 142 bool ExternalMountPoints::CrackVirtualPath(
 143     const base::FilePath& virtual_path,
 144     std::string* mount_name,
 145     FileSystemType* type,
 146     base::FilePath* path,
 147     FileSystemMountOption* mount_option) const {
 148   DCHECK(mount_name);
 149   DCHECK(path);
 150
 151   // The path should not contain any '..' references.
 152   if (virtual_path.ReferencesParent())
 153     return false;
 154
 155   // The virtual_path should comprise of <mount_name> and <relative_path> parts.
 156   std::vector<base::FilePath::StringType> components;
 157   virtual_path.GetComponents(&components);
 158   if (components.size() < 1)
 159     return false;
 160
 161   std::vector<base::FilePath::StringType>::iterator component_iter =
 162       components.begin();
 163   std::string maybe_mount_name =
 164       base::FilePath(*component_iter++).MaybeAsASCII();
 165   if (maybe_mount_name.empty())
 166     return false;
 167
 168   base::FilePath cracked_path;
 169   {
 170     base::AutoLock locker(lock_);
 171     NameToInstance::const_iterator found_instance =
 172         instance_map_.find(maybe_mount_name);
 173     if (found_instance == instance_map_.end())
 174       return false;
 175
 176     *mount_name = maybe_mount_name;
 177     const Instance* instance = found_instance->second;
 178     if (type)
 179       *type = instance->type();
 180     cracked_path = instance->path();
 181     *mount_option = instance->mount_option();
 182   }
 183
 184   for (; component_iter != components.end(); ++component_iter)
 185     cracked_path = cracked_path.Append(*component_iter);
 186   *path = cracked_path;
 187   return true;
 188 }
 189
 190 FileSystemURL ExternalMountPoints::CrackURL(const GURL& url) const {
 191   FileSystemURL filesystem_url = FileSystemURL(url);
 192   if (!filesystem_url.is_valid())
 193     return FileSystemURL();
 194   return CrackFileSystemURL(filesystem_url);
 195 }
 196
 197 FileSystemURL ExternalMountPoints::CreateCrackedFileSystemURL(
 198     const GURL& origin,
 199     FileSystemType type,
 200     const base::FilePath& path) const {
 201   return CrackFileSystemURL(FileSystemURL(origin, type, path));
 202 }
 203
 204 void ExternalMountPoints::AddMountPointInfosTo(
 205     std::vector<MountPointInfo>* mount_points) const {
 206   base::AutoLock locker(lock_);
 207   DCHECK(mount_points);
 208   for (NameToInstance::const_iterator iter = instance_map_.begin();
 209        iter != instance_map_.end(); ++iter) {
 210     mount_points->push_back(MountPointInfo(iter->first, iter->second->path()));
 211   }
 212 }
 213
 214 bool ExternalMountPoints::GetVirtualPath(const base::FilePath& path_in,
 215                                          base::FilePath* virtual_path) const {
 216   DCHECK(virtual_path);
 217
 218   base::AutoLock locker(lock_);
 219
 220   base::FilePath path = NormalizeFilePath(path_in);
 221   std::map<base::FilePath, std::string>::const_reverse_iterator iter(
 222       path_to_name_map_.upper_bound(path));
 223   if (iter == path_to_name_map_.rend())
 224     return false;
 225
 226   *virtual_path = CreateVirtualRootPath(iter->second);
 227   if (iter->first == path)
 228     return true;
 229   return iter->first.AppendRelativePath(path, virtual_path);
 230 }
 231
 232 base::FilePath ExternalMountPoints::CreateVirtualRootPath(
 233     const std::string& mount_name) const {
 234   return base::FilePath().AppendASCII(mount_name);
 235 }
 236
 237 FileSystemURL ExternalMountPoints::CreateExternalFileSystemURL(
 238     const GURL& origin,
 239     const std::string& mount_name,
 240     const base::FilePath& path) const {
 241   return CreateCrackedFileSystemURL(
 242       origin,
 243       fileapi::kFileSystemTypeExternal,
 244       // Avoid using FilePath::Append as path may be an absolute path.
 245       base::FilePath(
 246           CreateVirtualRootPath(mount_name).value() +
 247           base::FilePath::kSeparators[0] + path.value()));
 248 }
 249
 250 void ExternalMountPoints::RevokeAllFileSystems() {
 251   NameToInstance instance_map_copy;
 252   {
 253     base::AutoLock locker(lock_);
 254     instance_map_copy = instance_map_;
 255     instance_map_.clear();
 256     path_to_name_map_.clear();
 257   }
 258   STLDeleteContainerPairSecondPointers(instance_map_copy.begin(),
 259                                        instance_map_copy.end());
 260 }
 261
 262 ExternalMountPoints::ExternalMountPoints() {}
 263
 264 ExternalMountPoints::~ExternalMountPoints() {
 265   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
 266                                        instance_map_.end());
 267 }
 268
 269 FileSystemURL ExternalMountPoints::CrackFileSystemURL(
 270     const FileSystemURL& url) const {
 271   if (!HandlesFileSystemMountType(url.type()))
 272     return FileSystemURL();
 273
 274   base::FilePath virtual_path = url.path();
 275   if (url.type() == kFileSystemTypeNativeForPlatformApp) {
 276 #if defined(OS_CHROMEOS)
 277     // On Chrome OS, find a mount point and virtual path for the external fs.
 278     if (!GetVirtualPath(url.path(), &virtual_path))
 279       return FileSystemURL();
 280 #else
 281     // On other OS, it is simply a native local path.
 282     return FileSystemURL(
 283         url.origin(), url.mount_type(), url.virtual_path(),
 284         url.mount_filesystem_id(), kFileSystemTypeNativeLocal,
 285         url.path(), url.filesystem_id(), url.mount_option());
 286 #endif
 287   }
 288
 289   std::string mount_name;
 290   FileSystemType cracked_type;
 291   base::FilePath cracked_path;
 292   FileSystemMountOption cracked_mount_option;
 293
 294   if (!CrackVirtualPath(virtual_path, &mount_name, &cracked_type,
 295                         &cracked_path, &cracked_mount_option)) {
 296     return FileSystemURL();
 297   }
 298
 299   return FileSystemURL(
 300       url.origin(), url.mount_type(), url.virtual_path(),
 301       !url.filesystem_id().empty() ? url.filesystem_id() : mount_name,
 302       cracked_type, cracked_path, mount_name, cracked_mount_option);
 303 }
 304
 305 bool ExternalMountPoints::ValidateNewMountPoint(const std::string& mount_name,
 306                                                 const base::FilePath& path) {
 307   lock_.AssertAcquired();
 308
 309   // Mount name must not be empty.
 310   if (mount_name.empty())
 311     return false;
 312
 313   // Verify there is no registered mount point with the same name.
 314   NameToInstance::iterator found = instance_map_.find(mount_name);
 315   if (found != instance_map_.end())
 316     return false;
 317
 318   // Allow empty paths.
 319   if (path.empty())
 320     return true;
 321
 322   // Verify path is legal.
 323   if (path.ReferencesParent() || !path.IsAbsolute())
 324     return false;
 325
 326   // Check there the new path does not overlap with one of the existing ones.
 327   std::map<base::FilePath, std::string>::reverse_iterator potential_parent(
 328       path_to_name_map_.upper_bound(path));
 329   if (potential_parent != path_to_name_map_.rend()) {
 330     if (potential_parent->first == path ||
 331         potential_parent->first.IsParent(path)) {
 332       return false;
 333     }
 334   }
 335
 336   std::map<base::FilePath, std::string>::iterator potential_child =
 337       path_to_name_map_.upper_bound(path);
 338   if (potential_child == path_to_name_map_.end())
 339     return true;
 340   return !(potential_child->first == path) &&
 341          !path.IsParent(potential_child->first);
 342 }
 343
 344 }  // namespace fileapi