1/* 2 * Copyright (C) 2011 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 17#include <stdlib.h> 18#include <string.h> 19 20#define LOG_TAG "utils_test" 21#include <utils/Log.h> 22 23#include <gtest/gtest.h> 24 25extern "C" { 26#include "installd.h" 27} 28 29#define TEST_DATA_DIR "/data/" 30#define TEST_APP_DIR "/data/app/" 31#define TEST_APP_PRIVATE_DIR "/data/app-private/" 32#define TEST_ASEC_DIR "/mnt/asec/" 33 34#define TEST_SYSTEM_DIR1 "/system/app/" 35#define TEST_SYSTEM_DIR2 "/vendor/app/" 36 37#define REALLY_LONG_APP_NAME "com.example." \ 38 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." \ 39 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." \ 40 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 41 42#define REALLY_LONG_LEAF_NAME "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 43 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 44 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 45 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" 46 47namespace android { 48 49class UtilsTest : public testing::Test { 50protected: 51 virtual void SetUp() { 52 android_app_dir.path = TEST_APP_DIR; 53 android_app_dir.len = strlen(TEST_APP_DIR); 54 55 android_app_private_dir.path = TEST_APP_PRIVATE_DIR; 56 android_app_private_dir.len = strlen(TEST_APP_PRIVATE_DIR); 57 58 android_data_dir.path = TEST_DATA_DIR; 59 android_data_dir.len = strlen(TEST_DATA_DIR); 60 61 android_asec_dir.path = TEST_ASEC_DIR; 62 android_asec_dir.len = strlen(TEST_ASEC_DIR); 63 64 android_system_dirs.count = 2; 65 66 android_system_dirs.dirs = (dir_rec_t*) calloc(android_system_dirs.count, sizeof(dir_rec_t)); 67 android_system_dirs.dirs[0].path = TEST_SYSTEM_DIR1; 68 android_system_dirs.dirs[0].len = strlen(TEST_SYSTEM_DIR1); 69 70 android_system_dirs.dirs[1].path = TEST_SYSTEM_DIR2; 71 android_system_dirs.dirs[1].len = strlen(TEST_SYSTEM_DIR2); 72 } 73 74 virtual void TearDown() { 75 free(android_system_dirs.dirs); 76 } 77}; 78 79TEST_F(UtilsTest, IsValidApkPath_BadPrefix) { 80 // Bad prefixes directories 81 const char *badprefix1 = "/etc/passwd"; 82 EXPECT_EQ(-1, validate_apk_path(badprefix1)) 83 << badprefix1 << " should be allowed as a valid path"; 84 85 const char *badprefix2 = "../.." TEST_APP_DIR "../../../blah"; 86 EXPECT_EQ(-1, validate_apk_path(badprefix2)) 87 << badprefix2 << " should be allowed as a valid path"; 88 89 const char *badprefix3 = "init.rc"; 90 EXPECT_EQ(-1, validate_apk_path(badprefix3)) 91 << badprefix3 << " should be allowed as a valid path"; 92 93 const char *badprefix4 = "/init.rc"; 94 EXPECT_EQ(-1, validate_apk_path(badprefix4)) 95 << badprefix4 << " should be allowed as a valid path"; 96} 97 98TEST_F(UtilsTest, IsValidApkPath_Internal) { 99 // Internal directories 100 const char *internal1 = TEST_APP_DIR "example.apk"; 101 EXPECT_EQ(0, validate_apk_path(internal1)) 102 << internal1 << " should be allowed as a valid path"; 103 104 // b/16888084 105 const char *path2 = TEST_APP_DIR "example.com/example.apk"; 106 EXPECT_EQ(0, validate_apk_path(path2)) 107 << path2 << " should be allowed as a valid path"; 108 109 const char *badint1 = TEST_APP_DIR "../example.apk"; 110 EXPECT_EQ(-1, validate_apk_path(badint1)) 111 << badint1 << " should be rejected as a invalid path"; 112 113 const char *badint2 = TEST_APP_DIR "/../example.apk"; 114 EXPECT_EQ(-1, validate_apk_path(badint2)) 115 << badint2 << " should be rejected as a invalid path"; 116 117 // Only one subdir should be allowed. 118 const char *bad_path3 = TEST_APP_DIR "example.com/subdir/pkg.apk"; 119 EXPECT_EQ(-1, validate_apk_path(bad_path3)) 120 << bad_path3 << " should be rejected as a invalid path"; 121 122 const char *bad_path4 = TEST_APP_DIR "example.com/subdir/../pkg.apk"; 123 EXPECT_EQ(-1, validate_apk_path(bad_path4)) 124 << bad_path4 << " should be rejected as a invalid path"; 125 126 const char *bad_path5 = TEST_APP_DIR "example.com1/../example.com2/pkg.apk"; 127 EXPECT_EQ(-1, validate_apk_path(bad_path5)) 128 << bad_path5 << " should be rejected as a invalid path"; 129} 130 131TEST_F(UtilsTest, IsValidApkPath_Private) { 132 // Internal directories 133 const char *private1 = TEST_APP_PRIVATE_DIR "example.apk"; 134 EXPECT_EQ(0, validate_apk_path(private1)) 135 << private1 << " should be allowed as a valid path"; 136 137 // b/16888084 138 const char *path2 = TEST_APP_DIR "example.com/example.apk"; 139 EXPECT_EQ(0, validate_apk_path(path2)) 140 << path2 << " should be allowed as a valid path"; 141 142 const char *badpriv1 = TEST_APP_PRIVATE_DIR "../example.apk"; 143 EXPECT_EQ(-1, validate_apk_path(badpriv1)) 144 << badpriv1 << " should be rejected as a invalid path"; 145 146 const char *badpriv2 = TEST_APP_PRIVATE_DIR "/../example.apk"; 147 EXPECT_EQ(-1, validate_apk_path(badpriv2)) 148 << badpriv2 << " should be rejected as a invalid path"; 149 150 // Only one subdir should be allowed. 151 const char *bad_path3 = TEST_APP_PRIVATE_DIR "example.com/subdir/pkg.apk"; 152 EXPECT_EQ(-1, validate_apk_path(bad_path3)) 153 << bad_path3 << " should be rejected as a invalid path"; 154 155 const char *bad_path4 = TEST_APP_PRIVATE_DIR "example.com/subdir/../pkg.apk"; 156 EXPECT_EQ(-1, validate_apk_path(bad_path4)) 157 << bad_path4 << " should be rejected as a invalid path"; 158 159 const char *bad_path5 = TEST_APP_PRIVATE_DIR "example.com1/../example.com2/pkg.apk"; 160 EXPECT_EQ(-1, validate_apk_path(bad_path5)) 161 << bad_path5 << " should be rejected as a invalid path"; 162} 163 164 165TEST_F(UtilsTest, IsValidApkPath_AsecGood1) { 166 const char *asec1 = TEST_ASEC_DIR "example.apk"; 167 EXPECT_EQ(0, validate_apk_path(asec1)) 168 << asec1 << " should be allowed as a valid path"; 169} 170 171TEST_F(UtilsTest, IsValidApkPath_AsecGood2) { 172 const char *asec2 = TEST_ASEC_DIR "com.example.asec/pkg.apk"; 173 EXPECT_EQ(0, validate_apk_path(asec2)) 174 << asec2 << " should be allowed as a valid path"; 175} 176 177TEST_F(UtilsTest, IsValidApkPath_EscapeFail) { 178 const char *badasec1 = TEST_ASEC_DIR "../example.apk"; 179 EXPECT_EQ(-1, validate_apk_path(badasec1)) 180 << badasec1 << " should be rejected as a invalid path"; 181} 182 183TEST_F(UtilsTest, IsValidApkPath_DoubleSlashFail) { 184 const char *badasec2 = TEST_ASEC_DIR "com.example.asec//pkg.apk"; 185 EXPECT_EQ(-1, validate_apk_path(badasec2)) 186 << badasec2 << " should be rejected as a invalid path"; 187} 188 189TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeFail) { 190 const char *badasec3 = TEST_ASEC_DIR "com.example.asec/../../../pkg.apk"; 191 EXPECT_EQ(-1, validate_apk_path(badasec3)) 192 << badasec3 << " should be rejected as a invalid path"; 193} 194 195TEST_F(UtilsTest, IsValidApkPath_SlashEscapeFail) { 196 const char *badasec4 = TEST_ASEC_DIR "/../example.apk"; 197 EXPECT_EQ(-1, validate_apk_path(badasec4)) 198 << badasec4 << " should be rejected as a invalid path"; 199} 200 201TEST_F(UtilsTest, IsValidApkPath_CrazyDirFail) { 202 const char *badasec5 = TEST_ASEC_DIR ".//../.."; 203 EXPECT_EQ(-1, validate_apk_path(badasec5)) 204 << badasec5 << " should be rejected as a invalid path"; 205} 206 207TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeSingleFail) { 208 const char *badasec6 = TEST_ASEC_DIR "com.example.asec/../pkg.apk"; 209 EXPECT_EQ(-1, validate_apk_path(badasec6)) 210 << badasec6 << " should be rejected as a invalid path"; 211} 212 213TEST_F(UtilsTest, IsValidApkPath_TwoSubdirFail) { 214 const char *badasec7 = TEST_ASEC_DIR "com.example.asec/subdir1/pkg.apk"; 215 EXPECT_EQ(-1, validate_apk_path(badasec7)) 216 << badasec7 << " should be rejected as a invalid path"; 217} 218 219TEST_F(UtilsTest, CheckSystemApp_Dir1) { 220 const char *sysapp1 = TEST_SYSTEM_DIR1 "Voice.apk"; 221 EXPECT_EQ(0, validate_system_app_path(sysapp1)) 222 << sysapp1 << " should be allowed as a system path"; 223} 224 225TEST_F(UtilsTest, CheckSystemApp_Dir2) { 226 const char *sysapp2 = TEST_SYSTEM_DIR2 "com.example.myapp.apk"; 227 EXPECT_EQ(0, validate_system_app_path(sysapp2)) 228 << sysapp2 << " should be allowed as a system path"; 229} 230 231TEST_F(UtilsTest, CheckSystemApp_EscapeFail) { 232 const char *badapp1 = TEST_SYSTEM_DIR1 "../com.example.apk"; 233 EXPECT_EQ(-1, validate_system_app_path(badapp1)) 234 << badapp1 << " should be rejected not a system path"; 235} 236 237TEST_F(UtilsTest, CheckSystemApp_DoubleEscapeFail) { 238 const char *badapp2 = TEST_SYSTEM_DIR2 "/../../com.example.apk"; 239 EXPECT_EQ(-1, validate_system_app_path(badapp2)) 240 << badapp2 << " should be rejected not a system path"; 241} 242 243TEST_F(UtilsTest, CheckSystemApp_BadPathEscapeFail) { 244 const char *badapp3 = TEST_APP_DIR "/../../com.example.apk"; 245 EXPECT_EQ(-1, validate_system_app_path(badapp3)) 246 << badapp3 << " should be rejected not a system path"; 247} 248 249TEST_F(UtilsTest, CheckSystemApp_Subdir) { 250 const char *sysapp = TEST_SYSTEM_DIR1 "com.example/com.example.apk"; 251 EXPECT_EQ(0, validate_system_app_path(sysapp)) 252 << sysapp << " should be allowed as a system path"; 253 254 const char *badapp = TEST_SYSTEM_DIR1 "com.example/subdir/com.example.apk"; 255 EXPECT_EQ(-1, validate_system_app_path(badapp)) 256 << badapp << " should be rejected not a system path"; 257 258 const char *badapp1 = TEST_SYSTEM_DIR1 "com.example/subdir/../com.example.apk"; 259 EXPECT_EQ(-1, validate_system_app_path(badapp1)) 260 << badapp1 << " should be rejected not a system path"; 261 262 const char *badapp2 = TEST_SYSTEM_DIR1 "com.example1/../com.example2/com.example.apk"; 263 EXPECT_EQ(-1, validate_system_app_path(badapp2)) 264 << badapp2 << " should be rejected not a system path"; 265} 266 267TEST_F(UtilsTest, GetPathFromString_NullPathFail) { 268 dir_rec_t test1; 269 EXPECT_EQ(-1, get_path_from_string(&test1, (const char *) NULL)) 270 << "Should not allow NULL as a path."; 271} 272 273TEST_F(UtilsTest, GetPathFromString_EmptyPathFail) { 274 dir_rec_t test1; 275 EXPECT_EQ(-1, get_path_from_string(&test1, "")) 276 << "Should not allow empty paths."; 277} 278 279TEST_F(UtilsTest, GetPathFromString_RelativePathFail) { 280 dir_rec_t test1; 281 EXPECT_EQ(-1, get_path_from_string(&test1, "mnt/asec")) 282 << "Should not allow relative paths."; 283} 284 285TEST_F(UtilsTest, GetPathFromString_NonCanonical) { 286 dir_rec_t test1; 287 288 EXPECT_EQ(0, get_path_from_string(&test1, "/mnt/asec")) 289 << "Should be able to canonicalize directory /mnt/asec"; 290 EXPECT_STREQ("/mnt/asec/", test1.path) 291 << "/mnt/asec should be canonicalized to /mnt/asec/"; 292 EXPECT_EQ(10, (ssize_t) test1.len) 293 << "path len should be equal to the length of /mnt/asec/ (10)"; 294 free(test1.path); 295} 296 297TEST_F(UtilsTest, GetPathFromString_CanonicalPath) { 298 dir_rec_t test3; 299 EXPECT_EQ(0, get_path_from_string(&test3, "/data/app/")) 300 << "Should be able to canonicalize directory /data/app/"; 301 EXPECT_STREQ("/data/app/", test3.path) 302 << "/data/app/ should be canonicalized to /data/app/"; 303 EXPECT_EQ(10, (ssize_t) test3.len) 304 << "path len should be equal to the length of /data/app/ (10)"; 305 free(test3.path); 306} 307 308TEST_F(UtilsTest, CreatePkgPath_LongPkgNameSuccess) { 309 char path[PKG_PATH_MAX]; 310 311 // Create long packagename of "aaaaa..." 312 size_t pkgnameSize = PKG_NAME_MAX; 313 char pkgname[pkgnameSize + 1]; 314 memset(pkgname, 'a', pkgnameSize); 315 pkgname[pkgnameSize] = '\0'; 316 317 EXPECT_EQ(0, create_pkg_path(path, pkgname, "", 0)) 318 << "Should successfully be able to create package name."; 319 320 const char *prefix = TEST_DATA_DIR PRIMARY_USER_PREFIX; 321 size_t offset = strlen(prefix); 322 EXPECT_STREQ(pkgname, path + offset) 323 << "Package path should be a really long string of a's"; 324} 325 326TEST_F(UtilsTest, CreatePkgPath_LongPkgNameFail) { 327 char path[PKG_PATH_MAX]; 328 329 // Create long packagename of "aaaaa..." 330 size_t pkgnameSize = PKG_NAME_MAX + 1; 331 char pkgname[pkgnameSize + 1]; 332 memset(pkgname, 'a', pkgnameSize); 333 pkgname[pkgnameSize] = '\0'; 334 335 EXPECT_EQ(-1, create_pkg_path(path, pkgname, "", 0)) 336 << "Should return error because package name is too long."; 337} 338 339TEST_F(UtilsTest, CreatePkgPath_LongPostfixFail) { 340 char path[PKG_PATH_MAX]; 341 342 // Create long packagename of "aaaaa..." 343 size_t postfixSize = PKG_PATH_MAX; 344 char postfix[postfixSize + 1]; 345 memset(postfix, 'a', postfixSize); 346 postfix[postfixSize] = '\0'; 347 348 EXPECT_EQ(-1, create_pkg_path(path, "com.example.package", postfix, 0)) 349 << "Should return error because postfix is too long."; 350} 351 352TEST_F(UtilsTest, CreatePkgPath_PrimaryUser) { 353 char path[PKG_PATH_MAX]; 354 355 EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 0)) 356 << "Should return error because postfix is too long."; 357 358 EXPECT_STREQ(TEST_DATA_DIR PRIMARY_USER_PREFIX "com.example.package", path) 359 << "Package path should be in /data/data/"; 360} 361 362TEST_F(UtilsTest, CreatePkgPath_SecondaryUser) { 363 char path[PKG_PATH_MAX]; 364 365 EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 1)) 366 << "Should successfully create package path."; 367 368 EXPECT_STREQ(TEST_DATA_DIR SECONDARY_USER_PREFIX "1/com.example.package", path) 369 << "Package path should be in /data/user/"; 370} 371 372TEST_F(UtilsTest, CreatePkgPathInDir_ProtectedDir) { 373 char path[PKG_PATH_MAX]; 374 375 dir_rec_t dir; 376 dir.path = "/data/app-private/"; 377 dir.len = strlen(dir.path); 378 379 EXPECT_EQ(0, create_pkg_path_in_dir(path, &dir, "com.example.package", ".apk")) 380 << "Should successfully create package path."; 381 382 EXPECT_STREQ("/data/app-private/com.example.package.apk", path) 383 << "Package path should be in /data/app-private/"; 384} 385 386TEST_F(UtilsTest, CreatePersonaPath_Primary) { 387 char path[PKG_PATH_MAX]; 388 389 EXPECT_EQ(0, create_user_path(path, 0)) 390 << "Should successfully build primary user path."; 391 392 EXPECT_STREQ("/data/data/", path) 393 << "Primary user should have correct path"; 394} 395 396TEST_F(UtilsTest, CreatePersonaPath_Secondary) { 397 char path[PKG_PATH_MAX]; 398 399 EXPECT_EQ(0, create_user_path(path, 1)) 400 << "Should successfully build primary user path."; 401 402 EXPECT_STREQ("/data/user/1/", path) 403 << "Primary user should have correct path"; 404} 405 406TEST_F(UtilsTest, CreateMovePath_Primary) { 407 char path[PKG_PATH_MAX]; 408 409 EXPECT_EQ(0, create_move_path(path, "com.android.test", "shared_prefs", 0)) 410 << "Should be able to create move path for primary user"; 411 412 EXPECT_STREQ("/data/data/com.android.test/shared_prefs", path) 413 << "Primary user package directory should be created correctly"; 414} 415 416TEST_F(UtilsTest, CreateMovePath_Fail_AppTooLong) { 417 char path[PKG_PATH_MAX]; 418 419 EXPECT_EQ(-1, create_move_path(path, REALLY_LONG_APP_NAME, "shared_prefs", 0)) 420 << "Should fail to create move path for primary user"; 421} 422 423TEST_F(UtilsTest, CreateMovePath_Fail_LeafTooLong) { 424 char path[PKG_PATH_MAX]; 425 426 EXPECT_EQ(-1, create_move_path(path, "com.android.test", REALLY_LONG_LEAF_NAME, 0)) 427 << "Should fail to create move path for primary user"; 428} 429 430TEST_F(UtilsTest, CopyAndAppend_Normal) { 431 //int copy_and_append(dir_rec_t* dst, dir_rec_t* src, char* suffix) 432 dir_rec_t dst; 433 dir_rec_t src; 434 435 src.path = "/data/"; 436 src.len = strlen(src.path); 437 438 EXPECT_EQ(0, copy_and_append(&dst, &src, "app/")) 439 << "Should return error because postfix is too long."; 440 441 EXPECT_STREQ("/data/app/", dst.path) 442 << "Appended path should be correct"; 443 444 EXPECT_EQ(10, (ssize_t) dst.len) 445 << "Appended path should be length of '/data/app/' (10)"; 446} 447 448TEST_F(UtilsTest, AppendAndIncrement_Normal) { 449 size_t dst_size = 10; 450 char dst[dst_size]; 451 char *dstp = dst; 452 const char* src = "FOO"; 453 454 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 455 << "String should append successfully"; 456 457 EXPECT_STREQ("FOO", dst) 458 << "String should append correctly"; 459 460 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 461 << "String should append successfully again"; 462 463 EXPECT_STREQ("FOOFOO", dst) 464 << "String should append correctly again"; 465} 466 467TEST_F(UtilsTest, AppendAndIncrement_TooBig) { 468 size_t dst_size = 5; 469 char dst[dst_size]; 470 char *dstp = dst; 471 const char* src = "FOO"; 472 473 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 474 << "String should append successfully"; 475 476 EXPECT_STREQ("FOO", dst) 477 << "String should append correctly"; 478 479 EXPECT_EQ(-1, append_and_increment(&dstp, src, &dst_size)) 480 << "String should fail because it's too large to fit"; 481} 482 483} 484