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
19namespace storage {
20
21const char kPersistentDir[] = "/persistent";
22const char kTemporaryDir[] = "/temporary";
23const char kIsolatedDir[] = "/isolated";
24const char kExternalDir[] = "/external";
25const char kTestDir[] = "/test";
26
27const base::FilePath::CharType VirtualPath::kRoot[] = FILE_PATH_LITERAL("/");
28const 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].
34base::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
50base::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
84void 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
107void 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
124base::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
138bool VirtualPath::IsAbsolute(const base::FilePath::StringType& path) {
139  return path.find(kRoot) == 0;
140}
141
142bool 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
150bool 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
209GURL 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
239std::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
246FileSystemType 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
262storage::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
278std::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
334std::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
342base::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
350blink::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
379bool 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
403std::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
412bool 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
440bool 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
448std::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
467std::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
479base::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
512