storage/common/fileapi/file_system_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/common/fileapi/file_system_util.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/logging.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/sys_string_conversions.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "net/base/escape.h"
  15 #include "net/base/net_errors.h"
  16 #include "storage/common/database/database_identifier.h"
  17 #include "url/gurl.h"
  18
  19 namespace storage {
  20
  21 const char kPersistentDir[] = "/persistent";
  22 const char kTemporaryDir[] = "/temporary";
  23 const char kIsolatedDir[] = "/isolated";
  24 const char kExternalDir[] = "/external";
  25 const char kTestDir[] = "/test";
  26
  27 const base::FilePath::CharType VirtualPath::kRoot[] = FILE_PATH_LITERAL("/");
  28 const base::FilePath::CharType VirtualPath::kSeparator = FILE_PATH_LITERAL('/');
  29
  30 // TODO(ericu): Consider removing support for '\', even on Windows, if possible.
  31 // There's a lot of test code that will need reworking, and we may have trouble
  32 // with base::FilePath elsewhere [e.g. DirName and other methods may also need
  33 // replacement].
  34 base::FilePath VirtualPath::BaseName(const base::FilePath& virtual_path) {
  35   base::FilePath::StringType path = virtual_path.value();
  36
  37   // Keep everything after the final separator, but if the pathname is only
  38   // one character and it's a separator, leave it alone.
  39   while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
  40     path.resize(path.size() - 1);
  41   base::FilePath::StringType::size_type last_separator =
  42       path.find_last_of(base::FilePath::kSeparators);
  43   if (last_separator != base::FilePath::StringType::npos &&
  44       last_separator < path.size() - 1)
  45     path.erase(0, last_separator + 1);
  46
  47   return base::FilePath(path);
  48 }
  49
  50 base::FilePath VirtualPath::DirName(const base::FilePath& virtual_path) {
  51   typedef base::FilePath::StringType StringType;
  52   StringType  path = virtual_path.value();
  53
  54   // The logic below is taken from that of base::FilePath::DirName, except
  55   // that this version never cares about '//' or drive-letters even on win32.
  56
  57   // Strip trailing separators.
  58   while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
  59     path.resize(path.size() - 1);
  60
  61   StringType::size_type last_separator =
  62       path.find_last_of(base::FilePath::kSeparators);
  63   if (last_separator == StringType::npos) {
  64     // path_ is in the current directory.
  65     return base::FilePath(base::FilePath::kCurrentDirectory);
  66   }
  67   if (last_separator == 0) {
  68     // path_ is in the root directory.
  69     return base::FilePath(path.substr(0, 1));
  70   }
  71   // path_ is somewhere else, trim the basename.
  72   path.resize(last_separator);
  73
  74   // Strip trailing separators.
  75   while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
  76     path.resize(path.size() - 1);
  77
  78   if (path.empty())
  79     return base::FilePath(base::FilePath::kCurrentDirectory);
  80
  81   return base::FilePath(path);
  82 }
  83
  84 void VirtualPath::GetComponents(
  85     const base::FilePath& path,
  86     std::vector<base::FilePath::StringType>* components) {
  87   typedef base::FilePath::StringType StringType;
  88
  89   DCHECK(components);
  90   if (!components)
  91     return;
  92   components->clear();
  93   if (path.value().empty())
  94     return;
  95
  96   StringType::size_type begin = 0, end = 0;
  97   while (begin < path.value().length() && end != StringType::npos) {
  98     end = path.value().find_first_of(base::FilePath::kSeparators, begin);
  99     StringType component = path.value().substr(
 100         begin, end == StringType::npos ? StringType::npos : end - begin);
 101     if (!component.empty() && component != base::FilePath::kCurrentDirectory)
 102       components->push_back(component);
 103     begin = end + 1;
 104   }
 105 }
 106
 107 void VirtualPath::GetComponentsUTF8Unsafe(
 108     const base::FilePath& path,
 109     std::vector<std::string>* components) {
 110   DCHECK(components);
 111   if (!components)
 112     return;
 113   components->clear();
 114
 115   std::vector<base::FilePath::StringType> stringtype_components;
 116   VirtualPath::GetComponents(path, &stringtype_components);
 117   std::vector<base::FilePath::StringType>::const_iterator it;
 118   for (it = stringtype_components.begin(); it != stringtype_components.end();
 119        ++it) {
 120     components->push_back(base::FilePath(*it).AsUTF8Unsafe());
 121   }
 122 }
 123
 124 base::FilePath::StringType VirtualPath::GetNormalizedFilePath(
 125     const base::FilePath& path) {
 126   base::FilePath::StringType normalized_path = path.value();
 127   const size_t num_separators = base::FilePath::StringType(
 128       base::FilePath::kSeparators).length();
 129   for (size_t i = 0; i < num_separators; ++i) {
 130     std::replace(normalized_path.begin(), normalized_path.end(),
 131                  base::FilePath::kSeparators[i], kSeparator);
 132   }
 133
 134   return (IsAbsolute(normalized_path)) ?
 135       normalized_path : base::FilePath::StringType(kRoot) + normalized_path;
 136 }
 137
 138 bool VirtualPath::IsAbsolute(const base::FilePath::StringType& path) {
 139   return path.find(kRoot) == 0;
 140 }
 141
 142 bool VirtualPath::IsRootPath(const base::FilePath& path) {
 143   std::vector<base::FilePath::StringType> components;
 144   VirtualPath::GetComponents(path, &components);
 145   return (path.empty() || components.empty() ||
 146           (components.size() == 1 &&
 147            components[0] == VirtualPath::kRoot));
 148 }
 149
 150 bool ParseFileSystemSchemeURL(const GURL& url,
 151                               GURL* origin_url,
 152                               FileSystemType* type,
 153                               base::FilePath* virtual_path) {
 154   GURL origin;
 155   FileSystemType file_system_type = kFileSystemTypeUnknown;
 156
 157   if (!url.is_valid() || !url.SchemeIsFileSystem())
 158     return false;
 159
 160   const struct {
 161     FileSystemType type;
 162     const char* dir;
 163   } kValidTypes[] = {
 164     { kFileSystemTypePersistent, kPersistentDir },
 165     { kFileSystemTypeTemporary, kTemporaryDir },
 166     { kFileSystemTypeIsolated, kIsolatedDir },
 167     { kFileSystemTypeExternal, kExternalDir },
 168     { kFileSystemTypeTest, kTestDir },
 169   };
 170
 171   // A path of the inner_url contains only mount type part (e.g. "/temporary").
 172   DCHECK(url.inner_url());
 173   std::string inner_path = url.inner_url()->path();
 174   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kValidTypes); ++i) {
 175     if (inner_path == kValidTypes[i].dir) {
 176       file_system_type = kValidTypes[i].type;
 177       break;
 178     }
 179   }
 180
 181   if (file_system_type == kFileSystemTypeUnknown)
 182     return false;
 183
 184   std::string path = net::UnescapeURLComponent(url.path(),
 185       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS |
 186       net::UnescapeRule::CONTROL_CHARS);
 187
 188   // Ensure the path is relative.
 189   while (!path.empty() && path[0] == '/')
 190     path.erase(0, 1);
 191
 192   base::FilePath converted_path = base::FilePath::FromUTF8Unsafe(path);
 193
 194   // All parent references should have been resolved in the renderer.
 195   if (converted_path.ReferencesParent())
 196     return false;
 197
 198   if (origin_url)
 199     *origin_url = url.GetOrigin();
 200   if (type)
 201     *type = file_system_type;
 202   if (virtual_path)
 203     *virtual_path = converted_path.NormalizePathSeparators().
 204         StripTrailingSeparators();
 205
 206   return true;
 207 }
 208
 209 GURL GetFileSystemRootURI(const GURL& origin_url, FileSystemType type) {
 210   // origin_url is based on a security origin, so http://foo.com or file:///
 211   // instead of the corresponding filesystem URL.
 212   DCHECK(!origin_url.SchemeIsFileSystem());
 213
 214   std::string url = "filesystem:" + origin_url.GetWithEmptyPath().spec();
 215   switch (type) {
 216     case kFileSystemTypeTemporary:
 217       url += (kTemporaryDir + 1);  // We don't want the leading slash.
 218       return GURL(url + "/");
 219     case kFileSystemTypePersistent:
 220       url += (kPersistentDir + 1);  // We don't want the leading slash.
 221       return GURL(url + "/");
 222     case kFileSystemTypeExternal:
 223       url += (kExternalDir + 1);  // We don't want the leading slash.
 224       return GURL(url + "/");
 225     case kFileSystemTypeIsolated:
 226       url += (kIsolatedDir + 1);  // We don't want the leading slash.
 227       return GURL(url + "/");
 228     case kFileSystemTypeTest:
 229       url += (kTestDir + 1);  // We don't want the leading slash.
 230       return GURL(url + "/");
 231       // Internal types are always pointed via isolated or external URLs.
 232     default:
 233       NOTREACHED();
 234   }
 235   NOTREACHED();
 236   return GURL();
 237 }
 238
 239 std::string GetFileSystemName(const GURL& origin_url, FileSystemType type) {
 240   std::string origin_identifier = storage::GetIdentifierFromOrigin(origin_url);
 241   std::string type_string = GetFileSystemTypeString(type);
 242   DCHECK(!type_string.empty());
 243   return origin_identifier + ":" + type_string;
 244 }
 245
 246 FileSystemType QuotaStorageTypeToFileSystemType(
 247     storage::StorageType storage_type) {
 248   switch (storage_type) {
 249     case storage::kStorageTypeTemporary:
 250       return kFileSystemTypeTemporary;
 251     case storage::kStorageTypePersistent:
 252       return kFileSystemTypePersistent;
 253     case storage::kStorageTypeSyncable:
 254       return kFileSystemTypeSyncable;
 255     case storage::kStorageTypeQuotaNotManaged:
 256     case storage::kStorageTypeUnknown:
 257       return kFileSystemTypeUnknown;
 258   }
 259   return kFileSystemTypeUnknown;
 260 }
 261
 262 storage::StorageType FileSystemTypeToQuotaStorageType(FileSystemType type) {
 263   switch (type) {
 264     case kFileSystemTypeTemporary:
 265       return storage::kStorageTypeTemporary;
 266     case kFileSystemTypePersistent:
 267       return storage::kStorageTypePersistent;
 268     case kFileSystemTypeSyncable:
 269     case kFileSystemTypeSyncableForInternalSync:
 270       return storage::kStorageTypeSyncable;
 271     case kFileSystemTypePluginPrivate:
 272       return storage::kStorageTypeQuotaNotManaged;
 273     default:
 274       return storage::kStorageTypeUnknown;
 275   }
 276 }
 277
 278 std::string GetFileSystemTypeString(FileSystemType type) {
 279   switch (type) {
 280     case kFileSystemTypeTemporary:
 281       return "Temporary";
 282     case kFileSystemTypePersistent:
 283       return "Persistent";
 284     case kFileSystemTypeIsolated:
 285       return "Isolated";
 286     case kFileSystemTypeExternal:
 287       return "External";
 288     case kFileSystemTypeTest:
 289       return "Test";
 290     case kFileSystemTypeNativeLocal:
 291       return "NativeLocal";
 292     case kFileSystemTypeRestrictedNativeLocal:
 293       return "RestrictedNativeLocal";
 294     case kFileSystemTypeDragged:
 295       return "Dragged";
 296     case kFileSystemTypeNativeMedia:
 297       return "NativeMedia";
 298     case kFileSystemTypeDeviceMedia:
 299       return "DeviceMedia";
 300     case kFileSystemTypePicasa:
 301       return "Picasa";
 302     case kFileSystemTypeItunes:
 303       return "Itunes";
 304     case kFileSystemTypeIphoto:
 305       return "Iphoto";
 306     case kFileSystemTypeDrive:
 307       return "Drive";
 308     case kFileSystemTypeSyncable:
 309     case kFileSystemTypeSyncableForInternalSync:
 310       return "Syncable";
 311     case kFileSystemTypeNativeForPlatformApp:
 312       return "NativeForPlatformApp";
 313     case kFileSystemTypeForTransientFile:
 314       return "TransientFile";
 315     case kFileSystemTypePluginPrivate:
 316       return "PluginPrivate";
 317     case kFileSystemTypeCloudDevice:
 318       return "CloudDevice";
 319     case kFileSystemTypeProvided:
 320       return "Provided";
 321     case kFileSystemTypeDeviceMediaAsFileStorage:
 322       return "DeviceMediaStorage";
 323     case kFileSystemInternalTypeEnumStart:
 324     case kFileSystemInternalTypeEnumEnd:
 325       NOTREACHED();
 326       // Fall through.
 327     case kFileSystemTypeUnknown:
 328       return "Unknown";
 329   }
 330   NOTREACHED();
 331   return std::string();
 332 }
 333
 334 std::string FilePathToString(const base::FilePath& file_path) {
 335 #if defined(OS_WIN)
 336   return base::UTF16ToUTF8(file_path.value());
 337 #elif defined(OS_POSIX)
 338   return file_path.value();
 339 #endif
 340 }
 341
 342 base::FilePath StringToFilePath(const std::string& file_path_string) {
 343 #if defined(OS_WIN)
 344   return base::FilePath(base::UTF8ToUTF16(file_path_string));
 345 #elif defined(OS_POSIX)
 346   return base::FilePath(file_path_string);
 347 #endif
 348 }
 349
 350 blink::WebFileError FileErrorToWebFileError(
 351     base::File::Error error_code) {
 352   switch (error_code) {
 353     case base::File::FILE_ERROR_NOT_FOUND:
 354       return blink::WebFileErrorNotFound;
 355     case base::File::FILE_ERROR_INVALID_OPERATION:
 356     case base::File::FILE_ERROR_EXISTS:
 357     case base::File::FILE_ERROR_NOT_EMPTY:
 358       return blink::WebFileErrorInvalidModification;
 359     case base::File::FILE_ERROR_NOT_A_DIRECTORY:
 360     case base::File::FILE_ERROR_NOT_A_FILE:
 361       return blink::WebFileErrorTypeMismatch;
 362     case base::File::FILE_ERROR_ACCESS_DENIED:
 363       return blink::WebFileErrorNoModificationAllowed;
 364     case base::File::FILE_ERROR_FAILED:
 365       return blink::WebFileErrorInvalidState;
 366     case base::File::FILE_ERROR_ABORT:
 367       return blink::WebFileErrorAbort;
 368     case base::File::FILE_ERROR_SECURITY:
 369       return blink::WebFileErrorSecurity;
 370     case base::File::FILE_ERROR_NO_SPACE:
 371       return blink::WebFileErrorQuotaExceeded;
 372     case base::File::FILE_ERROR_INVALID_URL:
 373       return blink::WebFileErrorEncoding;
 374     default:
 375       return blink::WebFileErrorInvalidModification;
 376   }
 377 }
 378
 379 bool GetFileSystemPublicType(
 380     const std::string type_string,
 381     blink::WebFileSystemType* type) {
 382   DCHECK(type);
 383   if (type_string == "Temporary") {
 384     *type = blink::WebFileSystemTypeTemporary;
 385     return true;
 386   }
 387   if (type_string == "Persistent") {
 388     *type = blink::WebFileSystemTypePersistent;
 389     return true;
 390   }
 391   if (type_string == "Isolated") {
 392     *type = blink::WebFileSystemTypeIsolated;
 393     return true;
 394   }
 395   if (type_string == "External") {
 396     *type = blink::WebFileSystemTypeExternal;
 397     return true;
 398   }
 399   NOTREACHED();
 400   return false;
 401 }
 402
 403 std::string GetIsolatedFileSystemName(const GURL& origin_url,
 404                                       const std::string& filesystem_id) {
 405   std::string name(
 406       storage::GetFileSystemName(origin_url, storage::kFileSystemTypeIsolated));
 407   name.append("_");
 408   name.append(filesystem_id);
 409   return name;
 410 }
 411
 412 bool CrackIsolatedFileSystemName(const std::string& filesystem_name,
 413                                  std::string* filesystem_id) {
 414   DCHECK(filesystem_id);
 415
 416   // |filesystem_name| is of the form {origin}:isolated_{filesystem_id}.
 417   std::string start_token(":");
 418   start_token = start_token.append(
 419       GetFileSystemTypeString(kFileSystemTypeIsolated)).append("_");
 420   // WebKit uses different case in its constant for isolated file system
 421   // names, so we do a case insensitive compare by converting both strings
 422   // to uppercase.
 423   // TODO(benwells): Remove this when WebKit uses the same constant.
 424   start_token = StringToUpperASCII(start_token);
 425   std::string filesystem_name_upper = StringToUpperASCII(filesystem_name);
 426   size_t pos = filesystem_name_upper.find(start_token);
 427   if (pos == std::string::npos)
 428     return false;
 429   if (pos == 0)
 430     return false;
 431
 432   *filesystem_id = filesystem_name.substr(pos + start_token.length(),
 433                                           std::string::npos);
 434   if (filesystem_id->empty())
 435     return false;
 436
 437   return true;
 438 }
 439
 440 bool ValidateIsolatedFileSystemId(const std::string& filesystem_id) {
 441   const size_t kExpectedFileSystemIdSize = 32;
 442   if (filesystem_id.size() != kExpectedFileSystemIdSize)
 443     return false;
 444   const std::string kExpectedChars("ABCDEF0123456789");
 445   return base::ContainsOnlyChars(filesystem_id, kExpectedChars);
 446 }
 447
 448 std::string GetIsolatedFileSystemRootURIString(
 449     const GURL& origin_url,
 450     const std::string& filesystem_id,
 451     const std::string& optional_root_name) {
 452   std::string root = GetFileSystemRootURI(origin_url,
 453                                           kFileSystemTypeIsolated).spec();
 454   if (base::FilePath::FromUTF8Unsafe(filesystem_id).ReferencesParent())
 455     return std::string();
 456   root.append(net::EscapePath(filesystem_id));
 457   root.append("/");
 458   if (!optional_root_name.empty()) {
 459     if (base::FilePath::FromUTF8Unsafe(optional_root_name).ReferencesParent())
 460       return std::string();
 461     root.append(net::EscapePath(optional_root_name));
 462     root.append("/");
 463   }
 464   return root;
 465 }
 466
 467 std::string GetExternalFileSystemRootURIString(
 468     const GURL& origin_url,
 469     const std::string& mount_name) {
 470   std::string root = GetFileSystemRootURI(origin_url,
 471                                           kFileSystemTypeExternal).spec();
 472   if (base::FilePath::FromUTF8Unsafe(mount_name).ReferencesParent())
 473     return std::string();
 474   root.append(net::EscapePath(mount_name));
 475   root.append("/");
 476   return root;
 477 }
 478
 479 base::File::Error NetErrorToFileError(int error) {
 480   switch (error) {
 481     case net::OK:
 482       return base::File::FILE_OK;
 483     case net::ERR_ADDRESS_IN_USE:
 484       return base::File::FILE_ERROR_IN_USE;
 485     case net::ERR_FILE_EXISTS:
 486       return base::File::FILE_ERROR_EXISTS;
 487     case net::ERR_FILE_NOT_FOUND:
 488       return base::File::FILE_ERROR_NOT_FOUND;
 489     case net::ERR_ACCESS_DENIED:
 490       return base::File::FILE_ERROR_ACCESS_DENIED;
 491     case net::ERR_TOO_MANY_SOCKET_STREAMS:
 492       return base::File::FILE_ERROR_TOO_MANY_OPENED;
 493     case net::ERR_OUT_OF_MEMORY:
 494       return base::File::FILE_ERROR_NO_MEMORY;
 495     case net::ERR_FILE_NO_SPACE:
 496       return base::File::FILE_ERROR_NO_SPACE;
 497     case net::ERR_INVALID_ARGUMENT:
 498     case net::ERR_INVALID_HANDLE:
 499       return base::File::FILE_ERROR_INVALID_OPERATION;
 500     case net::ERR_ABORTED:
 501     case net::ERR_CONNECTION_ABORTED:
 502       return base::File::FILE_ERROR_ABORT;
 503     case net::ERR_ADDRESS_INVALID:
 504     case net::ERR_INVALID_URL:
 505       return base::File::FILE_ERROR_INVALID_URL;
 506     default:
 507       return base::File::FILE_ERROR_FAILED;
 508   }
 509 }
 510
 511 }  // namespace storage