| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifdef UNSAFE_BUFFERS_BUILD |
| // TODO(crbug.com/40285824): Remove this and convert code to safer constructs. |
| #pragma allow_unsafe_buffers |
| #endif |
| |
| #include "chrome/browser/ash/fileapi/file_system_backend.h" |
| |
| #include <stddef.h> |
| |
| #include <set> |
| |
| #include "base/files/file_path.h" |
| #include "chrome/browser/ash/fileapi/file_system_backend_delegate.h" |
| #include "chromeos/ash/components/dbus/cros_disks/cros_disks_client.h" |
| #include "extensions/common/constants.h" |
| #include "extensions/common/extension.h" |
| #include "storage/browser/file_system/external_mount_points.h" |
| #include "storage/browser/file_system/file_system_operation.h" |
| #include "storage/browser/file_system/file_system_url.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/common/storage_key/storage_key.h" |
| #include "url/origin.h" |
| |
| #define FPL(x) FILE_PATH_LITERAL(x) |
| |
| using storage::ExternalMountPoints; |
| using storage::FileSystemURL; |
| |
| namespace { |
| |
| FileSystemURL CreateFileSystemURL(const std::string& extension, |
| const char* path, |
| ExternalMountPoints* mount_points) { |
| return mount_points->CreateCrackedFileSystemURL( |
| blink::StorageKey::CreateFromStringForTesting("chrome-extension://" + |
| extension + "/"), |
| storage::kFileSystemTypeExternal, base::FilePath::FromUTF8Unsafe(path)); |
| } |
| |
| TEST(ChromeOSFileSystemBackendTest, DefaultMountPoints) { |
| // Make sure no system-level mount points are registered before testing |
| // to avoid flakiness. |
| storage::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems(); |
| |
| scoped_refptr<storage::ExternalMountPoints> mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| ash::FileSystemBackend backend( |
| nullptr, // profile |
| nullptr, // file_system_provider_delegate |
| nullptr, // mtp_delegate |
| nullptr, // arc_content_delegate |
| nullptr, // arc_documents_provider_delegate |
| nullptr, // drivefs_delegate |
| nullptr, // smbfs_delegate |
| mount_points.get(), storage::ExternalMountPoints::GetSystemInstance()); |
| backend.AddSystemMountPoints(); |
| std::vector<base::FilePath> root_dirs = backend.GetRootDirectories(); |
| std::set<base::FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end()); |
| |
| // By default there should be 3 mount points (in system mount points): |
| EXPECT_EQ(2u, root_dirs.size()); |
| |
| EXPECT_TRUE( |
| root_dirs_set.count(ash::CrosDisksClient::GetRemovableDiskMountPoint())); |
| EXPECT_TRUE( |
| root_dirs_set.count(ash::CrosDisksClient::GetArchiveMountPoint())); |
| } |
| |
| TEST(ChromeOSFileSystemBackendTest, GetRootDirectories) { |
| scoped_refptr<storage::ExternalMountPoints> mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| |
| scoped_refptr<storage::ExternalMountPoints> system_mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| |
| ash::FileSystemBackend backend(nullptr, // profile |
| nullptr, // file_system_provider_delegate |
| nullptr, // mtp_delegate |
| nullptr, // arc_content_delegate |
| nullptr, // arc_documents_provider_delegate |
| nullptr, // drivefs_delegate |
| nullptr, // smbfs_delegate |
| mount_points.get(), system_mount_points.get()); |
| |
| const size_t initial_root_dirs_size = backend.GetRootDirectories().size(); |
| |
| // Register 'local' test mount points. |
| mount_points->RegisterFileSystem("c", storage::kFileSystemTypeLocal, |
| storage::FileSystemMountOption(), |
| base::FilePath(FPL("/a/b/c"))); |
| mount_points->RegisterFileSystem("d", storage::kFileSystemTypeLocal, |
| storage::FileSystemMountOption(), |
| base::FilePath(FPL("/b/c/d"))); |
| |
| // Register system test mount points. |
| system_mount_points->RegisterFileSystem("d", storage::kFileSystemTypeLocal, |
| storage::FileSystemMountOption(), |
| base::FilePath(FPL("/g/c/d"))); |
| system_mount_points->RegisterFileSystem("e", storage::kFileSystemTypeLocal, |
| storage::FileSystemMountOption(), |
| base::FilePath(FPL("/g/d/e"))); |
| |
| std::vector<base::FilePath> root_dirs = backend.GetRootDirectories(); |
| std::set<base::FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end()); |
| EXPECT_EQ(initial_root_dirs_size + 4, root_dirs.size()); |
| EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/a/b/c")))); |
| EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/b/c/d")))); |
| EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/g/c/d")))); |
| EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/g/d/e")))); |
| } |
| |
| TEST(ChromeOSFileSystemBackendTest, AccessPermissions) { |
| scoped_refptr<storage::ExternalMountPoints> mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| scoped_refptr<storage::ExternalMountPoints> system_mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| ash::FileSystemBackend backend(nullptr, // profile |
| nullptr, // file_system_provider_delegate |
| nullptr, // mtp_delegate |
| nullptr, // arc_content_delegate |
| nullptr, // arc_documents_provider_delegate |
| nullptr, // drivefs_delegate |
| nullptr, // smbfs_delegate |
| mount_points.get(), system_mount_points.get()); |
| |
| std::string extension("ddammdhioacbehjngdmkjcjbnfginlla"); |
| url::Origin origin = url::Origin::Create( |
| extensions::Extension::GetBaseURLFromExtensionId(extension)); |
| |
| // Initialize mount points. |
| ASSERT_TRUE(system_mount_points->RegisterFileSystem( |
| "system", storage::kFileSystemTypeLocal, storage::FileSystemMountOption(), |
| base::FilePath(FPL("/g/system")))); |
| ASSERT_TRUE(mount_points->RegisterFileSystem( |
| "removable", storage::kFileSystemTypeLocal, |
| storage::FileSystemMountOption(), |
| base::FilePath(FPL("/media/removable")))); |
| |
| // Backend specific mount point access. |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "removable/foo", mount_points.get()))); |
| |
| backend.GrantFileAccessToOrigin(origin, base::FilePath(FPL("removable/foo"))); |
| EXPECT_TRUE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "removable/foo", mount_points.get()))); |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "removable/foo1", mount_points.get()))); |
| |
| // System mount point access. |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "system/foo", system_mount_points.get()))); |
| |
| backend.GrantFileAccessToOrigin(origin, base::FilePath(FPL("system/foo"))); |
| EXPECT_TRUE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "system/foo", system_mount_points.get()))); |
| EXPECT_FALSE( |
| backend.IsAccessAllowed(ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "system/foo1", |
| system_mount_points.get()))); |
| |
| // The extension cannot access new mount points. |
| // TODO(tbarzic): This should probably be changed. |
| ASSERT_TRUE(mount_points->RegisterFileSystem( |
| "test", storage::kFileSystemTypeLocal, storage::FileSystemMountOption(), |
| base::FilePath(FPL("/foo/test")))); |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "test_/foo", mount_points.get()))); |
| |
| backend.RevokeAccessForOrigin(origin); |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(extension, "removable/foo", mount_points.get()))); |
| |
| // ImageLoader has access to all files GetMetadata(), GetFileStreamReader(). |
| std::string image_loader("pmfjbimdmchhbnneeidfognadeopoehp"); |
| EXPECT_TRUE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kGetMetadata, |
| CreateFileSystemURL(image_loader, "removable/foo", mount_points.get()))); |
| EXPECT_TRUE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileStreamReader, |
| storage::OperationType::kNone, |
| CreateFileSystemURL(image_loader, "removable/foo", mount_points.get()))); |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileSystemOperation, |
| storage::OperationType::kCopy, |
| CreateFileSystemURL(image_loader, "removable/foo", mount_points.get()))); |
| EXPECT_FALSE(backend.IsAccessAllowed( |
| ash::BackendFunction::kCreateFileStreamWriter, |
| storage::OperationType::kNone, |
| CreateFileSystemURL(image_loader, "removable/foo", mount_points.get()))); |
| } |
| |
| TEST(ChromeOSFileSystemBackendTest, GetVirtualPathConflictWithSystemPoints) { |
| scoped_refptr<storage::ExternalMountPoints> mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| scoped_refptr<storage::ExternalMountPoints> system_mount_points( |
| storage::ExternalMountPoints::CreateRefCounted()); |
| ash::FileSystemBackend backend(nullptr, // profile |
| nullptr, // file_system_provider_delegate |
| nullptr, // mtp_delegate |
| nullptr, // arc_content_delegate |
| nullptr, // arc_documents_provider_delegate |
| nullptr, // drivefs_delegate |
| nullptr, // smbfs_delegate |
| mount_points.get(), system_mount_points.get()); |
| |
| const storage::FileSystemType type = storage::kFileSystemTypeLocal; |
| const storage::FileSystemMountOption option = |
| storage::FileSystemMountOption(); |
| |
| // Backend specific mount points. |
| ASSERT_TRUE(mount_points->RegisterFileSystem( |
| "b", type, option, base::FilePath(FPL("/a/b")))); |
| ASSERT_TRUE(mount_points->RegisterFileSystem( |
| "y", type, option, base::FilePath(FPL("/z/y")))); |
| ASSERT_TRUE(mount_points->RegisterFileSystem( |
| "n", type, option, base::FilePath(FPL("/m/n")))); |
| |
| // System mount points |
| ASSERT_TRUE(system_mount_points->RegisterFileSystem( |
| "gb", type, option, base::FilePath(FPL("/a/b")))); |
| ASSERT_TRUE( |
| system_mount_points->RegisterFileSystem( |
| "gz", type, option, base::FilePath(FPL("/z")))); |
| ASSERT_TRUE(system_mount_points->RegisterFileSystem( |
| "gp", type, option, base::FilePath(FPL("/m/n/o/p")))); |
| |
| struct TestCase { |
| const base::FilePath::CharType* const local_path; |
| bool success; |
| const base::FilePath::CharType* const virtual_path; |
| }; |
| |
| const TestCase kTestCases[] = { |
| // Same paths in both mount points. |
| { FPL("/a/b/c/d"), true, FPL("b/c/d") }, |
| // System mount points path more specific. |
| { FPL("/m/n/o/p/r/s"), true, FPL("n/o/p/r/s") }, |
| // System mount points path less specific. |
| { FPL("/z/y/x"), true, FPL("y/x") }, |
| // Only system mount points path matches. |
| { FPL("/z/q/r/s"), true, FPL("gz/q/r/s") }, |
| // No match. |
| { FPL("/foo/xxx"), false, FPL("") }, |
| }; |
| |
| for (size_t i = 0; i < std::size(kTestCases); ++i) { |
| // Initialize virtual path with a value. |
| base::FilePath virtual_path(FPL("/mount")); |
| base::FilePath local_path(kTestCases[i].local_path); |
| EXPECT_EQ(kTestCases[i].success, |
| backend.GetVirtualPath(local_path, &virtual_path)) |
| << "Resolving " << kTestCases[i].local_path; |
| |
| // There are no guarantees for |virtual_path| value if |GetVirtualPath| |
| // fails. |
| if (!kTestCases[i].success) |
| continue; |
| |
| base::FilePath expected_virtual_path(kTestCases[i].virtual_path); |
| EXPECT_EQ(expected_virtual_path, virtual_path) |
| << "Resolving " << kTestCases[i].local_path; |
| } |
| } |
| |
| } // namespace |
