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