installd_utils_test.cpp revision fd88ff2edd954117e36372fb095b6f5f35aad0e3 
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
123TEST_F(UtilsTest, IsValidApkPath_Private) {
124    // Internal directories
125    const char *private1 = TEST_APP_PRIVATE_DIR "example.apk";
126    EXPECT_EQ(0, validate_apk_path(private1))
127            << private1 << " should be allowed as a valid path";
128
129    // b/16888084
130    const char *path2 = TEST_APP_DIR "example.com/example.apk";
131    EXPECT_EQ(0, validate_apk_path(path2))
132            << path2 << " should be allowed as a valid path";
133
134    const char *badpriv1 = TEST_APP_PRIVATE_DIR "../example.apk";
135    EXPECT_EQ(-1, validate_apk_path(badpriv1))
136            << badpriv1 << " should be rejected as a invalid path";
137
138    const char *badpriv2 = TEST_APP_PRIVATE_DIR "/../example.apk";
139    EXPECT_EQ(-1, validate_apk_path(badpriv2))
140            << badpriv2 << " should be rejected as a invalid path";
141
142    // Only one subdir should be allowed.
143    const char *bad_path3 = TEST_APP_PRIVATE_DIR "example.com/subdir/pkg.apk";
144    EXPECT_EQ(-1, validate_apk_path(bad_path3))
145            << bad_path3 << " should be rejected as a invalid path";
146}
147
148
149TEST_F(UtilsTest, IsValidApkPath_AsecGood1) {
150    const char *asec1 = TEST_ASEC_DIR "example.apk";
151    EXPECT_EQ(0, validate_apk_path(asec1))
152            << asec1 << " should be allowed as a valid path";
153}
154
155TEST_F(UtilsTest, IsValidApkPath_AsecGood2) {
156    const char *asec2 = TEST_ASEC_DIR "com.example.asec/pkg.apk";
157    EXPECT_EQ(0, validate_apk_path(asec2))
158            << asec2 << " should be allowed as a valid path";
159}
160
161TEST_F(UtilsTest, IsValidApkPath_EscapeFail) {
162    const char *badasec1 = TEST_ASEC_DIR "../example.apk";
163    EXPECT_EQ(-1, validate_apk_path(badasec1))
164            << badasec1 << " should be rejected as a invalid path";
165}
166
167TEST_F(UtilsTest, IsValidApkPath_DoubleSlashFail) {
168    const char *badasec2 = TEST_ASEC_DIR "com.example.asec//pkg.apk";
169    EXPECT_EQ(-1, validate_apk_path(badasec2))
170            << badasec2 << " should be rejected as a invalid path";
171}
172
173TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeFail) {
174    const char *badasec3 = TEST_ASEC_DIR "com.example.asec/../../../pkg.apk";
175    EXPECT_EQ(-1, validate_apk_path(badasec3))
176            << badasec3  << " should be rejected as a invalid path";
177}
178
179TEST_F(UtilsTest, IsValidApkPath_SlashEscapeFail) {
180    const char *badasec4 = TEST_ASEC_DIR "/../example.apk";
181    EXPECT_EQ(-1, validate_apk_path(badasec4))
182            << badasec4 << " should be rejected as a invalid path";
183}
184
185TEST_F(UtilsTest, IsValidApkPath_CrazyDirFail) {
186    const char *badasec5 = TEST_ASEC_DIR ".//../..";
187    EXPECT_EQ(-1, validate_apk_path(badasec5))
188            << badasec5 << " should be rejected as a invalid path";
189}
190
191TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeSingleFail) {
192    const char *badasec6 = TEST_ASEC_DIR "com.example.asec/../pkg.apk";
193    EXPECT_EQ(-1, validate_apk_path(badasec6))
194            << badasec6 << " should be rejected as a invalid path";
195}
196
197TEST_F(UtilsTest, IsValidApkPath_TwoSubdirFail) {
198    const char *badasec7 = TEST_ASEC_DIR "com.example.asec/subdir1/pkg.apk";
199    EXPECT_EQ(-1, validate_apk_path(badasec7))
200            << badasec7 << " should be rejected as a invalid path";
201}
202
203TEST_F(UtilsTest, CheckSystemApp_Dir1) {
204    const char *sysapp1 = TEST_SYSTEM_DIR1 "Voice.apk";
205    EXPECT_EQ(0, validate_system_app_path(sysapp1))
206            << sysapp1 << " should be allowed as a system path";
207}
208
209TEST_F(UtilsTest, CheckSystemApp_Dir2) {
210    const char *sysapp2 = TEST_SYSTEM_DIR2 "com.example.myapp.apk";
211    EXPECT_EQ(0, validate_system_app_path(sysapp2))
212            << sysapp2 << " should be allowed as a system path";
213}
214
215TEST_F(UtilsTest, CheckSystemApp_EscapeFail) {
216    const char *badapp1 = TEST_SYSTEM_DIR1 "../com.example.apk";
217    EXPECT_EQ(-1, validate_system_app_path(badapp1))
218            << badapp1 << " should be rejected not a system path";
219}
220
221TEST_F(UtilsTest, CheckSystemApp_DoubleEscapeFail) {
222    const char *badapp2 = TEST_SYSTEM_DIR2 "/../../com.example.apk";
223    EXPECT_EQ(-1, validate_system_app_path(badapp2))
224            << badapp2 << " should be rejected not a system path";
225}
226
227TEST_F(UtilsTest, CheckSystemApp_BadPathEscapeFail) {
228    const char *badapp3 = TEST_APP_DIR "/../../com.example.apk";
229    EXPECT_EQ(-1, validate_system_app_path(badapp3))
230            << badapp3 << " should be rejected not a system path";
231}
232
233TEST_F(UtilsTest, GetPathFromString_NullPathFail) {
234    dir_rec_t test1;
235    EXPECT_EQ(-1, get_path_from_string(&test1, (const char *) NULL))
236            << "Should not allow NULL as a path.";
237}
238
239TEST_F(UtilsTest, GetPathFromString_EmptyPathFail) {
240    dir_rec_t test1;
241    EXPECT_EQ(-1, get_path_from_string(&test1, ""))
242            << "Should not allow empty paths.";
243}
244
245TEST_F(UtilsTest, GetPathFromString_RelativePathFail) {
246    dir_rec_t test1;
247    EXPECT_EQ(-1, get_path_from_string(&test1, "mnt/asec"))
248            << "Should not allow relative paths.";
249}
250
251TEST_F(UtilsTest, GetPathFromString_NonCanonical) {
252    dir_rec_t test1;
253
254    EXPECT_EQ(0, get_path_from_string(&test1, "/mnt/asec"))
255            << "Should be able to canonicalize directory /mnt/asec";
256    EXPECT_STREQ("/mnt/asec/", test1.path)
257            << "/mnt/asec should be canonicalized to /mnt/asec/";
258    EXPECT_EQ(10, (ssize_t) test1.len)
259            << "path len should be equal to the length of /mnt/asec/ (10)";
260    free(test1.path);
261}
262
263TEST_F(UtilsTest, GetPathFromString_CanonicalPath) {
264    dir_rec_t test3;
265    EXPECT_EQ(0, get_path_from_string(&test3, "/data/app/"))
266            << "Should be able to canonicalize directory /data/app/";
267    EXPECT_STREQ("/data/app/", test3.path)
268            << "/data/app/ should be canonicalized to /data/app/";
269    EXPECT_EQ(10, (ssize_t) test3.len)
270            << "path len should be equal to the length of /data/app/ (10)";
271    free(test3.path);
272}
273
274TEST_F(UtilsTest, CreatePkgPath_LongPkgNameSuccess) {
275    char path[PKG_PATH_MAX];
276
277    // Create long packagename of "aaaaa..."
278    size_t pkgnameSize = PKG_NAME_MAX;
279    char pkgname[pkgnameSize + 1];
280    memset(pkgname, 'a', pkgnameSize);
281    pkgname[pkgnameSize] = '\0';
282
283    EXPECT_EQ(0, create_pkg_path(path, pkgname, "", 0))
284            << "Should successfully be able to create package name.";
285
286    const char *prefix = TEST_DATA_DIR PRIMARY_USER_PREFIX;
287    size_t offset = strlen(prefix);
288    EXPECT_STREQ(pkgname, path + offset)
289             << "Package path should be a really long string of a's";
290}
291
292TEST_F(UtilsTest, CreatePkgPath_LongPkgNameFail) {
293    char path[PKG_PATH_MAX];
294
295    // Create long packagename of "aaaaa..."
296    size_t pkgnameSize = PKG_NAME_MAX + 1;
297    char pkgname[pkgnameSize + 1];
298    memset(pkgname, 'a', pkgnameSize);
299    pkgname[pkgnameSize] = '\0';
300
301    EXPECT_EQ(-1, create_pkg_path(path, pkgname, "", 0))
302            << "Should return error because package name is too long.";
303}
304
305TEST_F(UtilsTest, CreatePkgPath_LongPostfixFail) {
306    char path[PKG_PATH_MAX];
307
308    // Create long packagename of "aaaaa..."
309    size_t postfixSize = PKG_PATH_MAX;
310    char postfix[postfixSize + 1];
311    memset(postfix, 'a', postfixSize);
312    postfix[postfixSize] = '\0';
313
314    EXPECT_EQ(-1, create_pkg_path(path, "com.example.package", postfix, 0))
315            << "Should return error because postfix is too long.";
316}
317
318TEST_F(UtilsTest, CreatePkgPath_PrimaryUser) {
319    char path[PKG_PATH_MAX];
320
321    EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 0))
322            << "Should return error because postfix is too long.";
323
324    EXPECT_STREQ(TEST_DATA_DIR PRIMARY_USER_PREFIX "com.example.package", path)
325            << "Package path should be in /data/data/";
326}
327
328TEST_F(UtilsTest, CreatePkgPath_SecondaryUser) {
329    char path[PKG_PATH_MAX];
330
331    EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 1))
332            << "Should successfully create package path.";
333
334    EXPECT_STREQ(TEST_DATA_DIR SECONDARY_USER_PREFIX "1/com.example.package", path)
335            << "Package path should be in /data/user/";
336}
337
338TEST_F(UtilsTest, CreatePkgPathInDir_ProtectedDir) {
339    char path[PKG_PATH_MAX];
340
341    dir_rec_t dir;
342    dir.path = "/data/app-private/";
343    dir.len = strlen(dir.path);
344
345    EXPECT_EQ(0, create_pkg_path_in_dir(path, &dir, "com.example.package", ".apk"))
346            << "Should successfully create package path.";
347
348    EXPECT_STREQ("/data/app-private/com.example.package.apk", path)
349            << "Package path should be in /data/app-private/";
350}
351
352TEST_F(UtilsTest, CreatePersonaPath_Primary) {
353    char path[PKG_PATH_MAX];
354
355    EXPECT_EQ(0, create_user_path(path, 0))
356            << "Should successfully build primary user path.";
357
358    EXPECT_STREQ("/data/data/", path)
359            << "Primary user should have correct path";
360}
361
362TEST_F(UtilsTest, CreatePersonaPath_Secondary) {
363    char path[PKG_PATH_MAX];
364
365    EXPECT_EQ(0, create_user_path(path, 1))
366            << "Should successfully build primary user path.";
367
368    EXPECT_STREQ("/data/user/1/", path)
369            << "Primary user should have correct path";
370}
371
372TEST_F(UtilsTest, CreateMovePath_Primary) {
373    char path[PKG_PATH_MAX];
374
375    EXPECT_EQ(0, create_move_path(path, "com.android.test", "shared_prefs", 0))
376            << "Should be able to create move path for primary user";
377
378    EXPECT_STREQ("/data/data/com.android.test/shared_prefs", path)
379            << "Primary user package directory should be created correctly";
380}
381
382TEST_F(UtilsTest, CreateMovePath_Fail_AppTooLong) {
383    char path[PKG_PATH_MAX];
384
385    EXPECT_EQ(-1, create_move_path(path, REALLY_LONG_APP_NAME, "shared_prefs", 0))
386            << "Should fail to create move path for primary user";
387}
388
389TEST_F(UtilsTest, CreateMovePath_Fail_LeafTooLong) {
390    char path[PKG_PATH_MAX];
391
392    EXPECT_EQ(-1, create_move_path(path, "com.android.test", REALLY_LONG_LEAF_NAME, 0))
393            << "Should fail to create move path for primary user";
394}
395
396TEST_F(UtilsTest, CopyAndAppend_Normal) {
397    //int copy_and_append(dir_rec_t* dst, dir_rec_t* src, char* suffix)
398    dir_rec_t dst;
399    dir_rec_t src;
400
401    src.path = "/data/";
402    src.len = strlen(src.path);
403
404    EXPECT_EQ(0, copy_and_append(&dst, &src, "app/"))
405            << "Should return error because postfix is too long.";
406
407    EXPECT_STREQ("/data/app/", dst.path)
408            << "Appended path should be correct";
409
410    EXPECT_EQ(10, (ssize_t) dst.len)
411            << "Appended path should be length of '/data/app/' (10)";
412}
413
414TEST_F(UtilsTest, AppendAndIncrement_Normal) {
415    size_t dst_size = 10;
416    char dst[dst_size];
417    char *dstp = dst;
418    const char* src = "FOO";
419
420    EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size))
421            << "String should append successfully";
422
423    EXPECT_STREQ("FOO", dst)
424            << "String should append correctly";
425
426    EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size))
427            << "String should append successfully again";
428
429    EXPECT_STREQ("FOOFOO", dst)
430            << "String should append correctly again";
431}
432
433TEST_F(UtilsTest, AppendAndIncrement_TooBig) {
434    size_t dst_size = 5;
435    char dst[dst_size];
436    char *dstp = dst;
437    const char* src = "FOO";
438
439    EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size))
440            << "String should append successfully";
441
442    EXPECT_STREQ("FOO", dst)
443            << "String should append correctly";
444
445    EXPECT_EQ(-1, append_and_increment(&dstp, src, &dst_size))
446            << "String should fail because it's too large to fit";
447}
448
449}
450