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