1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_
#define STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util_proxy.h"
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "storage/browser/blob/shareable_file_reference.h"
#include "storage/browser/fileapi/file_system_file_util.h"
#include "storage/browser/fileapi/file_system_url.h"
#include "storage/browser/fileapi/sandbox_directory_database.h"
#include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
#include "storage/browser/storage_browser_export.h"
#include "storage/common/fileapi/file_system_types.h"
namespace base {
class SequencedTaskRunner;
class TimeTicks;
}
namespace content {
class ObfuscatedFileUtilTest;
class QuotaBackendImplTest;
}
namespace storage {
class SpecialStoragePolicy;
}
class GURL;
namespace storage {
class FileSystemOperationContext;
class SandboxOriginDatabaseInterface;
class TimedTaskHelper;
// This file util stores directory information in LevelDB to obfuscate
// and to neutralize virtual file paths given by arbitrary apps.
// Files are stored with two-level isolation: per-origin and per-type.
// The isolation is done by storing data in separate directory partitions.
// For example, a file in Temporary file system for origin 'www.example.com'
// is stored in a different partition for a file in Persistent file system
// for the same origin, or for Temporary file system for another origin.
//
// * Per-origin directory name information is stored in a separate LevelDB,
// which is maintained by SandboxOriginDatabase.
// * Per-type directory name information is given by
// GetTypeStringForURLCallback that is given in CTOR.
// We use a small static mapping (e.g. 't' for Temporary type) for
// regular sandbox filesystems.
//
// The overall implementation philosophy of this class is that partial failures
// should leave us with an intact database; we'd prefer to leak the occasional
// backing file than have a database entry whose backing file is missing. When
// doing FSCK operations, if you find a loose backing file with no reference,
// you may safely delete it.
//
// This class must be deleted on the FILE thread, because that's where
// DropDatabases needs to be called.
class STORAGE_EXPORT_PRIVATE ObfuscatedFileUtil
: public FileSystemFileUtil {
public:
// Origin enumerator interface.
// An instance of this interface is assumed to be called on the file thread.
class AbstractOriginEnumerator {
public:
virtual ~AbstractOriginEnumerator() {}
// Returns the next origin. Returns empty if there are no more origins.
virtual GURL Next() = 0;
// Returns the current origin's information.
// |type_string| must be ascii string.
virtual bool HasTypeDirectory(const std::string& type_string) const = 0;
};
typedef base::Callback<std::string(const FileSystemURL&)>
GetTypeStringForURLCallback;
// |get_type_string_for_url| is user-defined callback that should return
// a type string for the given FileSystemURL. The type string is used
// to provide per-type isolation in the sandboxed filesystem directory.
// Note that this method is called on file_task_runner.
//
// |known_type_strings| are known type string names that this file system
// should care about.
// This info is used to determine whether we could delete the entire
// origin directory or not in DeleteDirectoryForOriginAndType. If no directory
// for any known type exists the origin directory may get deleted when
// one origin/type pair is deleted.
//
ObfuscatedFileUtil(storage::SpecialStoragePolicy* special_storage_policy,
const base::FilePath& file_system_directory,
leveldb::Env* env_override,
base::SequencedTaskRunner* file_task_runner,
const GetTypeStringForURLCallback& get_type_string_for_url,
const std::set<std::string>& known_type_strings,
SandboxFileSystemBackendDelegate* sandbox_delegate);
~ObfuscatedFileUtil() override;
// FileSystemFileUtil overrides.
base::File CreateOrOpen(FileSystemOperationContext* context,
const FileSystemURL& url,
int file_flags) override;
base::File::Error EnsureFileExists(FileSystemOperationContext* context,
const FileSystemURL& url,
bool* created) override;
base::File::Error CreateDirectory(FileSystemOperationContext* context,
const FileSystemURL& url,
bool exclusive,
bool recursive) override;
base::File::Error GetFileInfo(FileSystemOperationContext* context,
const FileSystemURL& url,
base::File::Info* file_info,
base::FilePath* platform_file) override;
scoped_ptr<AbstractFileEnumerator> CreateFileEnumerator(
FileSystemOperationContext* context,
const FileSystemURL& root_url) override;
base::File::Error GetLocalFilePath(FileSystemOperationContext* context,
const FileSystemURL& file_system_url,
base::FilePath* local_path) override;
base::File::Error Touch(FileSystemOperationContext* context,
const FileSystemURL& url,
const base::Time& last_access_time,
const base::Time& last_modified_time) override;
base::File::Error Truncate(FileSystemOperationContext* context,
const FileSystemURL& url,
int64 length) override;
base::File::Error CopyOrMoveFile(FileSystemOperationContext* context,
const FileSystemURL& src_url,
const FileSystemURL& dest_url,
CopyOrMoveOption option,
bool copy) override;
base::File::Error CopyInForeignFile(FileSystemOperationContext* context,
const base::FilePath& src_file_path,
const FileSystemURL& dest_url) override;
base::File::Error DeleteFile(FileSystemOperationContext* context,
const FileSystemURL& url) override;
base::File::Error DeleteDirectory(FileSystemOperationContext* context,
const FileSystemURL& url) override;
storage::ScopedFile CreateSnapshotFile(
FileSystemOperationContext* context,
const FileSystemURL& url,
base::File::Error* error,
base::File::Info* file_info,
base::FilePath* platform_path) override;
// Same as the other CreateFileEnumerator, but with recursive support.
scoped_ptr<AbstractFileEnumerator> CreateFileEnumerator(
FileSystemOperationContext* context,
const FileSystemURL& root_url,
bool recursive);
// Returns true if the directory |url| is empty.
bool IsDirectoryEmpty(
FileSystemOperationContext* context,
const FileSystemURL& url);
// Gets the topmost directory specific to this origin and type. This will
// contain both the directory database's files and all the backing file
// subdirectories.
// Returns the topmost origin directory if |type_string| is empty.
// Returns an empty path if the directory is undefined.
// If the directory is defined, it will be returned, even if
// there is a file system error (e.g. the directory doesn't exist on disk and
// |create| is false). Callers should always check |error_code| to make sure
// the returned path is usable.
base::FilePath GetDirectoryForOriginAndType(
const GURL& origin,
const std::string& type_string,
bool create,
base::File::Error* error_code);
// Deletes the topmost directory specific to this origin and type. This will
// delete its directory database.
// Deletes the topmost origin directory if |type_string| is empty.
bool DeleteDirectoryForOriginAndType(
const GURL& origin,
const std::string& type_string);
// Frees resources used by an origin's filesystem.
void CloseFileSystemForOriginAndType(const GURL& origin,
const std::string& type_string);
// This method and all methods of its returned class must be called only on
// the FILE thread. The caller is responsible for deleting the returned
// object.
AbstractOriginEnumerator* CreateOriginEnumerator();
// Deletes a directory database from the database list in the ObfuscatedFSFU
// and destroys the database on the disk.
void DestroyDirectoryDatabase(const GURL& origin,
const std::string& type_string);
// Computes a cost for storing a given file in the obfuscated FSFU.
// As the cost of a file is independent of the cost of its parent directories,
// this ignores all but the BaseName of the supplied path. In order to
// compute the cost of adding a multi-segment directory recursively, call this
// on each path segment and add the results.
static int64 ComputeFilePathCost(const base::FilePath& path);
// Tries to prepopulate directory database for the given type strings.
// This tries from the first one in the given type_strings and stops
// once it succeeds to do so for one database (i.e. it prepopulates
// at most one database).
void MaybePrepopulateDatabase(
const std::vector<std::string>& type_strings_to_prepopulate);
private:
typedef SandboxDirectoryDatabase::FileId FileId;
typedef SandboxDirectoryDatabase::FileInfo FileInfo;
friend class ObfuscatedFileEnumerator;
friend class content::ObfuscatedFileUtilTest;
friend class content::QuotaBackendImplTest;
// Helper method to create an obfuscated file util for regular
// (temporary, persistent) file systems. Used only for testing.
// Note: this is implemented in sandbox_file_system_backend_delegate.cc.
static ObfuscatedFileUtil* CreateForTesting(
storage::SpecialStoragePolicy* special_storage_policy,
const base::FilePath& file_system_directory,
leveldb::Env* env_override,
base::SequencedTaskRunner* file_task_runner);
base::FilePath GetDirectoryForURL(
const FileSystemURL& url,
bool create,
base::File::Error* error_code);
// This just calls get_type_string_for_url_ callback that is given in ctor.
std::string CallGetTypeStringForURL(const FileSystemURL& url);
base::File::Error GetFileInfoInternal(
SandboxDirectoryDatabase* db,
FileSystemOperationContext* context,
const FileSystemURL& url,
FileId file_id,
FileInfo* local_info,
base::File::Info* file_info,
base::FilePath* platform_file_path);
// Creates a new file, both the underlying backing file and the entry in the
// database. |dest_file_info| is an in-out parameter. Supply the name and
// parent_id; data_path is ignored. On success, data_path will
// always be set to the relative path [from the root of the type-specific
// filesystem directory] of a NEW backing file. Returns the new file.
base::File CreateAndOpenFile(
FileSystemOperationContext* context,
const FileSystemURL& dest_url,
FileInfo* dest_file_info,
int file_flags);
// The same as CreateAndOpenFile except that a file is not returned and if a
// path is provided in |source_path|, it will be used as a source from which
// to COPY data.
base::File::Error CreateFile(
FileSystemOperationContext* context,
const base::FilePath& source_file_path,
const FileSystemURL& dest_url,
FileInfo* dest_file_info);
// Updates |db| and |dest_file_info| at the end of creating a new file.
base::File::Error CommitCreateFile(
const base::FilePath& root,
const base::FilePath& local_path,
SandboxDirectoryDatabase* db,
FileInfo* dest_file_info);
// This converts from a relative path [as is stored in the FileInfo.data_path
// field] to an absolute platform path that can be given to the native
// filesystem.
base::FilePath DataPathToLocalPath(
const FileSystemURL& url,
const base::FilePath& data_file_path);
std::string GetDirectoryDatabaseKey(const GURL& origin,
const std::string& type_string);
// This returns NULL if |create| flag is false and a filesystem does not
// exist for the given |url|.
// For read operations |create| should be false.
SandboxDirectoryDatabase* GetDirectoryDatabase(const FileSystemURL& url,
bool create);
// Gets the topmost directory specific to this origin. This will
// contain both the filesystem type subdirectories.
base::FilePath GetDirectoryForOrigin(const GURL& origin,
bool create,
base::File::Error* error_code);
void InvalidateUsageCache(FileSystemOperationContext* context,
const GURL& origin,
FileSystemType type);
void MarkUsed();
void DropDatabases();
// Initializes the origin database. |origin_hint| may be used as a hint
// for initializing database if it's not empty.
bool InitOriginDatabase(const GURL& origin_hint, bool create);
base::File::Error GenerateNewLocalPath(
SandboxDirectoryDatabase* db,
FileSystemOperationContext* context,
const FileSystemURL& url,
base::FilePath* root,
base::FilePath* local_path);
base::File CreateOrOpenInternal(
FileSystemOperationContext* context,
const FileSystemURL& url,
int file_flags);
bool HasIsolatedStorage(const GURL& origin);
typedef std::map<std::string, SandboxDirectoryDatabase*> DirectoryMap;
DirectoryMap directories_;
scoped_ptr<SandboxOriginDatabaseInterface> origin_database_;
scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
base::FilePath file_system_directory_;
leveldb::Env* env_override_;
// Used to delete database after a certain period of inactivity.
int64 db_flush_delay_seconds_;
scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
scoped_ptr<TimedTaskHelper> timer_;
GetTypeStringForURLCallback get_type_string_for_url_;
std::set<std::string> known_type_strings_;
// Not owned.
SandboxFileSystemBackendDelegate* sandbox_delegate_;
DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
};
} // namespace storage
#endif // STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_
|