blob: ca30f91006feae610ef0553f0381216212b381a7 [file] [log] [blame]
Mike Lockwood94afecf2012-10-24 10:45:23 -07001/*
2** Copyright 2008, The Android Open Source Project
3**
Dave Allisond9370732014-01-30 14:19:23 -08004** 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
Mike Lockwood94afecf2012-10-24 10:45:23 -07007**
Dave Allisond9370732014-01-30 14:19:23 -08008** http://www.apache.org/licenses/LICENSE-2.0
Mike Lockwood94afecf2012-10-24 10:45:23 -07009**
Dave Allisond9370732014-01-30 14:19:23 -080010** 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
Mike Lockwood94afecf2012-10-24 10:45:23 -070014** limitations under the License.
15*/
16
Mark Salyzyn92dc3fc2014-03-12 13:12:44 -070017#include <inttypes.h>
Nick Kralevichd7471292013-02-28 16:59:13 -080018#include <sys/capability.h>
Mike Lockwood94afecf2012-10-24 10:45:23 -070019#include "installd.h"
20#include <diskusage/dirsize.h>
21#include <selinux/android.h>
22
23/* Directory records that are used in execution of commands. */
24dir_rec_t android_data_dir;
25dir_rec_t android_asec_dir;
26dir_rec_t android_app_dir;
27dir_rec_t android_app_private_dir;
28dir_rec_t android_app_lib_dir;
29dir_rec_t android_media_dir;
30dir_rec_array_t android_system_dirs;
31
Robert Craig4d3fd4e2013-03-25 06:33:03 -040032int install(const char *pkgname, uid_t uid, gid_t gid, const char *seinfo)
Mike Lockwood94afecf2012-10-24 10:45:23 -070033{
34 char pkgdir[PKG_PATH_MAX];
35 char libsymlink[PKG_PATH_MAX];
36 char applibdir[PKG_PATH_MAX];
37 struct stat libStat;
38
39 if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
40 ALOGE("invalid uid/gid: %d %d\n", uid, gid);
41 return -1;
42 }
43
44 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, 0)) {
45 ALOGE("cannot create package path\n");
46 return -1;
47 }
48
49 if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, 0)) {
50 ALOGE("cannot create package lib symlink origin path\n");
51 return -1;
52 }
53
54 if (create_pkg_path_in_dir(applibdir, &android_app_lib_dir, pkgname, PKG_DIR_POSTFIX)) {
55 ALOGE("cannot create package lib symlink dest path\n");
56 return -1;
57 }
58
Nick Kralevicha2d838a2013-01-09 16:00:35 -080059 if (mkdir(pkgdir, 0751) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -070060 ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
61 return -1;
62 }
Nick Kralevicha2d838a2013-01-09 16:00:35 -080063 if (chmod(pkgdir, 0751) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -070064 ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
65 unlink(pkgdir);
66 return -1;
67 }
68
69 if (lstat(libsymlink, &libStat) < 0) {
70 if (errno != ENOENT) {
71 ALOGE("couldn't stat lib dir: %s\n", strerror(errno));
72 return -1;
73 }
74 } else {
75 if (S_ISDIR(libStat.st_mode)) {
Narayan Kamath3aee2c52014-06-10 13:16:47 +010076 if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -070077 ALOGE("couldn't delete lib directory during install for: %s", libsymlink);
78 return -1;
79 }
80 } else if (S_ISLNK(libStat.st_mode)) {
81 if (unlink(libsymlink) < 0) {
82 ALOGE("couldn't unlink lib directory during install for: %s", libsymlink);
83 return -1;
84 }
85 }
86 }
87
Stephen Smalley26288202014-02-07 09:16:46 -050088 if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -070089 ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
90 unlink(libsymlink);
91 unlink(pkgdir);
92 return -errno;
93 }
94
Stephen Smalley3a983892014-05-13 12:53:07 -040095 if (symlink(applibdir, libsymlink) < 0) {
96 ALOGE("couldn't symlink directory '%s' -> '%s': %s\n", libsymlink, applibdir,
97 strerror(errno));
98 unlink(pkgdir);
99 return -1;
100 }
101
Mike Lockwood94afecf2012-10-24 10:45:23 -0700102 if (chown(pkgdir, uid, gid) < 0) {
103 ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
104 unlink(libsymlink);
105 unlink(pkgdir);
106 return -1;
107 }
108
109 return 0;
110}
111
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700112int uninstall(const char *pkgname, userid_t userid)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700113{
114 char pkgdir[PKG_PATH_MAX];
115
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700116 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid))
Mike Lockwood94afecf2012-10-24 10:45:23 -0700117 return -1;
118
Dave Allisond9370732014-01-30 14:19:23 -0800119 remove_profile_file(pkgname);
120
Mike Lockwood94afecf2012-10-24 10:45:23 -0700121 /* delete contents AND directory, no exceptions */
122 return delete_dir_contents(pkgdir, 1, NULL);
123}
124
125int renamepkg(const char *oldpkgname, const char *newpkgname)
126{
127 char oldpkgdir[PKG_PATH_MAX];
128 char newpkgdir[PKG_PATH_MAX];
129
130 if (create_pkg_path(oldpkgdir, oldpkgname, PKG_DIR_POSTFIX, 0))
131 return -1;
132 if (create_pkg_path(newpkgdir, newpkgname, PKG_DIR_POSTFIX, 0))
133 return -1;
134
135 if (rename(oldpkgdir, newpkgdir) < 0) {
136 ALOGE("cannot rename dir '%s' to '%s': %s\n", oldpkgdir, newpkgdir, strerror(errno));
137 return -errno;
138 }
139 return 0;
140}
141
142int fix_uid(const char *pkgname, uid_t uid, gid_t gid)
143{
144 char pkgdir[PKG_PATH_MAX];
145 struct stat s;
146 int rc = 0;
147
148 if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
149 ALOGE("invalid uid/gid: %d %d\n", uid, gid);
150 return -1;
151 }
152
153 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, 0)) {
154 ALOGE("cannot create package path\n");
155 return -1;
156 }
157
158 if (stat(pkgdir, &s) < 0) return -1;
159
160 if (s.st_uid != 0 || s.st_gid != 0) {
Mark Salyzyn92dc3fc2014-03-12 13:12:44 -0700161 ALOGE("fixing uid of non-root pkg: %s %" PRIu32 " %" PRIu32 "\n", pkgdir, s.st_uid, s.st_gid);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700162 return -1;
163 }
164
165 if (chmod(pkgdir, 0751) < 0) {
166 ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
167 unlink(pkgdir);
168 return -errno;
169 }
170 if (chown(pkgdir, uid, gid) < 0) {
171 ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
172 unlink(pkgdir);
173 return -errno;
174 }
175
176 return 0;
177}
178
Narayan Kamath3aee2c52014-06-10 13:16:47 +0100179static int lib_dir_matcher(const char* file_name, const int is_dir) {
180 return is_dir && !strcmp(file_name, "lib");
181}
182
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700183int delete_user_data(const char *pkgname, userid_t userid)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700184{
185 char pkgdir[PKG_PATH_MAX];
186
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700187 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid))
Mike Lockwood94afecf2012-10-24 10:45:23 -0700188 return -1;
189
190 /* delete contents, excluding "lib", but not the directory itself */
Narayan Kamath3aee2c52014-06-10 13:16:47 +0100191 return delete_dir_contents(pkgdir, 0, &lib_dir_matcher);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700192}
193
Nick Kraleviche4e91c42013-09-20 12:45:20 -0700194int make_user_data(const char *pkgname, uid_t uid, userid_t userid, const char* seinfo)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700195{
196 char pkgdir[PKG_PATH_MAX];
197 char applibdir[PKG_PATH_MAX];
198 char libsymlink[PKG_PATH_MAX];
199 struct stat libStat;
200
201 // Create the data dir for the package
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700202 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid)) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700203 return -1;
204 }
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700205 if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, userid)) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700206 ALOGE("cannot create package lib symlink origin path\n");
207 return -1;
208 }
209 if (create_pkg_path_in_dir(applibdir, &android_app_lib_dir, pkgname, PKG_DIR_POSTFIX)) {
210 ALOGE("cannot create package lib symlink dest path\n");
211 return -1;
212 }
213
Nick Kralevicha2d838a2013-01-09 16:00:35 -0800214 if (mkdir(pkgdir, 0751) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700215 ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
216 return -errno;
217 }
Nick Kralevicha2d838a2013-01-09 16:00:35 -0800218 if (chmod(pkgdir, 0751) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700219 ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
220 unlink(pkgdir);
221 return -errno;
222 }
223
224 if (lstat(libsymlink, &libStat) < 0) {
225 if (errno != ENOENT) {
226 ALOGE("couldn't stat lib dir for non-primary: %s\n", strerror(errno));
227 unlink(pkgdir);
228 return -1;
229 }
230 } else {
231 if (S_ISDIR(libStat.st_mode)) {
Narayan Kamath3aee2c52014-06-10 13:16:47 +0100232 if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700233 ALOGE("couldn't delete lib directory during install for non-primary: %s",
234 libsymlink);
235 unlink(pkgdir);
236 return -1;
237 }
238 } else if (S_ISLNK(libStat.st_mode)) {
239 if (unlink(libsymlink) < 0) {
240 ALOGE("couldn't unlink lib directory during install for non-primary: %s",
241 libsymlink);
242 unlink(pkgdir);
243 return -1;
244 }
245 }
246 }
247
Stephen Smalley26288202014-02-07 09:16:46 -0500248 if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700249 ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
250 unlink(libsymlink);
251 unlink(pkgdir);
252 return -errno;
253 }
254
Stephen Smalley3a983892014-05-13 12:53:07 -0400255 if (symlink(applibdir, libsymlink) < 0) {
256 ALOGE("couldn't symlink directory for non-primary '%s' -> '%s': %s\n", libsymlink,
257 applibdir, strerror(errno));
258 unlink(pkgdir);
259 return -1;
260 }
261
Mike Lockwood94afecf2012-10-24 10:45:23 -0700262 if (chown(pkgdir, uid, uid) < 0) {
263 ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
264 unlink(libsymlink);
265 unlink(pkgdir);
266 return -errno;
267 }
268
269 return 0;
270}
271
Robin Lee095c7632014-04-25 15:05:19 +0100272int create_user(userid_t userid)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700273{
Robin Lee095c7632014-04-25 15:05:19 +0100274 if (ensure_config_user_dirs(userid) == -1) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700275 return -1;
276 }
277
278 return 0;
279}
280
Robin Lee095c7632014-04-25 15:05:19 +0100281int delete_user(userid_t userid)
282{
283 int status = 0;
284
285 char data_path[PKG_PATH_MAX];
286 if ((create_user_path(data_path, userid) != 0)
287 || (delete_dir_contents(data_path, 1, NULL) != 0)) {
288 status = -1;
289 }
290
291 char media_path[PATH_MAX];
292 if ((create_user_media_path(media_path, userid) != 0)
293 || (delete_dir_contents(media_path, 1, NULL) != 0)) {
294 status = -1;
295 }
296
297 char config_path[PATH_MAX];
298 if ((create_user_config_path(config_path, userid) != 0)
299 || (delete_dir_contents(config_path, 1, NULL) != 0)) {
300 status = -1;
301 }
302
303 return status;
304}
305
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700306int delete_cache(const char *pkgname, userid_t userid)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700307{
308 char cachedir[PKG_PATH_MAX];
309
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700310 if (create_pkg_path(cachedir, pkgname, CACHE_DIR_POSTFIX, userid))
Mike Lockwood94afecf2012-10-24 10:45:23 -0700311 return -1;
312
313 /* delete contents, not the directory, no exceptions */
Narayan Kamath3aee2c52014-06-10 13:16:47 +0100314 return delete_dir_contents(cachedir, 0, NULL);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700315}
316
317/* Try to ensure free_size bytes of storage are available.
318 * Returns 0 on success.
319 * This is rather simple-minded because doing a full LRU would
320 * be potentially memory-intensive, and without atime it would
321 * also require that apps constantly modify file metadata even
322 * when just reading from the cache, which is pretty awful.
323 */
324int free_cache(int64_t free_size)
325{
326 cache_t* cache;
327 int64_t avail;
328 DIR *d;
329 struct dirent *de;
330 char tmpdir[PATH_MAX];
331 char *dirpos;
332
333 avail = data_disk_free();
334 if (avail < 0) return -1;
335
336 ALOGI("free_cache(%" PRId64 ") avail %" PRId64 "\n", free_size, avail);
337 if (avail >= free_size) return 0;
338
339 cache = start_cache_collection();
340
341 // Collect cache files for primary user.
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700342 if (create_user_path(tmpdir, 0) == 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700343 //ALOGI("adding cache files from %s\n", tmpdir);
344 add_cache_files(cache, tmpdir, "cache");
345 }
346
347 // Search for other users and add any cache files from them.
348 snprintf(tmpdir, sizeof(tmpdir), "%s%s", android_data_dir.path,
349 SECONDARY_USER_PREFIX);
350 dirpos = tmpdir + strlen(tmpdir);
351 d = opendir(tmpdir);
352 if (d != NULL) {
353 while ((de = readdir(d))) {
354 if (de->d_type == DT_DIR) {
355 const char *name = de->d_name;
356 /* always skip "." and ".." */
357 if (name[0] == '.') {
358 if (name[1] == 0) continue;
359 if ((name[1] == '.') && (name[2] == 0)) continue;
360 }
361 if ((strlen(name)+(dirpos-tmpdir)) < (sizeof(tmpdir)-1)) {
362 strcpy(dirpos, name);
363 //ALOGI("adding cache files from %s\n", tmpdir);
364 add_cache_files(cache, tmpdir, "cache");
365 } else {
366 ALOGW("Path exceeds limit: %s%s", tmpdir, name);
367 }
368 }
369 }
370 closedir(d);
371 }
372
373 // Collect cache files on external storage for all users (if it is mounted as part
374 // of the internal storage).
375 strcpy(tmpdir, android_media_dir.path);
376 dirpos = tmpdir + strlen(tmpdir);
377 d = opendir(tmpdir);
378 if (d != NULL) {
379 while ((de = readdir(d))) {
380 if (de->d_type == DT_DIR) {
381 const char *name = de->d_name;
382 /* skip any dir that doesn't start with a number, so not a user */
383 if (name[0] < '0' || name[0] > '9') {
384 continue;
385 }
386 if ((strlen(name)+(dirpos-tmpdir)) < (sizeof(tmpdir)-1)) {
387 strcpy(dirpos, name);
388 if (lookup_media_dir(tmpdir, "Android") == 0
389 && lookup_media_dir(tmpdir, "data") == 0) {
390 //ALOGI("adding cache files from %s\n", tmpdir);
391 add_cache_files(cache, tmpdir, "cache");
392 }
393 } else {
394 ALOGW("Path exceeds limit: %s%s", tmpdir, name);
395 }
396 }
397 }
398 closedir(d);
399 }
400
401 clear_cache_files(cache, free_size);
402 finish_cache_collection(cache);
403
404 return data_disk_free() >= free_size ? 0 : -1;
405}
406
Narayan Kamath1b400322014-04-11 13:17:00 +0100407int move_dex(const char *src, const char *dst, const char *instruction_set)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700408{
409 char src_dex[PKG_PATH_MAX];
410 char dst_dex[PKG_PATH_MAX];
411
412 if (validate_apk_path(src)) return -1;
413 if (validate_apk_path(dst)) return -1;
414
Narayan Kamath1b400322014-04-11 13:17:00 +0100415 if (create_cache_path(src_dex, src, instruction_set)) return -1;
416 if (create_cache_path(dst_dex, dst, instruction_set)) return -1;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700417
418 ALOGV("move %s -> %s\n", src_dex, dst_dex);
419 if (rename(src_dex, dst_dex) < 0) {
420 ALOGE("Couldn't move %s: %s\n", src_dex, strerror(errno));
421 return -1;
422 } else {
423 return 0;
424 }
425}
426
Narayan Kamath1b400322014-04-11 13:17:00 +0100427int rm_dex(const char *path, const char *instruction_set)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700428{
429 char dex_path[PKG_PATH_MAX];
430
431 if (validate_apk_path(path)) return -1;
Narayan Kamath1b400322014-04-11 13:17:00 +0100432 if (create_cache_path(dex_path, path, instruction_set)) return -1;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700433
434 ALOGV("unlink %s\n", dex_path);
435 if (unlink(dex_path) < 0) {
436 ALOGE("Couldn't unlink %s: %s\n", dex_path, strerror(errno));
437 return -1;
438 } else {
439 return 0;
440 }
441}
442
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700443int get_size(const char *pkgname, userid_t userid, const char *apkpath,
Dianne Hackborn8b417802013-05-01 18:55:10 -0700444 const char *libdirpath, const char *fwdlock_apkpath, const char *asecpath,
Narayan Kamath1b400322014-04-11 13:17:00 +0100445 const char *instruction_set, int64_t *_codesize, int64_t *_datasize,
446 int64_t *_cachesize, int64_t* _asecsize)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700447{
448 DIR *d;
449 int dfd;
450 struct dirent *de;
451 struct stat s;
452 char path[PKG_PATH_MAX];
453
454 int64_t codesize = 0;
455 int64_t datasize = 0;
456 int64_t cachesize = 0;
457 int64_t asecsize = 0;
458
459 /* count the source apk as code -- but only if it's not
460 * on the /system partition and its not on the sdcard.
461 */
462 if (validate_system_app_path(apkpath) &&
463 strncmp(apkpath, android_asec_dir.path, android_asec_dir.len) != 0) {
464 if (stat(apkpath, &s) == 0) {
465 codesize += stat_size(&s);
466 }
467 }
468 /* count the forward locked apk as code if it is given
469 */
470 if (fwdlock_apkpath != NULL && fwdlock_apkpath[0] != '!') {
471 if (stat(fwdlock_apkpath, &s) == 0) {
472 codesize += stat_size(&s);
473 }
474 }
475 /* count the cached dexfile as code */
Narayan Kamath1b400322014-04-11 13:17:00 +0100476 if (!create_cache_path(path, apkpath, instruction_set)) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700477 if (stat(path, &s) == 0) {
478 codesize += stat_size(&s);
479 }
480 }
481
482 /* add in size of any libraries */
Dianne Hackborn8b417802013-05-01 18:55:10 -0700483 if (libdirpath != NULL && libdirpath[0] != '!') {
484 d = opendir(libdirpath);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700485 if (d != NULL) {
486 dfd = dirfd(d);
487 codesize += calculate_dir_size(dfd);
488 closedir(d);
489 }
490 }
491
492 /* compute asec size if it is given
493 */
494 if (asecpath != NULL && asecpath[0] != '!') {
495 if (stat(asecpath, &s) == 0) {
496 asecsize += stat_size(&s);
497 }
498 }
499
Jeff Sharkeyabe4fe52013-07-10 16:55:46 -0700500 if (create_pkg_path(path, pkgname, PKG_DIR_POSTFIX, userid)) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700501 goto done;
502 }
503
504 d = opendir(path);
505 if (d == NULL) {
506 goto done;
507 }
508 dfd = dirfd(d);
509
510 /* most stuff in the pkgdir is data, except for the "cache"
511 * directory and below, which is cache, and the "lib" directory
512 * and below, which is code...
513 */
514 while ((de = readdir(d))) {
515 const char *name = de->d_name;
516
517 if (de->d_type == DT_DIR) {
518 int subfd;
519 int64_t statsize = 0;
520 int64_t dirsize = 0;
521 /* always skip "." and ".." */
522 if (name[0] == '.') {
523 if (name[1] == 0) continue;
524 if ((name[1] == '.') && (name[2] == 0)) continue;
525 }
526 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
527 statsize = stat_size(&s);
528 }
529 subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY);
530 if (subfd >= 0) {
531 dirsize = calculate_dir_size(subfd);
532 }
533 if(!strcmp(name,"lib")) {
534 codesize += dirsize + statsize;
535 } else if(!strcmp(name,"cache")) {
536 cachesize += dirsize + statsize;
537 } else {
538 datasize += dirsize + statsize;
539 }
540 } else if (de->d_type == DT_LNK && !strcmp(name,"lib")) {
541 // This is the symbolic link to the application's library
542 // code. We'll count this as code instead of data, since
543 // it is not something that the app creates.
544 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
545 codesize += stat_size(&s);
546 }
547 } else {
548 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
549 datasize += stat_size(&s);
550 }
551 }
552 }
553 closedir(d);
554done:
555 *_codesize = codesize;
556 *_datasize = datasize;
557 *_cachesize = cachesize;
558 *_asecsize = asecsize;
559 return 0;
560}
561
562
Narayan Kamath1b400322014-04-11 13:17:00 +0100563int create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700564{
565 char *tmp;
566 int srclen;
567 int dstlen;
568
569 srclen = strlen(src);
570
571 /* demand that we are an absolute path */
572 if ((src == 0) || (src[0] != '/') || strstr(src,"..")) {
573 return -1;
574 }
575
576 if (srclen > PKG_PATH_MAX) { // XXX: PKG_NAME_MAX?
577 return -1;
578 }
579
Dave Allisond9370732014-01-30 14:19:23 -0800580 dstlen = srclen + strlen(DALVIK_CACHE_PREFIX) +
Narayan Kamath1b400322014-04-11 13:17:00 +0100581 strlen(instruction_set) +
582 strlen(DALVIK_CACHE_POSTFIX) + 2;
Dave Allisond9370732014-01-30 14:19:23 -0800583
Mike Lockwood94afecf2012-10-24 10:45:23 -0700584 if (dstlen > PKG_PATH_MAX) {
585 return -1;
586 }
587
Narayan Kamath1b400322014-04-11 13:17:00 +0100588 sprintf(path,"%s%s/%s%s",
Mike Lockwood94afecf2012-10-24 10:45:23 -0700589 DALVIK_CACHE_PREFIX,
Narayan Kamath1b400322014-04-11 13:17:00 +0100590 instruction_set,
Mike Lockwood94afecf2012-10-24 10:45:23 -0700591 src + 1, /* skip the leading / */
592 DALVIK_CACHE_POSTFIX);
Dave Allisond9370732014-01-30 14:19:23 -0800593
Narayan Kamath1b400322014-04-11 13:17:00 +0100594 for(tmp = path + strlen(DALVIK_CACHE_PREFIX) + strlen(instruction_set) + 1; *tmp; tmp++) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700595 if (*tmp == '/') {
596 *tmp = '@';
597 }
598 }
599
600 return 0;
601}
602
603static void run_dexopt(int zip_fd, int odex_fd, const char* input_file_name,
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800604 const char* output_file_name)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700605{
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800606 /* platform-specific flags affecting optimization and verification */
607 char dexopt_flags[PROPERTY_VALUE_MAX];
608 property_get("dalvik.vm.dexopt-flags", dexopt_flags, "");
609 ALOGV("dalvik.vm.dexopt-flags=%s\n", dexopt_flags);
610
Mike Lockwood94afecf2012-10-24 10:45:23 -0700611 static const char* DEX_OPT_BIN = "/system/bin/dexopt";
612 static const int MAX_INT_LEN = 12; // '-'+10dig+'\0' -OR- 0x+8dig
613 char zip_num[MAX_INT_LEN];
614 char odex_num[MAX_INT_LEN];
615
616 sprintf(zip_num, "%d", zip_fd);
617 sprintf(odex_num, "%d", odex_fd);
618
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700619 ALOGV("Running %s in=%s out=%s\n", DEX_OPT_BIN, input_file_name, output_file_name);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700620 execl(DEX_OPT_BIN, DEX_OPT_BIN, "--zip", zip_num, odex_num, input_file_name,
621 dexopt_flags, (char*) NULL);
622 ALOGE("execl(%s) failed: %s\n", DEX_OPT_BIN, strerror(errno));
623}
624
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700625static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name,
Narayan Kamath1b400322014-04-11 13:17:00 +0100626 const char* output_file_name, const char *pkgname, const char *instruction_set)
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700627{
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800628 char dex2oat_flags[PROPERTY_VALUE_MAX];
Calin Juravle4fdff462014-06-06 16:58:43 +0100629 bool have_dex2oat_flags = property_get("dalvik.vm.dex2oat-flags", dex2oat_flags, NULL) > 0;
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800630 ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags);
631
Calin Juravle4fdff462014-06-06 16:58:43 +0100632 char prop_buf[PROPERTY_VALUE_MAX];
633 bool profiler = (property_get("dalvik.vm.profiler", prop_buf, "0") > 0) && (prop_buf[0] == '1');
Calin Juravle57c69c32014-06-06 14:42:16 +0100634
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700635 static const char* DEX2OAT_BIN = "/system/bin/dex2oat";
Brian Carlstrom53e07762014-06-27 14:15:19 -0700636
637 // TODO: Make this memory value configurable with a system property b/15919420
638 static const char* RUNTIME_ARG = "--runtime-arg";
639 static const char* MEMORY_MAX_ARG = "-Xmx512m";
640
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700641 static const int MAX_INT_LEN = 12; // '-'+10dig+'\0' -OR- 0x+8dig
Narayan Kamath1b400322014-04-11 13:17:00 +0100642 static const unsigned int MAX_INSTRUCTION_SET_LEN = 32;
643
644 if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
645 ALOGE("Instruction set %s longer than max length of %d",
646 instruction_set, MAX_INSTRUCTION_SET_LEN);
647 return;
648 }
649
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700650 char zip_fd_arg[strlen("--zip-fd=") + MAX_INT_LEN];
651 char zip_location_arg[strlen("--zip-location=") + PKG_PATH_MAX];
652 char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];
Brian Carlstrom7195fcc2014-06-16 13:28:03 -0700653 char oat_location_arg[strlen("--oat-location=") + PKG_PATH_MAX];
Narayan Kamath1b400322014-04-11 13:17:00 +0100654 char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
Calin Juravle4fdff462014-06-06 16:58:43 +0100655 char profile_file_arg[strlen("--profile-file=") + PKG_PATH_MAX];
656 char top_k_profile_threshold_arg[strlen("--top-k-profile-threshold=") + PROPERTY_VALUE_MAX];
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700657
658 sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
659 sprintf(zip_location_arg, "--zip-location=%s", input_file_name);
660 sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);
661 sprintf(oat_location_arg, "--oat-location=%s", output_file_name);
Narayan Kamath1b400322014-04-11 13:17:00 +0100662 sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
Calin Juravle57c69c32014-06-06 14:42:16 +0100663
Calin Juravle4fdff462014-06-06 16:58:43 +0100664 bool have_profile_file = false;
665 bool have_top_k_profile_threshold = false;
Calin Juravle57c69c32014-06-06 14:42:16 +0100666 if (profiler && (strcmp(pkgname, "*") != 0)) {
667 char profile_file[PKG_PATH_MAX];
668 snprintf(profile_file, sizeof(profile_file), "%s/%s",
Dave Allisond9370732014-01-30 14:19:23 -0800669 DALVIK_CACHE_PREFIX "profiles", pkgname);
Calin Juravle57c69c32014-06-06 14:42:16 +0100670 struct stat st;
Calin Juravle4fdff462014-06-06 16:58:43 +0100671 if ((stat(profile_file, &st) == 0) && (st.st_size > 0)) {
Calin Juravle57c69c32014-06-06 14:42:16 +0100672 sprintf(profile_file_arg, "--profile-file=%s", profile_file);
Calin Juravle4fdff462014-06-06 16:58:43 +0100673 have_profile_file = true;
674 if (property_get("dalvik.vm.profile.top-k-thr", prop_buf, NULL) > 0) {
675 snprintf(top_k_profile_threshold_arg, sizeof(top_k_profile_threshold_arg),
676 "--top-k-profile-threshold=%s", prop_buf);
677 have_top_k_profile_threshold = true;
678 }
Calin Juravle57c69c32014-06-06 14:42:16 +0100679 }
Dave Allisond9370732014-01-30 14:19:23 -0800680 }
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700681
682 ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, input_file_name, output_file_name);
Calin Juravle4fdff462014-06-06 16:58:43 +0100683
Brian Carlstrom53e07762014-06-27 14:15:19 -0700684 char* argv[9 // program name, mandatory arguments and the final NULL
Calin Juravle4fdff462014-06-06 16:58:43 +0100685 + (have_profile_file ? 1 : 0)
686 + (have_top_k_profile_threshold ? 1 : 0)
687 + (have_dex2oat_flags ? 1 : 0)];
688 int i = 0;
689 argv[i++] = (char*)DEX2OAT_BIN;
Brian Carlstrom53e07762014-06-27 14:15:19 -0700690 argv[i++] = (char*)RUNTIME_ARG;
691 argv[i++] = (char*)MEMORY_MAX_ARG;
Calin Juravle4fdff462014-06-06 16:58:43 +0100692 argv[i++] = zip_fd_arg;
693 argv[i++] = zip_location_arg;
694 argv[i++] = oat_fd_arg;
695 argv[i++] = oat_location_arg;
696 argv[i++] = instruction_set_arg;
697 if (have_profile_file) {
698 argv[i++] = profile_file_arg;
699 }
700 if (have_top_k_profile_threshold) {
701 argv[i++] = top_k_profile_threshold_arg;
702 }
703 if (have_dex2oat_flags) {
704 argv[i++] = dex2oat_flags;
705 }
706 argv[i] = NULL;
707
708 execv(DEX2OAT_BIN, (char* const *)argv);
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700709 ALOGE("execl(%s) failed: %s\n", DEX2OAT_BIN, strerror(errno));
710}
711
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +0100712static int wait_child(pid_t pid)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700713{
714 int status;
715 pid_t got_pid;
716
Mike Lockwood94afecf2012-10-24 10:45:23 -0700717 while (1) {
718 got_pid = waitpid(pid, &status, 0);
719 if (got_pid == -1 && errno == EINTR) {
720 printf("waitpid interrupted, retrying\n");
721 } else {
722 break;
723 }
724 }
725 if (got_pid != pid) {
726 ALOGW("waitpid failed: wanted %d, got %d: %s\n",
727 (int) pid, (int) got_pid, strerror(errno));
728 return 1;
729 }
730
731 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700732 return 0;
733 } else {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700734 return status; /* always nonzero */
735 }
736}
737
Dave Allisond9370732014-01-30 14:19:23 -0800738int dexopt(const char *apk_path, uid_t uid, int is_public,
Narayan Kamath1b400322014-04-11 13:17:00 +0100739 const char *pkgname, const char *instruction_set)
Mike Lockwood94afecf2012-10-24 10:45:23 -0700740{
741 struct utimbuf ut;
742 struct stat apk_stat, dex_stat;
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700743 char out_path[PKG_PATH_MAX];
Brian Carlstrome7a8b172013-06-30 13:17:38 -0700744 char persist_sys_dalvik_vm_lib[PROPERTY_VALUE_MAX];
Mike Lockwood94afecf2012-10-24 10:45:23 -0700745 char *end;
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700746 int res, zip_fd=-1, out_fd=-1;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700747
Mike Lockwood94afecf2012-10-24 10:45:23 -0700748 if (strlen(apk_path) >= (PKG_PATH_MAX - 8)) {
749 return -1;
750 }
751
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800752 /* The command to run depend on the value of persist.sys.dalvik.vm.lib */
Brian Carlstrom856bc782014-05-28 14:31:47 -0700753 property_get("persist.sys.dalvik.vm.lib.2", persist_sys_dalvik_vm_lib, "libart.so");
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700754
755 /* Before anything else: is there a .odex file? If so, we have
756 * precompiled the apk and there is nothing to do here.
757 */
Chih-Wei Huang0e8ae162014-04-28 15:47:45 +0800758 strcpy(out_path, apk_path);
759 end = strrchr(out_path, '.');
760 if (end != NULL) {
761 strcpy(end, ".odex");
762 if (stat(out_path, &dex_stat) == 0) {
763 return 0;
764 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700765 }
766
Narayan Kamath1b400322014-04-11 13:17:00 +0100767 if (create_cache_path(out_path, apk_path, instruction_set)) {
Mike Lockwood94afecf2012-10-24 10:45:23 -0700768 return -1;
769 }
770
771 memset(&apk_stat, 0, sizeof(apk_stat));
772 stat(apk_path, &apk_stat);
773
774 zip_fd = open(apk_path, O_RDONLY, 0);
775 if (zip_fd < 0) {
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700776 ALOGE("installd cannot open '%s' for input during dexopt\n", apk_path);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700777 return -1;
778 }
779
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700780 unlink(out_path);
781 out_fd = open(out_path, O_RDWR | O_CREAT | O_EXCL, 0644);
782 if (out_fd < 0) {
783 ALOGE("installd cannot open '%s' for output during dexopt\n", out_path);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700784 goto fail;
785 }
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700786 if (fchmod(out_fd,
Mike Lockwood94afecf2012-10-24 10:45:23 -0700787 S_IRUSR|S_IWUSR|S_IRGRP |
788 (is_public ? S_IROTH : 0)) < 0) {
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700789 ALOGE("installd cannot chmod '%s' during dexopt\n", out_path);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700790 goto fail;
791 }
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700792 if (fchown(out_fd, AID_SYSTEM, uid) < 0) {
793 ALOGE("installd cannot chown '%s' during dexopt\n", out_path);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700794 goto fail;
795 }
796
Dave Allisond9370732014-01-30 14:19:23 -0800797 // Create profile file if there is a package name present.
798 if (strcmp(pkgname, "*") != 0) {
799 create_profile_file(pkgname, uid);
800 }
801
802
Mike Lockwood94afecf2012-10-24 10:45:23 -0700803 ALOGV("DexInv: --- BEGIN '%s' ---\n", apk_path);
804
805 pid_t pid;
806 pid = fork();
807 if (pid == 0) {
808 /* child -- drop privileges before continuing */
809 if (setgid(uid) != 0) {
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700810 ALOGE("setgid(%d) failed in installd during dexopt\n", uid);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700811 exit(64);
812 }
813 if (setuid(uid) != 0) {
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700814 ALOGE("setuid(%d) failed in installd during dexopt\n", uid);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700815 exit(65);
816 }
817 // drop capabilities
818 struct __user_cap_header_struct capheader;
819 struct __user_cap_data_struct capdata[2];
820 memset(&capheader, 0, sizeof(capheader));
821 memset(&capdata, 0, sizeof(capdata));
822 capheader.version = _LINUX_CAPABILITY_VERSION_3;
823 if (capset(&capheader, &capdata[0]) < 0) {
824 ALOGE("capset failed: %s\n", strerror(errno));
825 exit(66);
826 }
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700827 if (flock(out_fd, LOCK_EX | LOCK_NB) != 0) {
828 ALOGE("flock(%s) failed: %s\n", out_path, strerror(errno));
Mike Lockwood94afecf2012-10-24 10:45:23 -0700829 exit(67);
830 }
831
Brian Carlstrome7a8b172013-06-30 13:17:38 -0700832 if (strncmp(persist_sys_dalvik_vm_lib, "libdvm", 6) == 0) {
Brian Carlstrom0ae8e392014-02-10 16:42:52 -0800833 run_dexopt(zip_fd, out_fd, apk_path, out_path);
Brian Carlstrome7a8b172013-06-30 13:17:38 -0700834 } else if (strncmp(persist_sys_dalvik_vm_lib, "libart", 6) == 0) {
Narayan Kamath1b400322014-04-11 13:17:00 +0100835 run_dex2oat(zip_fd, out_fd, apk_path, out_path, pkgname, instruction_set);
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700836 } else {
Brian Carlstrome7a8b172013-06-30 13:17:38 -0700837 exit(69); /* Unexpected persist.sys.dalvik.vm.lib value */
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700838 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700839 exit(68); /* only get here on exec failure */
840 } else {
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +0100841 res = wait_child(pid);
842 if (res == 0) {
843 ALOGV("DexInv: --- END '%s' (success) ---\n", apk_path);
844 } else {
845 ALOGE("DexInv: --- END '%s' --- status=0x%04x, process failed\n", apk_path, res);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700846 goto fail;
847 }
848 }
849
850 ut.actime = apk_stat.st_atime;
851 ut.modtime = apk_stat.st_mtime;
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700852 utime(out_path, &ut);
853
854 close(out_fd);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700855 close(zip_fd);
856 return 0;
857
858fail:
Brian Carlstrom1705fc42013-03-21 18:20:22 -0700859 if (out_fd >= 0) {
860 close(out_fd);
861 unlink(out_path);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700862 }
863 if (zip_fd >= 0) {
864 close(zip_fd);
865 }
866 return -1;
867}
868
869void mkinnerdirs(char* path, int basepos, mode_t mode, int uid, int gid,
870 struct stat* statbuf)
871{
872 while (path[basepos] != 0) {
873 if (path[basepos] == '/') {
874 path[basepos] = 0;
875 if (lstat(path, statbuf) < 0) {
876 ALOGV("Making directory: %s\n", path);
877 if (mkdir(path, mode) == 0) {
878 chown(path, uid, gid);
879 } else {
880 ALOGW("Unable to make directory %s: %s\n", path, strerror(errno));
881 }
882 }
883 path[basepos] = '/';
884 basepos++;
885 }
886 basepos++;
887 }
888}
889
890int movefileordir(char* srcpath, char* dstpath, int dstbasepos,
891 int dstuid, int dstgid, struct stat* statbuf)
892{
893 DIR *d;
894 struct dirent *de;
895 int res;
896
897 int srcend = strlen(srcpath);
898 int dstend = strlen(dstpath);
Dave Allisond9370732014-01-30 14:19:23 -0800899
Mike Lockwood94afecf2012-10-24 10:45:23 -0700900 if (lstat(srcpath, statbuf) < 0) {
901 ALOGW("Unable to stat %s: %s\n", srcpath, strerror(errno));
902 return 1;
903 }
Dave Allisond9370732014-01-30 14:19:23 -0800904
Mike Lockwood94afecf2012-10-24 10:45:23 -0700905 if ((statbuf->st_mode&S_IFDIR) == 0) {
906 mkinnerdirs(dstpath, dstbasepos, S_IRWXU|S_IRWXG|S_IXOTH,
907 dstuid, dstgid, statbuf);
908 ALOGV("Renaming %s to %s (uid %d)\n", srcpath, dstpath, dstuid);
909 if (rename(srcpath, dstpath) >= 0) {
910 if (chown(dstpath, dstuid, dstgid) < 0) {
911 ALOGE("cannot chown %s: %s\n", dstpath, strerror(errno));
912 unlink(dstpath);
913 return 1;
914 }
915 } else {
916 ALOGW("Unable to rename %s to %s: %s\n",
917 srcpath, dstpath, strerror(errno));
918 return 1;
919 }
920 return 0;
921 }
922
923 d = opendir(srcpath);
924 if (d == NULL) {
925 ALOGW("Unable to opendir %s: %s\n", srcpath, strerror(errno));
926 return 1;
927 }
928
929 res = 0;
Dave Allisond9370732014-01-30 14:19:23 -0800930
Mike Lockwood94afecf2012-10-24 10:45:23 -0700931 while ((de = readdir(d))) {
932 const char *name = de->d_name;
933 /* always skip "." and ".." */
934 if (name[0] == '.') {
935 if (name[1] == 0) continue;
936 if ((name[1] == '.') && (name[2] == 0)) continue;
937 }
Dave Allisond9370732014-01-30 14:19:23 -0800938
Mike Lockwood94afecf2012-10-24 10:45:23 -0700939 if ((srcend+strlen(name)) >= (PKG_PATH_MAX-2)) {
940 ALOGW("Source path too long; skipping: %s/%s\n", srcpath, name);
941 continue;
942 }
Dave Allisond9370732014-01-30 14:19:23 -0800943
Mike Lockwood94afecf2012-10-24 10:45:23 -0700944 if ((dstend+strlen(name)) >= (PKG_PATH_MAX-2)) {
945 ALOGW("Destination path too long; skipping: %s/%s\n", dstpath, name);
946 continue;
947 }
Dave Allisond9370732014-01-30 14:19:23 -0800948
Mike Lockwood94afecf2012-10-24 10:45:23 -0700949 srcpath[srcend] = dstpath[dstend] = '/';
950 strcpy(srcpath+srcend+1, name);
951 strcpy(dstpath+dstend+1, name);
Dave Allisond9370732014-01-30 14:19:23 -0800952
Mike Lockwood94afecf2012-10-24 10:45:23 -0700953 if (movefileordir(srcpath, dstpath, dstbasepos, dstuid, dstgid, statbuf) != 0) {
954 res = 1;
955 }
Dave Allisond9370732014-01-30 14:19:23 -0800956
Mike Lockwood94afecf2012-10-24 10:45:23 -0700957 // Note: we will be leaving empty directories behind in srcpath,
958 // but that is okay, the package manager will be erasing all of the
959 // data associated with .apks that disappear.
Dave Allisond9370732014-01-30 14:19:23 -0800960
Mike Lockwood94afecf2012-10-24 10:45:23 -0700961 srcpath[srcend] = dstpath[dstend] = 0;
962 }
Dave Allisond9370732014-01-30 14:19:23 -0800963
Mike Lockwood94afecf2012-10-24 10:45:23 -0700964 closedir(d);
965 return res;
966}
967
968int movefiles()
969{
970 DIR *d;
971 int dfd, subfd;
972 struct dirent *de;
973 struct stat s;
974 char buf[PKG_PATH_MAX+1];
975 int bufp, bufe, bufi, readlen;
976
977 char srcpkg[PKG_NAME_MAX];
978 char dstpkg[PKG_NAME_MAX];
979 char srcpath[PKG_PATH_MAX];
980 char dstpath[PKG_PATH_MAX];
981 int dstuid=-1, dstgid=-1;
982 int hasspace;
983
984 d = opendir(UPDATE_COMMANDS_DIR_PREFIX);
985 if (d == NULL) {
986 goto done;
987 }
988 dfd = dirfd(d);
989
990 /* Iterate through all files in the directory, executing the
991 * file movements requested there-in.
992 */
993 while ((de = readdir(d))) {
994 const char *name = de->d_name;
995
996 if (de->d_type == DT_DIR) {
997 continue;
998 } else {
999 subfd = openat(dfd, name, O_RDONLY);
1000 if (subfd < 0) {
1001 ALOGW("Unable to open update commands at %s%s\n",
1002 UPDATE_COMMANDS_DIR_PREFIX, name);
1003 continue;
1004 }
Dave Allisond9370732014-01-30 14:19:23 -08001005
Mike Lockwood94afecf2012-10-24 10:45:23 -07001006 bufp = 0;
1007 bufe = 0;
1008 buf[PKG_PATH_MAX] = 0;
1009 srcpkg[0] = dstpkg[0] = 0;
1010 while (1) {
1011 bufi = bufp;
1012 while (bufi < bufe && buf[bufi] != '\n') {
1013 bufi++;
1014 }
1015 if (bufi < bufe) {
1016 buf[bufi] = 0;
1017 ALOGV("Processing line: %s\n", buf+bufp);
1018 hasspace = 0;
1019 while (bufp < bufi && isspace(buf[bufp])) {
1020 hasspace = 1;
1021 bufp++;
1022 }
1023 if (buf[bufp] == '#' || bufp == bufi) {
1024 // skip comments and empty lines.
1025 } else if (hasspace) {
1026 if (dstpkg[0] == 0) {
1027 ALOGW("Path before package line in %s%s: %s\n",
1028 UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1029 } else if (srcpkg[0] == 0) {
1030 // Skip -- source package no longer exists.
1031 } else {
1032 ALOGV("Move file: %s (from %s to %s)\n", buf+bufp, srcpkg, dstpkg);
1033 if (!create_move_path(srcpath, srcpkg, buf+bufp, 0) &&
1034 !create_move_path(dstpath, dstpkg, buf+bufp, 0)) {
1035 movefileordir(srcpath, dstpath,
1036 strlen(dstpath)-strlen(buf+bufp),
1037 dstuid, dstgid, &s);
1038 }
1039 }
1040 } else {
1041 char* div = strchr(buf+bufp, ':');
1042 if (div == NULL) {
1043 ALOGW("Bad package spec in %s%s; no ':' sep: %s\n",
1044 UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1045 } else {
1046 *div = 0;
1047 div++;
1048 if (strlen(buf+bufp) < PKG_NAME_MAX) {
1049 strcpy(dstpkg, buf+bufp);
1050 } else {
1051 srcpkg[0] = dstpkg[0] = 0;
1052 ALOGW("Package name too long in %s%s: %s\n",
1053 UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1054 }
1055 if (strlen(div) < PKG_NAME_MAX) {
1056 strcpy(srcpkg, div);
1057 } else {
1058 srcpkg[0] = dstpkg[0] = 0;
1059 ALOGW("Package name too long in %s%s: %s\n",
1060 UPDATE_COMMANDS_DIR_PREFIX, name, div);
1061 }
1062 if (srcpkg[0] != 0) {
1063 if (!create_pkg_path(srcpath, srcpkg, PKG_DIR_POSTFIX, 0)) {
1064 if (lstat(srcpath, &s) < 0) {
1065 // Package no longer exists -- skip.
1066 srcpkg[0] = 0;
1067 }
1068 } else {
1069 srcpkg[0] = 0;
1070 ALOGW("Can't create path %s in %s%s\n",
1071 div, UPDATE_COMMANDS_DIR_PREFIX, name);
1072 }
1073 if (srcpkg[0] != 0) {
1074 if (!create_pkg_path(dstpath, dstpkg, PKG_DIR_POSTFIX, 0)) {
1075 if (lstat(dstpath, &s) == 0) {
1076 dstuid = s.st_uid;
1077 dstgid = s.st_gid;
1078 } else {
1079 // Destination package doesn't
1080 // exist... due to original-package,
1081 // this is normal, so don't be
1082 // noisy about it.
1083 srcpkg[0] = 0;
1084 }
1085 } else {
1086 srcpkg[0] = 0;
1087 ALOGW("Can't create path %s in %s%s\n",
1088 div, UPDATE_COMMANDS_DIR_PREFIX, name);
1089 }
1090 }
1091 ALOGV("Transfering from %s to %s: uid=%d\n",
1092 srcpkg, dstpkg, dstuid);
1093 }
1094 }
1095 }
1096 bufp = bufi+1;
1097 } else {
1098 if (bufp == 0) {
1099 if (bufp < bufe) {
1100 ALOGW("Line too long in %s%s, skipping: %s\n",
1101 UPDATE_COMMANDS_DIR_PREFIX, name, buf);
1102 }
1103 } else if (bufp < bufe) {
1104 memcpy(buf, buf+bufp, bufe-bufp);
1105 bufe -= bufp;
1106 bufp = 0;
1107 }
1108 readlen = read(subfd, buf+bufe, PKG_PATH_MAX-bufe);
1109 if (readlen < 0) {
1110 ALOGW("Failure reading update commands in %s%s: %s\n",
1111 UPDATE_COMMANDS_DIR_PREFIX, name, strerror(errno));
1112 break;
1113 } else if (readlen == 0) {
1114 break;
1115 }
1116 bufe += readlen;
1117 buf[bufe] = 0;
1118 ALOGV("Read buf: %s\n", buf);
1119 }
1120 }
1121 close(subfd);
1122 }
1123 }
1124 closedir(d);
1125done:
1126 return 0;
1127}
1128
1129int linklib(const char* pkgname, const char* asecLibDir, int userId)
1130{
1131 char pkgdir[PKG_PATH_MAX];
1132 char libsymlink[PKG_PATH_MAX];
1133 struct stat s, libStat;
1134 int rc = 0;
1135
1136 if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userId)) {
1137 ALOGE("cannot create package path\n");
1138 return -1;
1139 }
1140 if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, userId)) {
1141 ALOGE("cannot create package lib symlink origin path\n");
1142 return -1;
1143 }
1144
1145 if (stat(pkgdir, &s) < 0) return -1;
1146
1147 if (chown(pkgdir, AID_INSTALL, AID_INSTALL) < 0) {
1148 ALOGE("failed to chown '%s': %s\n", pkgdir, strerror(errno));
1149 return -1;
1150 }
1151
1152 if (chmod(pkgdir, 0700) < 0) {
1153 ALOGE("linklib() 1: failed to chmod '%s': %s\n", pkgdir, strerror(errno));
1154 rc = -1;
1155 goto out;
1156 }
1157
1158 if (lstat(libsymlink, &libStat) < 0) {
1159 if (errno != ENOENT) {
1160 ALOGE("couldn't stat lib dir: %s\n", strerror(errno));
1161 rc = -1;
1162 goto out;
1163 }
1164 } else {
1165 if (S_ISDIR(libStat.st_mode)) {
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001166 if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
Mike Lockwood94afecf2012-10-24 10:45:23 -07001167 rc = -1;
1168 goto out;
1169 }
1170 } else if (S_ISLNK(libStat.st_mode)) {
1171 if (unlink(libsymlink) < 0) {
1172 ALOGE("couldn't unlink lib dir: %s\n", strerror(errno));
1173 rc = -1;
1174 goto out;
1175 }
1176 }
1177 }
1178
1179 if (symlink(asecLibDir, libsymlink) < 0) {
1180 ALOGE("couldn't symlink directory '%s' -> '%s': %s\n", libsymlink, asecLibDir,
1181 strerror(errno));
1182 rc = -errno;
1183 goto out;
1184 }
1185
1186out:
1187 if (chmod(pkgdir, s.st_mode) < 0) {
1188 ALOGE("linklib() 2: failed to chmod '%s': %s\n", pkgdir, strerror(errno));
1189 rc = -errno;
1190 }
1191
1192 if (chown(pkgdir, s.st_uid, s.st_gid) < 0) {
1193 ALOGE("failed to chown '%s' : %s\n", pkgdir, strerror(errno));
1194 return -errno;
1195 }
1196
1197 return rc;
1198}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01001199
1200static void run_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
1201{
1202 static const char *IDMAP_BIN = "/system/bin/idmap";
1203 static const size_t MAX_INT_LEN = 32;
1204 char idmap_str[MAX_INT_LEN];
1205
1206 snprintf(idmap_str, sizeof(idmap_str), "%d", idmap_fd);
1207
1208 execl(IDMAP_BIN, IDMAP_BIN, "--fd", target_apk, overlay_apk, idmap_str, (char*)NULL);
1209 ALOGE("execl(%s) failed: %s\n", IDMAP_BIN, strerror(errno));
1210}
1211
1212// Transform string /a/b/c.apk to (prefix)/a@b@c.apk@(suffix)
1213// eg /a/b/c.apk to /data/resource-cache/a@b@c.apk@idmap
1214static int flatten_path(const char *prefix, const char *suffix,
1215 const char *overlay_path, char *idmap_path, size_t N)
1216{
1217 if (overlay_path == NULL || idmap_path == NULL) {
1218 return -1;
1219 }
1220 const size_t len_overlay_path = strlen(overlay_path);
1221 // will access overlay_path + 1 further below; requires absolute path
1222 if (len_overlay_path < 2 || *overlay_path != '/') {
1223 return -1;
1224 }
1225 const size_t len_idmap_root = strlen(prefix);
1226 const size_t len_suffix = strlen(suffix);
1227 if (SIZE_MAX - len_idmap_root < len_overlay_path ||
1228 SIZE_MAX - (len_idmap_root + len_overlay_path) < len_suffix) {
1229 // additions below would cause overflow
1230 return -1;
1231 }
1232 if (N < len_idmap_root + len_overlay_path + len_suffix) {
1233 return -1;
1234 }
1235 memset(idmap_path, 0, N);
1236 snprintf(idmap_path, N, "%s%s%s", prefix, overlay_path + 1, suffix);
1237 char *ch = idmap_path + len_idmap_root;
1238 while (*ch != '\0') {
1239 if (*ch == '/') {
1240 *ch = '@';
1241 }
1242 ++ch;
1243 }
1244 return 0;
1245}
1246
1247int idmap(const char *target_apk, const char *overlay_apk, uid_t uid)
1248{
1249 ALOGV("idmap target_apk=%s overlay_apk=%s uid=%d\n", target_apk, overlay_apk, uid);
1250
1251 int idmap_fd = -1;
1252 char idmap_path[PATH_MAX];
1253
1254 if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
1255 idmap_path, sizeof(idmap_path)) == -1) {
1256 ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
1257 goto fail;
1258 }
1259
1260 unlink(idmap_path);
1261 idmap_fd = open(idmap_path, O_RDWR | O_CREAT | O_EXCL, 0644);
1262 if (idmap_fd < 0) {
1263 ALOGE("idmap cannot open '%s' for output: %s\n", idmap_path, strerror(errno));
1264 goto fail;
1265 }
1266 if (fchown(idmap_fd, AID_SYSTEM, uid) < 0) {
1267 ALOGE("idmap cannot chown '%s'\n", idmap_path);
1268 goto fail;
1269 }
1270 if (fchmod(idmap_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
1271 ALOGE("idmap cannot chmod '%s'\n", idmap_path);
1272 goto fail;
1273 }
1274
1275 pid_t pid;
1276 pid = fork();
1277 if (pid == 0) {
1278 /* child -- drop privileges before continuing */
1279 if (setgid(uid) != 0) {
1280 ALOGE("setgid(%d) failed during idmap\n", uid);
1281 exit(1);
1282 }
1283 if (setuid(uid) != 0) {
1284 ALOGE("setuid(%d) failed during idmap\n", uid);
1285 exit(1);
1286 }
1287 if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
1288 ALOGE("flock(%s) failed during idmap: %s\n", idmap_path, strerror(errno));
1289 exit(1);
1290 }
1291
1292 run_idmap(target_apk, overlay_apk, idmap_fd);
1293 exit(1); /* only if exec call to idmap failed */
1294 } else {
1295 int status = wait_child(pid);
1296 if (status != 0) {
1297 ALOGE("idmap failed, status=0x%04x\n", status);
1298 goto fail;
1299 }
1300 }
1301
1302 close(idmap_fd);
1303 return 0;
1304fail:
1305 if (idmap_fd >= 0) {
1306 close(idmap_fd);
1307 unlink(idmap_path);
1308 }
1309 return -1;
1310}
Robert Craige9887e42014-02-20 10:25:56 -05001311
Robert Craigda30dc72014-03-27 10:21:12 -04001312int restorecon_data(const char* pkgName, const char* seinfo, uid_t uid)
Robert Craige9887e42014-02-20 10:25:56 -05001313{
Robert Craigda30dc72014-03-27 10:21:12 -04001314 struct dirent *entry;
1315 DIR *d;
1316 struct stat s;
1317 char *userdir;
1318 char *primarydir;
1319 char *pkgdir;
Robert Craige9887e42014-02-20 10:25:56 -05001320 int ret = 0;
1321
Robert Craigda30dc72014-03-27 10:21:12 -04001322 // SELINUX_ANDROID_RESTORECON_DATADATA flag is set by libselinux. Not needed here.
1323 unsigned int flags = SELINUX_ANDROID_RESTORECON_RECURSE;
1324
1325 if (!pkgName || !seinfo) {
1326 ALOGE("Package name or seinfo tag is null when trying to restorecon.");
Robert Craige9887e42014-02-20 10:25:56 -05001327 return -1;
1328 }
1329
Robert Craigda30dc72014-03-27 10:21:12 -04001330 if (asprintf(&primarydir, "%s%s%s", android_data_dir.path, PRIMARY_USER_PREFIX, pkgName) < 0) {
1331 return -1;
1332 }
1333
1334 // Relabel for primary user.
1335 if (selinux_android_restorecon_pkgdir(primarydir, seinfo, uid, flags) < 0) {
1336 ALOGE("restorecon failed for %s: %s\n", primarydir, strerror(errno));
Robert Craige9887e42014-02-20 10:25:56 -05001337 ret |= -1;
1338 }
1339
Robert Craigda30dc72014-03-27 10:21:12 -04001340 if (asprintf(&userdir, "%s%s", android_data_dir.path, SECONDARY_USER_PREFIX) < 0) {
1341 free(primarydir);
1342 return -1;
Robert Craige9887e42014-02-20 10:25:56 -05001343 }
1344
Robert Craigda30dc72014-03-27 10:21:12 -04001345 // Relabel package directory for all secondary users.
1346 d = opendir(userdir);
1347 if (d == NULL) {
1348 free(primarydir);
1349 free(userdir);
1350 return -1;
1351 }
1352
1353 while ((entry = readdir(d))) {
1354 if (entry->d_type != DT_DIR) {
1355 continue;
1356 }
1357
1358 const char *user = entry->d_name;
1359 // Ignore "." and ".."
1360 if (!strcmp(user, ".") || !strcmp(user, "..")) {
1361 continue;
1362 }
1363
1364 // user directories start with a number
1365 if (user[0] < '0' || user[0] > '9') {
1366 ALOGE("Expecting numbered directory during restorecon. Instead got '%s'.", user);
1367 continue;
1368 }
1369
1370 if (asprintf(&pkgdir, "%s%s/%s", userdir, user, pkgName) < 0) {
1371 continue;
1372 }
1373
1374 if (stat(pkgdir, &s) < 0) {
1375 free(pkgdir);
1376 continue;
1377 }
1378
1379 if (selinux_android_restorecon_pkgdir(pkgdir, seinfo, uid, flags) < 0) {
1380 ALOGE("restorecon failed for %s: %s\n", pkgdir, strerror(errno));
1381 ret |= -1;
1382 }
1383 free(pkgdir);
1384 }
1385
1386 closedir(d);
1387 free(primarydir);
1388 free(userdir);
Robert Craige9887e42014-02-20 10:25:56 -05001389 return ret;
1390}
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001391
1392static int prune_dex_exclusion_predicate(const char *file_name, const int is_dir)
1393{
Narayan Kamath1e57e4a2014-06-17 12:54:16 +01001394 // Exclude all directories. The top level command will be
1395 // given a list of ISA specific directories that are assumed
1396 // to be flat.
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001397 if (is_dir) {
Narayan Kamath1e57e4a2014-06-17 12:54:16 +01001398 return 1;
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001399 }
1400
1401
1402 // Don't exclude regular files that start with the list
1403 // of prefixes.
1404 static const char data_app_prefix[] = "data@app@";
1405 static const char data_priv_app_prefix[] = "data@priv-app@";
1406 if (!strncmp(file_name, data_app_prefix, sizeof(data_app_prefix) - 1) ||
1407 !strncmp(file_name, data_priv_app_prefix, sizeof(data_priv_app_prefix) - 1)) {
1408 return 0;
1409 }
1410
1411 // Exclude all regular files that don't start with the prefix "data@app@" or
1412 // "data@priv-app@".
1413 return 1;
1414}
1415
Narayan Kamath1e57e4a2014-06-17 12:54:16 +01001416int prune_dex_cache(const char* subdir) {
1417 // "." is handled as a special case, and refers to
1418 // DALVIK_CACHE_PREFIX (usually /data/dalvik-cache).
1419 const bool is_dalvik_cache_root = !strcmp(subdir, ".");
1420
1421 // Don't allow the path to contain "." or ".." except for the
1422 // special case above. This is much stricter than we need to be,
1423 // but there's no good reason to support them.
1424 if (strchr(subdir, '.' ) != NULL && !is_dalvik_cache_root) {
1425 return -1;
1426 }
1427
1428 if (!is_dalvik_cache_root) {
1429 char full_path[PKG_PATH_MAX];
1430 snprintf(full_path, sizeof(full_path), "%s%s", DALVIK_CACHE_PREFIX, subdir);
1431 return delete_dir_contents(full_path, 0, &prune_dex_exclusion_predicate);
1432 }
1433
1434
1435 // When subdir == ".", clean the contents of the top level
1436 // dalvik-cache directory.
1437 return delete_dir_contents(DALVIK_CACHE_PREFIX, 0, &prune_dex_exclusion_predicate);
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001438}