Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 17 | #include <sstream> |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 18 | #include <string> |
| 19 | |
| 20 | #include <fcntl.h> |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 21 | #include <stdlib.h> |
| 22 | #include <string.h> |
| 23 | #include <sys/statvfs.h> |
Alan Stokes | 4f2d97c | 2019-02-05 17:53:24 +0000 | [diff] [blame] | 24 | #include <sys/stat.h> |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 25 | #include <sys/xattr.h> |
| 26 | |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 27 | #include <android-base/file.h> |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 28 | #include <android-base/logging.h> |
| 29 | #include <android-base/properties.h> |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 30 | #include <android-base/scopeguard.h> |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 31 | #include <android-base/stringprintf.h> |
| 32 | #include <cutils/properties.h> |
| 33 | #include <gtest/gtest.h> |
| 34 | |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 35 | #include "binder_test_utils.h" |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 36 | #include "InstalldNativeService.h" |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 37 | #include "dexopt.h" |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 38 | #include "globals.h" |
| 39 | #include "utils.h" |
| 40 | |
| 41 | using android::base::StringPrintf; |
| 42 | |
| 43 | namespace android { |
| 44 | namespace installd { |
| 45 | |
| 46 | constexpr const char* kTestUuid = "TEST"; |
| 47 | |
Jeff Sharkey | 77be896 | 2018-08-29 10:31:25 -0600 | [diff] [blame] | 48 | #define FLAG_FORCE InstalldNativeService::FLAG_FORCE |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 49 | |
| 50 | int get_property(const char *key, char *value, const char *default_value) { |
| 51 | return property_get(key, value, default_value); |
| 52 | } |
| 53 | |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 54 | bool calculate_oat_file_path(char path[PKG_PATH_MAX], const char *oat_dir, const char *apk_path, |
Calin Juravle | 249f2d3 | 2017-05-03 17:22:27 -0700 | [diff] [blame] | 55 | const char *instruction_set) { |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 56 | return calculate_oat_file_path_default(path, oat_dir, apk_path, instruction_set); |
| 57 | } |
| 58 | |
| 59 | bool calculate_odex_file_path(char path[PKG_PATH_MAX], const char *apk_path, |
| 60 | const char *instruction_set) { |
| 61 | return calculate_odex_file_path_default(path, apk_path, instruction_set); |
| 62 | } |
| 63 | |
| 64 | bool create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set) { |
| 65 | return create_cache_path_default(path, src, instruction_set); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 66 | } |
| 67 | |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 68 | static std::string get_full_path(const char* path) { |
| 69 | return StringPrintf("/data/local/tmp/user/0/%s", path); |
| 70 | } |
| 71 | |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 72 | static void mkdir(const char* path, uid_t owner, gid_t group, mode_t mode) { |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 73 | const std::string fullPath = get_full_path(path); |
Alan Stokes | 4f2d97c | 2019-02-05 17:53:24 +0000 | [diff] [blame] | 74 | EXPECT_EQ(::mkdir(fullPath.c_str(), mode), 0); |
| 75 | EXPECT_EQ(::chown(fullPath.c_str(), owner, group), 0); |
| 76 | EXPECT_EQ(::chmod(fullPath.c_str(), mode), 0); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 77 | } |
| 78 | |
| 79 | static void touch(const char* path, uid_t owner, gid_t group, mode_t mode) { |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 80 | int fd = ::open(get_full_path(path).c_str(), O_RDWR | O_CREAT, mode); |
Alan Stokes | 4f2d97c | 2019-02-05 17:53:24 +0000 | [diff] [blame] | 81 | EXPECT_NE(fd, -1); |
| 82 | EXPECT_EQ(::fchown(fd, owner, group), 0); |
| 83 | EXPECT_EQ(::fchmod(fd, mode), 0); |
| 84 | EXPECT_EQ(::close(fd), 0); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | static int stat_gid(const char* path) { |
| 88 | struct stat buf; |
Alan Stokes | 4f2d97c | 2019-02-05 17:53:24 +0000 | [diff] [blame] | 89 | EXPECT_EQ(::stat(get_full_path(path).c_str(), &buf), 0); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 90 | return buf.st_gid; |
| 91 | } |
| 92 | |
| 93 | static int stat_mode(const char* path) { |
| 94 | struct stat buf; |
Alan Stokes | 4f2d97c | 2019-02-05 17:53:24 +0000 | [diff] [blame] | 95 | EXPECT_EQ(::stat(get_full_path(path).c_str(), &buf), 0); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 96 | return buf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISGID); |
| 97 | } |
| 98 | |
| 99 | class ServiceTest : public testing::Test { |
| 100 | protected: |
| 101 | InstalldNativeService* service; |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 102 | std::optional<std::string> testUuid; |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 103 | |
| 104 | virtual void SetUp() { |
| 105 | setenv("ANDROID_LOG_TAGS", "*:v", 1); |
| 106 | android::base::InitLogging(nullptr); |
| 107 | |
| 108 | service = new InstalldNativeService(); |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 109 | testUuid = kTestUuid; |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 110 | system("mkdir -p /data/local/tmp/user/0"); |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 111 | |
| 112 | init_globals_from_data_and_root(); |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | virtual void TearDown() { |
| 116 | delete service; |
| 117 | system("rm -rf /data/local/tmp/user"); |
| 118 | } |
| 119 | }; |
| 120 | |
| 121 | TEST_F(ServiceTest, FixupAppData_Upgrade) { |
| 122 | LOG(INFO) << "FixupAppData_Upgrade"; |
| 123 | |
| 124 | mkdir("com.example", 10000, 10000, 0700); |
| 125 | mkdir("com.example/normal", 10000, 10000, 0700); |
| 126 | mkdir("com.example/cache", 10000, 10000, 0700); |
| 127 | touch("com.example/cache/file", 10000, 10000, 0700); |
| 128 | |
| 129 | service->fixupAppData(testUuid, 0); |
| 130 | |
| 131 | EXPECT_EQ(10000, stat_gid("com.example/normal")); |
| 132 | EXPECT_EQ(20000, stat_gid("com.example/cache")); |
| 133 | EXPECT_EQ(20000, stat_gid("com.example/cache/file")); |
| 134 | |
| 135 | EXPECT_EQ(0700, stat_mode("com.example/normal")); |
| 136 | EXPECT_EQ(02771, stat_mode("com.example/cache")); |
| 137 | EXPECT_EQ(0700, stat_mode("com.example/cache/file")); |
| 138 | } |
| 139 | |
| 140 | TEST_F(ServiceTest, FixupAppData_Moved) { |
| 141 | LOG(INFO) << "FixupAppData_Moved"; |
| 142 | |
| 143 | mkdir("com.example", 10000, 10000, 0700); |
| 144 | mkdir("com.example/foo", 10000, 10000, 0700); |
| 145 | touch("com.example/foo/file", 10000, 20000, 0700); |
| 146 | mkdir("com.example/bar", 10000, 20000, 0700); |
| 147 | touch("com.example/bar/file", 10000, 20000, 0700); |
| 148 | |
| 149 | service->fixupAppData(testUuid, 0); |
| 150 | |
| 151 | EXPECT_EQ(10000, stat_gid("com.example/foo")); |
| 152 | EXPECT_EQ(20000, stat_gid("com.example/foo/file")); |
| 153 | EXPECT_EQ(10000, stat_gid("com.example/bar")); |
| 154 | EXPECT_EQ(10000, stat_gid("com.example/bar/file")); |
| 155 | |
| 156 | service->fixupAppData(testUuid, FLAG_FORCE); |
| 157 | |
| 158 | EXPECT_EQ(10000, stat_gid("com.example/foo")); |
| 159 | EXPECT_EQ(10000, stat_gid("com.example/foo/file")); |
| 160 | EXPECT_EQ(10000, stat_gid("com.example/bar")); |
| 161 | EXPECT_EQ(10000, stat_gid("com.example/bar/file")); |
| 162 | } |
| 163 | |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 164 | TEST_F(ServiceTest, HashSecondaryDex) { |
| 165 | LOG(INFO) << "HashSecondaryDex"; |
| 166 | |
| 167 | mkdir("com.example", 10000, 10000, 0700); |
| 168 | mkdir("com.example/foo", 10000, 10000, 0700); |
| 169 | touch("com.example/foo/file", 10000, 20000, 0700); |
| 170 | |
| 171 | std::vector<uint8_t> result; |
| 172 | std::string dexPath = get_full_path("com.example/foo/file"); |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 173 | EXPECT_BINDER_SUCCESS(service->hashSecondaryDexFile( |
| 174 | dexPath, "com.example", 10000, testUuid, FLAG_STORAGE_CE, &result)); |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 175 | |
| 176 | EXPECT_EQ(result.size(), 32U); |
| 177 | |
| 178 | std::ostringstream output; |
| 179 | output << std::hex << std::setfill('0'); |
| 180 | for (auto b : result) { |
| 181 | output << std::setw(2) << +b; |
| 182 | } |
| 183 | |
| 184 | // This is the SHA256 of an empty string (sha256sum /dev/null) |
| 185 | EXPECT_EQ(output.str(), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); |
| 186 | } |
| 187 | |
| 188 | TEST_F(ServiceTest, HashSecondaryDex_NoSuch) { |
| 189 | LOG(INFO) << "HashSecondaryDex_NoSuch"; |
| 190 | |
| 191 | std::vector<uint8_t> result; |
| 192 | std::string dexPath = get_full_path("com.example/foo/file"); |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 193 | EXPECT_BINDER_SUCCESS(service->hashSecondaryDexFile( |
| 194 | dexPath, "com.example", 10000, testUuid, FLAG_STORAGE_CE, &result)); |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 195 | |
| 196 | EXPECT_EQ(result.size(), 0U); |
| 197 | } |
| 198 | |
| 199 | TEST_F(ServiceTest, HashSecondaryDex_Unreadable) { |
| 200 | LOG(INFO) << "HashSecondaryDex_Unreadable"; |
| 201 | |
| 202 | mkdir("com.example", 10000, 10000, 0700); |
| 203 | mkdir("com.example/foo", 10000, 10000, 0700); |
| 204 | touch("com.example/foo/file", 10000, 20000, 0300); |
| 205 | |
| 206 | std::vector<uint8_t> result; |
| 207 | std::string dexPath = get_full_path("com.example/foo/file"); |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 208 | EXPECT_BINDER_SUCCESS(service->hashSecondaryDexFile( |
| 209 | dexPath, "com.example", 10000, testUuid, FLAG_STORAGE_CE, &result)); |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 210 | |
| 211 | EXPECT_EQ(result.size(), 0U); |
| 212 | } |
| 213 | |
| 214 | TEST_F(ServiceTest, HashSecondaryDex_WrongApp) { |
| 215 | LOG(INFO) << "HashSecondaryDex_WrongApp"; |
| 216 | |
| 217 | mkdir("com.example", 10000, 10000, 0700); |
| 218 | mkdir("com.example/foo", 10000, 10000, 0700); |
| 219 | touch("com.example/foo/file", 10000, 20000, 0700); |
| 220 | |
| 221 | std::vector<uint8_t> result; |
| 222 | std::string dexPath = get_full_path("com.example/foo/file"); |
Andreas Gampe | 8f7140d | 2019-01-31 09:22:27 -0800 | [diff] [blame] | 223 | EXPECT_BINDER_FAIL(service->hashSecondaryDexFile( |
| 224 | dexPath, "com.wrong", 10000, testUuid, FLAG_STORAGE_CE, &result)); |
Alan Stokes | 753dc71 | 2017-10-16 10:56:00 +0100 | [diff] [blame] | 225 | } |
| 226 | |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 227 | TEST_F(ServiceTest, CalculateOat) { |
| 228 | char buf[PKG_PATH_MAX]; |
Calin Juravle | 249f2d3 | 2017-05-03 17:22:27 -0700 | [diff] [blame] | 229 | |
Jeff Sharkey | 1b9d9a6 | 2017-09-21 14:51:09 -0600 | [diff] [blame] | 230 | EXPECT_TRUE(calculate_oat_file_path(buf, "/path/to/oat", "/path/to/file.apk", "isa")); |
| 231 | EXPECT_EQ("/path/to/oat/isa/file.odex", std::string(buf)); |
| 232 | |
| 233 | EXPECT_FALSE(calculate_oat_file_path(buf, "/path/to/oat", "/path/to/file", "isa")); |
| 234 | EXPECT_FALSE(calculate_oat_file_path(buf, "/path/to/oat", "file", "isa")); |
| 235 | } |
| 236 | |
| 237 | TEST_F(ServiceTest, CalculateOdex) { |
| 238 | char buf[PKG_PATH_MAX]; |
| 239 | |
| 240 | EXPECT_TRUE(calculate_odex_file_path(buf, "/path/to/file.apk", "isa")); |
| 241 | EXPECT_EQ("/path/to/oat/isa/file.odex", std::string(buf)); |
| 242 | } |
| 243 | |
| 244 | TEST_F(ServiceTest, CalculateCache) { |
| 245 | char buf[PKG_PATH_MAX]; |
| 246 | |
| 247 | EXPECT_TRUE(create_cache_path(buf, "/path/to/file.apk", "isa")); |
| 248 | EXPECT_EQ("/data/dalvik-cache/isa/path@to@file.apk@classes.dex", std::string(buf)); |
Calin Juravle | 249f2d3 | 2017-05-03 17:22:27 -0700 | [diff] [blame] | 249 | } |
| 250 | |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 251 | static bool mkdirs(const std::string& path, mode_t mode) { |
| 252 | struct stat sb; |
| 253 | if (stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) { |
| 254 | return true; |
| 255 | } |
| 256 | |
| 257 | if (!mkdirs(android::base::Dirname(path), mode)) { |
| 258 | return false; |
| 259 | } |
| 260 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 261 | if (::mkdir(path.c_str(), mode) != 0) { |
| 262 | PLOG(DEBUG) << "Failed to create folder " << path; |
| 263 | return false; |
| 264 | } |
| 265 | return true; |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 266 | } |
| 267 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 268 | class AppDataSnapshotTest : public testing::Test { |
| 269 | private: |
| 270 | std::string rollback_ce_base_dir; |
| 271 | std::string rollback_de_base_dir; |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 272 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 273 | protected: |
| 274 | InstalldNativeService* service; |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 275 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 276 | std::string fake_package_ce_path; |
| 277 | std::string fake_package_de_path; |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 278 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 279 | virtual void SetUp() { |
| 280 | setenv("ANDROID_LOG_TAGS", "*:v", 1); |
| 281 | android::base::InitLogging(nullptr); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 282 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 283 | service = new InstalldNativeService(); |
| 284 | ASSERT_TRUE(mkdirs("/data/local/tmp/user/0", 0700)); |
| 285 | |
| 286 | init_globals_from_data_and_root(); |
| 287 | |
| 288 | rollback_ce_base_dir = create_data_misc_ce_rollback_base_path("TEST", 0); |
| 289 | rollback_de_base_dir = create_data_misc_de_rollback_base_path("TEST", 0); |
| 290 | |
| 291 | fake_package_ce_path = create_data_user_ce_package_path("TEST", 0, "com.foo"); |
| 292 | fake_package_de_path = create_data_user_de_package_path("TEST", 0, "com.foo"); |
| 293 | |
| 294 | ASSERT_TRUE(mkdirs(rollback_ce_base_dir, 0700)); |
| 295 | ASSERT_TRUE(mkdirs(rollback_de_base_dir, 0700)); |
| 296 | ASSERT_TRUE(mkdirs(fake_package_ce_path, 0700)); |
| 297 | ASSERT_TRUE(mkdirs(fake_package_de_path, 0700)); |
| 298 | } |
| 299 | |
| 300 | virtual void TearDown() { |
| 301 | ASSERT_EQ(0, delete_dir_contents_and_dir(rollback_ce_base_dir, true)); |
| 302 | ASSERT_EQ(0, delete_dir_contents_and_dir(rollback_de_base_dir, true)); |
| 303 | ASSERT_EQ(0, delete_dir_contents(fake_package_ce_path, true)); |
| 304 | ASSERT_EQ(0, delete_dir_contents(fake_package_de_path, true)); |
| 305 | |
| 306 | delete service; |
| 307 | ASSERT_EQ(0, delete_dir_contents_and_dir("/data/local/tmp/user/0", true)); |
| 308 | } |
| 309 | }; |
| 310 | |
| 311 | TEST_F(AppDataSnapshotTest, CreateAppDataSnapshot) { |
| 312 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 37); |
| 313 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 37); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 314 | |
| 315 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 316 | "TEST_CONTENT_CE", fake_package_ce_path + "/file1", |
| 317 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 318 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 319 | "TEST_CONTENT_DE", fake_package_de_path + "/file1", |
| 320 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 321 | |
| 322 | // Request a snapshot of the CE content but not the DE content. |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 323 | int64_t ce_snapshot_inode; |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 324 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 325 | "com.foo", 0, 37, FLAG_STORAGE_CE, &ce_snapshot_inode)); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 326 | struct stat buf; |
| 327 | memset(&buf, 0, sizeof(buf)); |
| 328 | ASSERT_EQ(0, stat((rollback_ce_dir + "/com.foo").c_str(), &buf)); |
| 329 | ASSERT_EQ(ce_snapshot_inode, (int64_t) buf.st_ino); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 330 | |
| 331 | std::string ce_content, de_content; |
| 332 | // At this point, we should have the CE content but not the DE content. |
| 333 | ASSERT_TRUE(android::base::ReadFileToString( |
| 334 | rollback_ce_dir + "/com.foo/file1", &ce_content, false /* follow_symlinks */)); |
| 335 | ASSERT_FALSE(android::base::ReadFileToString( |
| 336 | rollback_de_dir + "/com.foo/file1", &de_content, false /* follow_symlinks */)); |
| 337 | ASSERT_EQ("TEST_CONTENT_CE", ce_content); |
| 338 | |
| 339 | // Modify the CE content, so we can assert later that it's reflected |
| 340 | // in the snapshot. |
| 341 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 342 | "TEST_CONTENT_CE_MODIFIED", fake_package_ce_path + "/file1", |
| 343 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 344 | |
| 345 | // Request a snapshot of the DE content but not the CE content. |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 346 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 347 | "com.foo", 0, 37, FLAG_STORAGE_DE, &ce_snapshot_inode)); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 348 | // Only DE content snapshot was requested. |
| 349 | ASSERT_EQ(ce_snapshot_inode, 0); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 350 | |
| 351 | // At this point, both the CE as well as the DE content should be fully |
| 352 | // populated. |
| 353 | ASSERT_TRUE(android::base::ReadFileToString( |
| 354 | rollback_ce_dir + "/com.foo/file1", &ce_content, false /* follow_symlinks */)); |
| 355 | ASSERT_TRUE(android::base::ReadFileToString( |
| 356 | rollback_de_dir + "/com.foo/file1", &de_content, false /* follow_symlinks */)); |
| 357 | ASSERT_EQ("TEST_CONTENT_CE", ce_content); |
| 358 | ASSERT_EQ("TEST_CONTENT_DE", de_content); |
| 359 | |
| 360 | // Modify the DE content, so we can assert later that it's reflected |
| 361 | // in our final snapshot. |
| 362 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 363 | "TEST_CONTENT_DE_MODIFIED", fake_package_de_path + "/file1", |
| 364 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 365 | |
| 366 | // Request a snapshot of both the CE as well as the DE content. |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 367 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 368 | "com.foo", 0, 37, FLAG_STORAGE_DE | FLAG_STORAGE_CE, nullptr)); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 369 | |
| 370 | ASSERT_TRUE(android::base::ReadFileToString( |
| 371 | rollback_ce_dir + "/com.foo/file1", &ce_content, false /* follow_symlinks */)); |
| 372 | ASSERT_TRUE(android::base::ReadFileToString( |
| 373 | rollback_de_dir + "/com.foo/file1", &de_content, false /* follow_symlinks */)); |
| 374 | ASSERT_EQ("TEST_CONTENT_CE_MODIFIED", ce_content); |
| 375 | ASSERT_EQ("TEST_CONTENT_DE_MODIFIED", de_content); |
| 376 | } |
| 377 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 378 | TEST_F(AppDataSnapshotTest, CreateAppDataSnapshot_TwoSnapshotsWithTheSameId) { |
| 379 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 67); |
| 380 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 67); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 381 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 382 | auto another_fake_package_ce_path = create_data_user_ce_package_path("TEST", 0, "com.bar"); |
| 383 | auto another_fake_package_de_path = create_data_user_de_package_path("TEST", 0, "com.bar"); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 384 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 385 | // Since this test sets up data for another package, some bookkeeping is required. |
| 386 | auto deleter = [&]() { |
| 387 | ASSERT_EQ(0, delete_dir_contents_and_dir(another_fake_package_ce_path, true)); |
| 388 | ASSERT_EQ(0, delete_dir_contents_and_dir(another_fake_package_de_path, true)); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 389 | }; |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 390 | auto scope_guard = android::base::make_scope_guard(deleter); |
| 391 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 392 | ASSERT_TRUE(mkdirs(another_fake_package_ce_path, 0700)); |
| 393 | ASSERT_TRUE(mkdirs(another_fake_package_de_path, 0700)); |
| 394 | |
| 395 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 396 | "TEST_CONTENT_CE", fake_package_ce_path + "/file1", |
| 397 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 398 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 399 | "TEST_CONTENT_DE", fake_package_de_path + "/file1", |
| 400 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 401 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 402 | "ANOTHER_TEST_CONTENT_CE", another_fake_package_ce_path + "/file1", |
| 403 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 404 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 405 | "ANOTHER_TEST_CONTENT_DE", another_fake_package_de_path + "/file1", |
| 406 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 407 | |
| 408 | // Request snapshot for the package com.foo. |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 409 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 410 | "com.foo", 0, 67, FLAG_STORAGE_DE | FLAG_STORAGE_CE, nullptr)); |
| 411 | // Now request snapshot with the same id for the package com.bar |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 412 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 413 | "com.bar", 0, 67, FLAG_STORAGE_DE | FLAG_STORAGE_CE, nullptr)); |
| 414 | |
| 415 | // Check that both snapshots have correct data in them. |
| 416 | std::string com_foo_ce_content, com_foo_de_content; |
| 417 | std::string com_bar_ce_content, com_bar_de_content; |
| 418 | ASSERT_TRUE(android::base::ReadFileToString( |
| 419 | rollback_ce_dir + "/com.foo/file1", &com_foo_ce_content, false /* follow_symlinks */)); |
| 420 | ASSERT_TRUE(android::base::ReadFileToString( |
| 421 | rollback_de_dir + "/com.foo/file1", &com_foo_de_content, false /* follow_symlinks */)); |
| 422 | ASSERT_TRUE(android::base::ReadFileToString( |
| 423 | rollback_ce_dir + "/com.bar/file1", &com_bar_ce_content, false /* follow_symlinks */)); |
| 424 | ASSERT_TRUE(android::base::ReadFileToString( |
| 425 | rollback_de_dir + "/com.bar/file1", &com_bar_de_content, false /* follow_symlinks */)); |
| 426 | ASSERT_EQ("TEST_CONTENT_CE", com_foo_ce_content); |
| 427 | ASSERT_EQ("TEST_CONTENT_DE", com_foo_de_content); |
| 428 | ASSERT_EQ("ANOTHER_TEST_CONTENT_CE", com_bar_ce_content); |
| 429 | ASSERT_EQ("ANOTHER_TEST_CONTENT_DE", com_bar_de_content); |
| 430 | } |
| 431 | |
| 432 | TEST_F(AppDataSnapshotTest, CreateAppDataSnapshot_AppDataAbsent) { |
| 433 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 73); |
| 434 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 73); |
| 435 | |
| 436 | // Similuating app data absence. |
| 437 | ASSERT_EQ(0, delete_dir_contents_and_dir(fake_package_ce_path, true)); |
| 438 | ASSERT_EQ(0, delete_dir_contents_and_dir(fake_package_de_path, true)); |
| 439 | |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 440 | int64_t ce_snapshot_inode; |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 441 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 442 | "com.foo", 0, 73, FLAG_STORAGE_CE, &ce_snapshot_inode)); |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 443 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 444 | "com.foo", 0, 73, FLAG_STORAGE_DE, nullptr)); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 445 | // No CE content snapshot was performed. |
| 446 | ASSERT_EQ(ce_snapshot_inode, 0); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 447 | |
| 448 | // The snapshot calls must succeed but there should be no snapshot |
| 449 | // created. |
| 450 | struct stat sb; |
| 451 | ASSERT_EQ(-1, stat((rollback_ce_dir + "/com.foo").c_str(), &sb)); |
| 452 | ASSERT_EQ(-1, stat((rollback_de_dir + "/com.foo").c_str(), &sb)); |
| 453 | } |
| 454 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 455 | TEST_F(AppDataSnapshotTest, CreateAppDataSnapshot_ClearsExistingSnapshot) { |
| 456 | auto rollback_ce_dir = create_data_misc_ce_rollback_package_path("TEST", 0, 13, "com.foo"); |
| 457 | auto rollback_de_dir = create_data_misc_de_rollback_package_path("TEST", 0, 13, "com.foo"); |
Nikita Ioffe | 835ae77 | 2019-01-23 16:32:13 +0000 | [diff] [blame] | 458 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 459 | ASSERT_TRUE(mkdirs(rollback_ce_dir, 0700)); |
| 460 | ASSERT_TRUE(mkdirs(rollback_de_dir, 0700)); |
Nikita Ioffe | 835ae77 | 2019-01-23 16:32:13 +0000 | [diff] [blame] | 461 | |
| 462 | // Simulate presence of an existing snapshot |
| 463 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 464 | "TEST_CONTENT_CE", rollback_ce_dir + "/file1", |
| 465 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 466 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 467 | "TEST_CONTENT_DE", rollback_de_dir + "/file1", |
| 468 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 469 | |
| 470 | // Create app data. |
| 471 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 472 | "TEST_CONTENT_2_CE", fake_package_ce_path + "/file2", |
| 473 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 474 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 475 | "TEST_CONTENT_2_DE", fake_package_de_path + "/file2", |
| 476 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 477 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 478 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 479 | "com.foo", 0, 13, FLAG_STORAGE_DE | FLAG_STORAGE_CE, nullptr)); |
Nikita Ioffe | 835ae77 | 2019-01-23 16:32:13 +0000 | [diff] [blame] | 480 | |
| 481 | // Previous snapshot (with data for file1) must be cleared. |
| 482 | struct stat sb; |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 483 | ASSERT_EQ(-1, stat((rollback_ce_dir + "/file1").c_str(), &sb)); |
| 484 | ASSERT_EQ(-1, stat((rollback_de_dir + "/file1").c_str(), &sb)); |
| 485 | // New snapshot (with data for file2) must be present. |
| 486 | ASSERT_NE(-1, stat((rollback_ce_dir + "/file2").c_str(), &sb)); |
| 487 | ASSERT_NE(-1, stat((rollback_de_dir + "/file2").c_str(), &sb)); |
Nikita Ioffe | 835ae77 | 2019-01-23 16:32:13 +0000 | [diff] [blame] | 488 | } |
| 489 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 490 | TEST_F(AppDataSnapshotTest, SnapshotAppData_WrongVolumeUuid) { |
| 491 | // Setup rollback folders to make sure that fails due to wrong volumeUuid being |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 492 | // passed, not because of some other reason. |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 493 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 17); |
| 494 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 17); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 495 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 496 | ASSERT_TRUE(mkdirs(rollback_ce_dir, 0700)); |
| 497 | ASSERT_TRUE(mkdirs(rollback_de_dir, 0700)); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 498 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 499 | EXPECT_BINDER_FAIL(service->snapshotAppData(std::make_optional<std::string>("FOO"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 500 | "com.foo", 0, 17, FLAG_STORAGE_DE, nullptr)); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 501 | } |
| 502 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 503 | TEST_F(AppDataSnapshotTest, CreateAppDataSnapshot_ClearsCache) { |
Nikita Ioffe | 04c74f3 | 2019-02-02 17:26:18 +0000 | [diff] [blame] | 504 | auto fake_package_ce_cache_path = fake_package_ce_path + "/cache"; |
| 505 | auto fake_package_ce_code_cache_path = fake_package_ce_path + "/code_cache"; |
Nikita Ioffe | 900b3c2 | 2019-01-23 14:32:48 +0000 | [diff] [blame] | 506 | auto fake_package_de_cache_path = fake_package_de_path + "/cache"; |
| 507 | auto fake_package_de_code_cache_path = fake_package_de_path + "/code_cache"; |
| 508 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 509 | ASSERT_TRUE(mkdirs(fake_package_ce_cache_path, 0700)); |
| 510 | ASSERT_TRUE(mkdirs(fake_package_ce_code_cache_path, 0700)); |
| 511 | ASSERT_TRUE(mkdirs(fake_package_de_cache_path, 0700)); |
| 512 | ASSERT_TRUE(mkdirs(fake_package_de_code_cache_path, 0700)); |
Nikita Ioffe | 900b3c2 | 2019-01-23 14:32:48 +0000 | [diff] [blame] | 513 | |
| 514 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 515 | "TEST_CONTENT_CE", fake_package_ce_cache_path + "/file1", |
| 516 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 517 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 518 | "TEST_CONTENT_CE", fake_package_ce_code_cache_path + "/file1", |
| 519 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 520 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 521 | "TEST_CONTENT_DE", fake_package_de_cache_path + "/file1", |
| 522 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 523 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 524 | "TEST_CONTENT_DE", fake_package_de_code_cache_path + "/file1", |
| 525 | 0700, 10000, 20000, false /* follow_symlinks */)); |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 526 | ASSERT_BINDER_SUCCESS(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 527 | "com.foo", 0, 23, FLAG_STORAGE_CE | FLAG_STORAGE_DE, nullptr)); |
Nikita Ioffe | 900b3c2 | 2019-01-23 14:32:48 +0000 | [diff] [blame] | 528 | // The snapshot call must clear cache. |
| 529 | struct stat sb; |
| 530 | ASSERT_EQ(-1, stat((fake_package_ce_cache_path + "/file1").c_str(), &sb)); |
| 531 | ASSERT_EQ(-1, stat((fake_package_ce_code_cache_path + "/file1").c_str(), &sb)); |
| 532 | ASSERT_EQ(-1, stat((fake_package_de_cache_path + "/file1").c_str(), &sb)); |
| 533 | ASSERT_EQ(-1, stat((fake_package_de_code_cache_path + "/file1").c_str(), &sb)); |
| 534 | } |
| 535 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 536 | TEST_F(AppDataSnapshotTest, RestoreAppDataSnapshot) { |
| 537 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 239); |
| 538 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 239); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 539 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 540 | ASSERT_TRUE(mkdirs(rollback_ce_dir, 0700)); |
| 541 | ASSERT_TRUE(mkdirs(rollback_de_dir, 0700)); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 542 | |
| 543 | // Write contents to the rollback location. We'll write the same files to the |
| 544 | // app data location and make sure the restore has overwritten them. |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 545 | ASSERT_TRUE(mkdirs(rollback_ce_dir + "/com.foo/", 0700)); |
| 546 | ASSERT_TRUE(mkdirs(rollback_de_dir + "/com.foo/", 0700)); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 547 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 548 | "CE_RESTORE_CONTENT", rollback_ce_dir + "/com.foo/file1", |
| 549 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 550 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 551 | "DE_RESTORE_CONTENT", rollback_de_dir + "/com.foo/file1", |
| 552 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 553 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 554 | "TEST_CONTENT_CE", fake_package_ce_path + "/file1", |
| 555 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 556 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 557 | "TEST_CONTENT_DE", fake_package_de_path + "/file1", |
| 558 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 559 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 560 | ASSERT_BINDER_SUCCESS(service->restoreAppDataSnapshot(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 561 | "com.foo", 10000, "", 0, 239, FLAG_STORAGE_DE | FLAG_STORAGE_CE)); |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 562 | |
| 563 | std::string ce_content, de_content; |
| 564 | ASSERT_TRUE(android::base::ReadFileToString( |
| 565 | fake_package_ce_path + "/file1", &ce_content, false /* follow_symlinks */)); |
| 566 | ASSERT_TRUE(android::base::ReadFileToString( |
| 567 | fake_package_de_path + "/file1", &de_content, false /* follow_symlinks */)); |
| 568 | ASSERT_EQ("CE_RESTORE_CONTENT", ce_content); |
| 569 | ASSERT_EQ("DE_RESTORE_CONTENT", de_content); |
| 570 | } |
| 571 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 572 | TEST_F(AppDataSnapshotTest, CreateSnapshotThenDestroyIt) { |
| 573 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 57); |
| 574 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 57); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 575 | |
| 576 | // Prepare data for snapshot. |
| 577 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 578 | "TEST_CONTENT_CE", fake_package_ce_path + "/file1", |
| 579 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 580 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 581 | "TEST_CONTENT_DE", fake_package_de_path + "/file1", |
| 582 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 583 | |
| 584 | int64_t ce_snapshot_inode; |
| 585 | // Request a snapshot of both the CE as well as the DE content. |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 586 | ASSERT_TRUE(service->snapshotAppData(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 587 | "com.foo", 0, 57, FLAG_STORAGE_DE | FLAG_STORAGE_CE, &ce_snapshot_inode).isOk()); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 588 | // Because CE data snapshot was requested, ce_snapshot_inode can't be null. |
| 589 | ASSERT_NE(0, ce_snapshot_inode); |
| 590 | // Check snapshot is there. |
| 591 | struct stat sb; |
| 592 | ASSERT_EQ(0, stat((rollback_ce_dir + "/com.foo").c_str(), &sb)); |
| 593 | ASSERT_EQ(0, stat((rollback_de_dir + "/com.foo").c_str(), &sb)); |
| 594 | |
| 595 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 596 | ASSERT_TRUE(service->destroyAppDataSnapshot(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 597 | "com.foo", 0, ce_snapshot_inode, 57, FLAG_STORAGE_DE | FLAG_STORAGE_CE).isOk()); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 598 | // Check snapshot is deleted. |
| 599 | ASSERT_EQ(-1, stat((rollback_ce_dir + "/com.foo").c_str(), &sb)); |
| 600 | ASSERT_EQ(-1, stat((rollback_de_dir + "/com.foo").c_str(), &sb)); |
| 601 | } |
| 602 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 603 | TEST_F(AppDataSnapshotTest, DestroyAppDataSnapshot_CeSnapshotInodeIsZero) { |
| 604 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 1543); |
| 605 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 1543); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 606 | |
| 607 | // Create a snapshot |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 608 | ASSERT_TRUE(mkdirs(rollback_ce_dir + "/com.foo/", 0700)); |
| 609 | ASSERT_TRUE(mkdirs(rollback_de_dir + "/com.foo/", 0700)); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 610 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 611 | "CE_RESTORE_CONTENT", rollback_ce_dir + "/com.foo/file1", |
| 612 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 613 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 614 | "DE_RESTORE_CONTENT", rollback_de_dir + "/com.foo/file1", |
| 615 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 616 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 617 | ASSERT_TRUE(service->destroyAppDataSnapshot(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 618 | "com.foo", 0, 0, 1543, FLAG_STORAGE_DE | FLAG_STORAGE_CE).isOk()); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 619 | |
| 620 | // Check snapshot is deleted. |
| 621 | struct stat sb; |
| 622 | ASSERT_EQ(-1, stat((rollback_ce_dir + "/com.foo").c_str(), &sb)); |
| 623 | ASSERT_EQ(-1, stat((rollback_de_dir + "/com.foo").c_str(), &sb)); |
| 624 | |
| 625 | // Check that deleting already deleted snapshot is no-op. |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 626 | ASSERT_TRUE(service->destroyAppDataSnapshot(std::make_optional<std::string>("TEST"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 627 | "com.foo", 0, 0, 1543, FLAG_STORAGE_DE | FLAG_STORAGE_CE).isOk()); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 628 | } |
| 629 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 630 | TEST_F(AppDataSnapshotTest, DestroyAppDataSnapshot_WrongVolumeUuid) { |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 631 | // Setup rollback data to make sure that test fails due to wrong volumeUuid |
| 632 | // being passed, not because of some other reason. |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 633 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 43); |
| 634 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 43); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 635 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 636 | ASSERT_TRUE(mkdirs(rollback_ce_dir, 0700)); |
| 637 | ASSERT_TRUE(mkdirs(rollback_de_dir, 0700)); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 638 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 639 | ASSERT_FALSE(service->destroyAppDataSnapshot(std::make_optional<std::string>("BAR"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 640 | "com.foo", 0, 0, 43, FLAG_STORAGE_DE).isOk()); |
Nikita Ioffe | 77be2ed | 2019-01-25 13:54:43 +0000 | [diff] [blame] | 641 | } |
Narayan Kamath | e63ca7d | 2019-01-14 15:21:52 +0000 | [diff] [blame] | 642 | |
Oli Lan | 035abbb | 2020-03-16 18:18:41 +0000 | [diff] [blame] | 643 | TEST_F(AppDataSnapshotTest, DestroyCeSnapshotsNotSpecified) { |
| 644 | auto rollback_ce_dir_in_1 = create_data_misc_ce_rollback_path("TEST", 0, 1543); |
| 645 | auto rollback_ce_dir_in_2 = create_data_misc_ce_rollback_path("TEST", 0, 77); |
| 646 | auto rollback_ce_dir_out_1 = create_data_misc_ce_rollback_path("TEST", 0, 1500); |
| 647 | auto rollback_ce_dir_out_2 = create_data_misc_ce_rollback_path("TEST", 0, 2); |
| 648 | |
| 649 | // Create snapshots |
| 650 | ASSERT_TRUE(mkdirs(rollback_ce_dir_in_1 + "/com.foo/", 0700)); |
| 651 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 652 | "CE_RESTORE_CONTENT", rollback_ce_dir_in_1 + "/com.foo/file1", |
| 653 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 654 | |
| 655 | ASSERT_TRUE(mkdirs(rollback_ce_dir_in_2 + "/com.foo/", 0700)); |
| 656 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 657 | "CE_RESTORE_CONTENT", rollback_ce_dir_in_2 + "/com.foo/file1", |
| 658 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 659 | |
| 660 | ASSERT_TRUE(mkdirs(rollback_ce_dir_out_1 + "/com.foo/", 0700)); |
| 661 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 662 | "CE_RESTORE_CONTENT", rollback_ce_dir_out_1 + "/com.foo/file1", |
| 663 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 664 | |
| 665 | ASSERT_TRUE(mkdirs(rollback_ce_dir_out_2 + "/com.foo/", 0700)); |
| 666 | ASSERT_TRUE(android::base::WriteStringToFile( |
| 667 | "CE_RESTORE_CONTENT", rollback_ce_dir_out_2 + "/com.foo/file1", |
| 668 | 0700, 10000, 20000, false /* follow_symlinks */)); |
| 669 | |
| 670 | ASSERT_TRUE(service->destroyCeSnapshotsNotSpecified( |
| 671 | std::make_optional<std::string>("TEST"), 0, { 1543, 77 }).isOk()); |
| 672 | |
| 673 | // Check only snapshots not specified are deleted. |
| 674 | struct stat sb; |
| 675 | ASSERT_EQ(0, stat((rollback_ce_dir_in_1 + "/com.foo").c_str(), &sb)); |
| 676 | ASSERT_EQ(0, stat((rollback_ce_dir_in_2 + "/com.foo").c_str(), &sb)); |
| 677 | ASSERT_EQ(-1, stat((rollback_ce_dir_out_1 + "/com.foo").c_str(), &sb)); |
| 678 | ASSERT_EQ(ENOENT, errno); |
| 679 | ASSERT_EQ(-1, stat((rollback_ce_dir_out_2 + "/com.foo").c_str(), &sb)); |
| 680 | ASSERT_EQ(ENOENT, errno); |
| 681 | } |
| 682 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 683 | TEST_F(AppDataSnapshotTest, RestoreAppDataSnapshot_WrongVolumeUuid) { |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 684 | // Setup rollback data to make sure that fails due to wrong volumeUuid being |
| 685 | // passed, not because of some other reason. |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 686 | auto rollback_ce_dir = create_data_misc_ce_rollback_path("TEST", 0, 41); |
| 687 | auto rollback_de_dir = create_data_misc_de_rollback_path("TEST", 0, 41); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 688 | |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 689 | ASSERT_TRUE(mkdirs(rollback_ce_dir, 0700)); |
| 690 | ASSERT_TRUE(mkdirs(rollback_de_dir, 0700)); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 691 | |
Jooyung Han | 9fcc4ef | 2020-01-23 12:45:10 +0900 | [diff] [blame] | 692 | EXPECT_BINDER_FAIL(service->restoreAppDataSnapshot(std::make_optional<std::string>("BAR"), |
Nikita Ioffe | b68f0d1 | 2019-02-04 11:06:37 +0000 | [diff] [blame] | 693 | "com.foo", 10000, "", 0, 41, FLAG_STORAGE_DE)); |
Nikita Ioffe | 8e4d346 | 2019-01-21 17:56:03 +0000 | [diff] [blame] | 694 | } |
| 695 | |
Jeff Sharkey | e12d596 | 2017-04-03 16:41:02 -0600 | [diff] [blame] | 696 | } // namespace installd |
| 697 | } // namespace android |