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