commands.c revision e18987efb5e39ca1bed15527b7b82bde55c99669 
1/*
2** Copyright 2008, 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 <inttypes.h>
18#include <sys/capability.h>
19#include "installd.h"
20#include <cutils/sched_policy.h>
21#include <diskusage/dirsize.h>
22#include <selinux/android.h>
23
24/* Directory records that are used in execution of commands. */
25dir_rec_t android_data_dir;
26dir_rec_t android_asec_dir;
27dir_rec_t android_app_dir;
28dir_rec_t android_app_private_dir;
29dir_rec_t android_app_lib_dir;
30dir_rec_t android_media_dir;
31dir_rec_array_t android_system_dirs;
32
33int install(const char *pkgname, uid_t uid, gid_t gid, const char *seinfo)
34{
35    char pkgdir[PKG_PATH_MAX];
36    char libsymlink[PKG_PATH_MAX];
37    char applibdir[PKG_PATH_MAX];
38    struct stat libStat;
39
40    if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
41        ALOGE("invalid uid/gid: %d %d\n", uid, gid);
42        return -1;
43    }
44
45    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, 0)) {
46        ALOGE("cannot create package path\n");
47        return -1;
48    }
49
50    if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, 0)) {
51        ALOGE("cannot create package lib symlink origin path\n");
52        return -1;
53    }
54
55    if (create_pkg_path_in_dir(applibdir, &android_app_lib_dir, pkgname, PKG_DIR_POSTFIX)) {
56        ALOGE("cannot create package lib symlink dest path\n");
57        return -1;
58    }
59
60    if (mkdir(pkgdir, 0751) < 0) {
61        ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
62        return -1;
63    }
64    if (chmod(pkgdir, 0751) < 0) {
65        ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
66        unlink(pkgdir);
67        return -1;
68    }
69
70    if (lstat(libsymlink, &libStat) < 0) {
71        if (errno != ENOENT) {
72            ALOGE("couldn't stat lib dir: %s\n", strerror(errno));
73            return -1;
74        }
75    } else {
76        if (S_ISDIR(libStat.st_mode)) {
77            if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
78                ALOGE("couldn't delete lib directory during install for: %s", libsymlink);
79                return -1;
80            }
81        } else if (S_ISLNK(libStat.st_mode)) {
82            if (unlink(libsymlink) < 0) {
83                ALOGE("couldn't unlink lib directory during install for: %s", libsymlink);
84                return -1;
85            }
86        }
87    }
88
89    if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
90        ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
91        unlink(libsymlink);
92        unlink(pkgdir);
93        return -errno;
94    }
95
96    if (symlink(applibdir, libsymlink) < 0) {
97        ALOGE("couldn't symlink directory '%s' -> '%s': %s\n", libsymlink, applibdir,
98                strerror(errno));
99        unlink(pkgdir);
100        return -1;
101    }
102
103    if (chown(pkgdir, uid, gid) < 0) {
104        ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
105        unlink(libsymlink);
106        unlink(pkgdir);
107        return -1;
108    }
109
110    return 0;
111}
112
113int uninstall(const char *pkgname, userid_t userid)
114{
115    char pkgdir[PKG_PATH_MAX];
116
117    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid))
118        return -1;
119
120    remove_profile_file(pkgname);
121
122    /* delete contents AND directory, no exceptions */
123    return delete_dir_contents(pkgdir, 1, NULL);
124}
125
126int renamepkg(const char *oldpkgname, const char *newpkgname)
127{
128    char oldpkgdir[PKG_PATH_MAX];
129    char newpkgdir[PKG_PATH_MAX];
130
131    if (create_pkg_path(oldpkgdir, oldpkgname, PKG_DIR_POSTFIX, 0))
132        return -1;
133    if (create_pkg_path(newpkgdir, newpkgname, PKG_DIR_POSTFIX, 0))
134        return -1;
135
136    if (rename(oldpkgdir, newpkgdir) < 0) {
137        ALOGE("cannot rename dir '%s' to '%s': %s\n", oldpkgdir, newpkgdir, strerror(errno));
138        return -errno;
139    }
140    return 0;
141}
142
143int fix_uid(const char *pkgname, uid_t uid, gid_t gid)
144{
145    char pkgdir[PKG_PATH_MAX];
146    struct stat s;
147    int rc = 0;
148
149    if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
150        ALOGE("invalid uid/gid: %d %d\n", uid, gid);
151        return -1;
152    }
153
154    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, 0)) {
155        ALOGE("cannot create package path\n");
156        return -1;
157    }
158
159    if (stat(pkgdir, &s) < 0) return -1;
160
161    if (s.st_uid != 0 || s.st_gid != 0) {
162        ALOGE("fixing uid of non-root pkg: %s %" PRIu32 " %" PRIu32 "\n", pkgdir, s.st_uid, s.st_gid);
163        return -1;
164    }
165
166    if (chmod(pkgdir, 0751) < 0) {
167        ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
168        unlink(pkgdir);
169        return -errno;
170    }
171    if (chown(pkgdir, uid, gid) < 0) {
172        ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
173        unlink(pkgdir);
174        return -errno;
175    }
176
177    return 0;
178}
179
180static int lib_dir_matcher(const char* file_name, const int is_dir) {
181  return is_dir && !strcmp(file_name, "lib");
182}
183
184int delete_user_data(const char *pkgname, userid_t userid)
185{
186    char pkgdir[PKG_PATH_MAX];
187
188    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid))
189        return -1;
190
191    /* delete contents, excluding "lib", but not the directory itself */
192    return delete_dir_contents(pkgdir, 0, &lib_dir_matcher);
193}
194
195int make_user_data(const char *pkgname, uid_t uid, userid_t userid, const char* seinfo)
196{
197    char pkgdir[PKG_PATH_MAX];
198    char applibdir[PKG_PATH_MAX];
199    char libsymlink[PKG_PATH_MAX];
200    struct stat libStat;
201
202    // Create the data dir for the package
203    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userid)) {
204        return -1;
205    }
206    if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, userid)) {
207        ALOGE("cannot create package lib symlink origin path\n");
208        return -1;
209    }
210    if (create_pkg_path_in_dir(applibdir, &android_app_lib_dir, pkgname, PKG_DIR_POSTFIX)) {
211        ALOGE("cannot create package lib symlink dest path\n");
212        return -1;
213    }
214
215    if (mkdir(pkgdir, 0751) < 0) {
216        ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
217        return -errno;
218    }
219    if (chmod(pkgdir, 0751) < 0) {
220        ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
221        unlink(pkgdir);
222        return -errno;
223    }
224
225    if (lstat(libsymlink, &libStat) < 0) {
226        if (errno != ENOENT) {
227            ALOGE("couldn't stat lib dir for non-primary: %s\n", strerror(errno));
228            unlink(pkgdir);
229            return -1;
230        }
231    } else {
232        if (S_ISDIR(libStat.st_mode)) {
233            if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
234                ALOGE("couldn't delete lib directory during install for non-primary: %s",
235                        libsymlink);
236                unlink(pkgdir);
237                return -1;
238            }
239        } else if (S_ISLNK(libStat.st_mode)) {
240            if (unlink(libsymlink) < 0) {
241                ALOGE("couldn't unlink lib directory during install for non-primary: %s",
242                        libsymlink);
243                unlink(pkgdir);
244                return -1;
245            }
246        }
247    }
248
249    if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
250        ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
251        unlink(libsymlink);
252        unlink(pkgdir);
253        return -errno;
254    }
255
256    if (symlink(applibdir, libsymlink) < 0) {
257        ALOGE("couldn't symlink directory for non-primary '%s' -> '%s': %s\n", libsymlink,
258                applibdir, strerror(errno));
259        unlink(pkgdir);
260        return -1;
261    }
262
263    if (chown(pkgdir, uid, uid) < 0) {
264        ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
265        unlink(libsymlink);
266        unlink(pkgdir);
267        return -errno;
268    }
269
270    return 0;
271}
272
273int make_user_config(userid_t userid)
274{
275    if (ensure_config_user_dirs(userid) == -1) {
276        return -1;
277    }
278
279    return 0;
280}
281
282int delete_user(userid_t userid)
283{
284    int status = 0;
285
286    char data_path[PKG_PATH_MAX];
287    if ((create_user_path(data_path, userid) != 0)
288            || (delete_dir_contents(data_path, 1, NULL) != 0)) {
289        status = -1;
290    }
291
292    char media_path[PATH_MAX];
293    if ((create_user_media_path(media_path, userid) != 0)
294            || (delete_dir_contents(media_path, 1, NULL) != 0)) {
295        status = -1;
296    }
297
298    char config_path[PATH_MAX];
299    if ((create_user_config_path(config_path, userid) != 0)
300            || (delete_dir_contents(config_path, 1, NULL) != 0)) {
301        status = -1;
302    }
303
304    return status;
305}
306
307int delete_cache(const char *pkgname, userid_t userid)
308{
309    char cachedir[PKG_PATH_MAX];
310
311    if (create_pkg_path(cachedir, pkgname, CACHE_DIR_POSTFIX, userid))
312        return -1;
313
314    /* delete contents, not the directory, no exceptions */
315    return delete_dir_contents(cachedir, 0, NULL);
316}
317
318int delete_code_cache(const char *pkgname, userid_t userid)
319{
320    char codecachedir[PKG_PATH_MAX];
321
322    if (create_pkg_path(codecachedir, pkgname, CODE_CACHE_DIR_POSTFIX, userid))
323        return -1;
324
325    /* delete contents, not the directory, no exceptions */
326    return delete_dir_contents(codecachedir, 0, NULL);
327}
328
329/* Try to ensure free_size bytes of storage are available.
330 * Returns 0 on success.
331 * This is rather simple-minded because doing a full LRU would
332 * be potentially memory-intensive, and without atime it would
333 * also require that apps constantly modify file metadata even
334 * when just reading from the cache, which is pretty awful.
335 */
336int free_cache(int64_t free_size)
337{
338    cache_t* cache;
339    int64_t avail;
340    DIR *d;
341    struct dirent *de;
342    char tmpdir[PATH_MAX];
343    char *dirpos;
344
345    avail = data_disk_free();
346    if (avail < 0) return -1;
347
348    ALOGI("free_cache(%" PRId64 ") avail %" PRId64 "\n", free_size, avail);
349    if (avail >= free_size) return 0;
350
351    cache = start_cache_collection();
352
353    // Collect cache files for primary user.
354    if (create_user_path(tmpdir, 0) == 0) {
355        //ALOGI("adding cache files from %s\n", tmpdir);
356        add_cache_files(cache, tmpdir, "cache");
357    }
358
359    // Search for other users and add any cache files from them.
360    snprintf(tmpdir, sizeof(tmpdir), "%s%s", android_data_dir.path,
361            SECONDARY_USER_PREFIX);
362    dirpos = tmpdir + strlen(tmpdir);
363    d = opendir(tmpdir);
364    if (d != NULL) {
365        while ((de = readdir(d))) {
366            if (de->d_type == DT_DIR) {
367                const char *name = de->d_name;
368                    /* always skip "." and ".." */
369                if (name[0] == '.') {
370                    if (name[1] == 0) continue;
371                    if ((name[1] == '.') && (name[2] == 0)) continue;
372                }
373                if ((strlen(name)+(dirpos-tmpdir)) < (sizeof(tmpdir)-1)) {
374                    strcpy(dirpos, name);
375                    //ALOGI("adding cache files from %s\n", tmpdir);
376                    add_cache_files(cache, tmpdir, "cache");
377                } else {
378                    ALOGW("Path exceeds limit: %s%s", tmpdir, name);
379                }
380            }
381        }
382        closedir(d);
383    }
384
385    // Collect cache files on external storage for all users (if it is mounted as part
386    // of the internal storage).
387    strcpy(tmpdir, android_media_dir.path);
388    dirpos = tmpdir + strlen(tmpdir);
389    d = opendir(tmpdir);
390    if (d != NULL) {
391        while ((de = readdir(d))) {
392            if (de->d_type == DT_DIR) {
393                const char *name = de->d_name;
394                    /* skip any dir that doesn't start with a number, so not a user */
395                if (name[0] < '0' || name[0] > '9') {
396                    continue;
397                }
398                if ((strlen(name)+(dirpos-tmpdir)) < (sizeof(tmpdir)-1)) {
399                    strcpy(dirpos, name);
400                    if (lookup_media_dir(tmpdir, "Android") == 0
401                            && lookup_media_dir(tmpdir, "data") == 0) {
402                        //ALOGI("adding cache files from %s\n", tmpdir);
403                        add_cache_files(cache, tmpdir, "cache");
404                    }
405                } else {
406                    ALOGW("Path exceeds limit: %s%s", tmpdir, name);
407                }
408            }
409        }
410        closedir(d);
411    }
412
413    clear_cache_files(cache, free_size);
414    finish_cache_collection(cache);
415
416    return data_disk_free() >= free_size ? 0 : -1;
417}
418
419int move_dex(const char *src, const char *dst, const char *instruction_set)
420{
421    char src_dex[PKG_PATH_MAX];
422    char dst_dex[PKG_PATH_MAX];
423
424    if (validate_apk_path(src)) return -1;
425    if (validate_apk_path(dst)) return -1;
426
427    if (create_cache_path(src_dex, src, instruction_set)) return -1;
428    if (create_cache_path(dst_dex, dst, instruction_set)) return -1;
429
430    ALOGV("move %s -> %s\n", src_dex, dst_dex);
431    if (rename(src_dex, dst_dex) < 0) {
432        ALOGE("Couldn't move %s: %s\n", src_dex, strerror(errno));
433        return -1;
434    } else {
435        return 0;
436    }
437}
438
439int rm_dex(const char *path, const char *instruction_set)
440{
441    char dex_path[PKG_PATH_MAX];
442
443    if (validate_apk_path(path)) return -1;
444    if (create_cache_path(dex_path, path, instruction_set)) return -1;
445
446    ALOGV("unlink %s\n", dex_path);
447    if (unlink(dex_path) < 0) {
448        ALOGE("Couldn't unlink %s: %s\n", dex_path, strerror(errno));
449        return -1;
450    } else {
451        return 0;
452    }
453}
454
455int get_size(const char *pkgname, userid_t userid, const char *apkpath,
456             const char *libdirpath, const char *fwdlock_apkpath, const char *asecpath,
457             const char *instruction_set, int64_t *_codesize, int64_t *_datasize,
458             int64_t *_cachesize, int64_t* _asecsize)
459{
460    DIR *d;
461    int dfd;
462    struct dirent *de;
463    struct stat s;
464    char path[PKG_PATH_MAX];
465
466    int64_t codesize = 0;
467    int64_t datasize = 0;
468    int64_t cachesize = 0;
469    int64_t asecsize = 0;
470
471        /* count the source apk as code -- but only if it's not
472         * on the /system partition and its not on the sdcard.
473         */
474    if (validate_system_app_path(apkpath) &&
475            strncmp(apkpath, android_asec_dir.path, android_asec_dir.len) != 0) {
476        if (stat(apkpath, &s) == 0) {
477            codesize += stat_size(&s);
478        }
479    }
480        /* count the forward locked apk as code if it is given
481         */
482    if (fwdlock_apkpath != NULL && fwdlock_apkpath[0] != '!') {
483        if (stat(fwdlock_apkpath, &s) == 0) {
484            codesize += stat_size(&s);
485        }
486    }
487        /* count the cached dexfile as code */
488    if (!create_cache_path(path, apkpath, instruction_set)) {
489        if (stat(path, &s) == 0) {
490            codesize += stat_size(&s);
491        }
492    }
493
494        /* add in size of any libraries */
495    if (libdirpath != NULL && libdirpath[0] != '!') {
496        d = opendir(libdirpath);
497        if (d != NULL) {
498            dfd = dirfd(d);
499            codesize += calculate_dir_size(dfd);
500            closedir(d);
501        }
502    }
503
504        /* compute asec size if it is given
505         */
506    if (asecpath != NULL && asecpath[0] != '!') {
507        if (stat(asecpath, &s) == 0) {
508            asecsize += stat_size(&s);
509        }
510    }
511
512    if (create_pkg_path(path, pkgname, PKG_DIR_POSTFIX, userid)) {
513        goto done;
514    }
515
516    d = opendir(path);
517    if (d == NULL) {
518        goto done;
519    }
520    dfd = dirfd(d);
521
522    /* most stuff in the pkgdir is data, except for the "cache"
523     * directory and below, which is cache, and the "lib" directory
524     * and below, which is code...
525     */
526    while ((de = readdir(d))) {
527        const char *name = de->d_name;
528
529        if (de->d_type == DT_DIR) {
530            int subfd;
531            int64_t statsize = 0;
532            int64_t dirsize = 0;
533                /* always skip "." and ".." */
534            if (name[0] == '.') {
535                if (name[1] == 0) continue;
536                if ((name[1] == '.') && (name[2] == 0)) continue;
537            }
538            if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
539                statsize = stat_size(&s);
540            }
541            subfd = openat(dfd, name, O_RDONLY | O_DIRECTORY);
542            if (subfd >= 0) {
543                dirsize = calculate_dir_size(subfd);
544            }
545            if(!strcmp(name,"lib")) {
546                codesize += dirsize + statsize;
547            } else if(!strcmp(name,"cache")) {
548                cachesize += dirsize + statsize;
549            } else {
550                datasize += dirsize + statsize;
551            }
552        } else if (de->d_type == DT_LNK && !strcmp(name,"lib")) {
553            // This is the symbolic link to the application's library
554            // code.  We'll count this as code instead of data, since
555            // it is not something that the app creates.
556            if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
557                codesize += stat_size(&s);
558            }
559        } else {
560            if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
561                datasize += stat_size(&s);
562            }
563        }
564    }
565    closedir(d);
566done:
567    *_codesize = codesize;
568    *_datasize = datasize;
569    *_cachesize = cachesize;
570    *_asecsize = asecsize;
571    return 0;
572}
573
574int create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set)
575{
576    char *tmp;
577    int srclen;
578    int dstlen;
579
580    srclen = strlen(src);
581
582        /* demand that we are an absolute path */
583    if ((src == 0) || (src[0] != '/') || strstr(src,"..")) {
584        return -1;
585    }
586
587    if (srclen > PKG_PATH_MAX) {        // XXX: PKG_NAME_MAX?
588        return -1;
589    }
590
591    dstlen = srclen + strlen(DALVIK_CACHE_PREFIX) +
592        strlen(instruction_set) +
593        strlen(DALVIK_CACHE_POSTFIX) + 2;
594
595    if (dstlen > PKG_PATH_MAX) {
596        return -1;
597    }
598
599    sprintf(path,"%s%s/%s%s",
600            DALVIK_CACHE_PREFIX,
601            instruction_set,
602            src + 1, /* skip the leading / */
603            DALVIK_CACHE_POSTFIX);
604
605    for(tmp = path + strlen(DALVIK_CACHE_PREFIX) + strlen(instruction_set) + 1; *tmp; tmp++) {
606        if (*tmp == '/') {
607            *tmp = '@';
608        }
609    }
610
611    return 0;
612}
613
614static void run_dexopt(int zip_fd, int odex_fd, const char* input_file_name,
615    const char* output_file_name)
616{
617    /* platform-specific flags affecting optimization and verification */
618    char dexopt_flags[PROPERTY_VALUE_MAX];
619    property_get("dalvik.vm.dexopt-flags", dexopt_flags, "");
620    ALOGV("dalvik.vm.dexopt-flags=%s\n", dexopt_flags);
621
622    static const char* DEX_OPT_BIN = "/system/bin/dexopt";
623    static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig
624    char zip_num[MAX_INT_LEN];
625    char odex_num[MAX_INT_LEN];
626
627    sprintf(zip_num, "%d", zip_fd);
628    sprintf(odex_num, "%d", odex_fd);
629
630    ALOGV("Running %s in=%s out=%s\n", DEX_OPT_BIN, input_file_name, output_file_name);
631    execl(DEX_OPT_BIN, DEX_OPT_BIN, "--zip", zip_num, odex_num, input_file_name,
632        dexopt_flags, (char*) NULL);
633    ALOGE("execl(%s) failed: %s\n", DEX_OPT_BIN, strerror(errno));
634}
635
636static void run_patchoat(int input_fd, int oat_fd, const char* input_file_name,
637    const char* output_file_name, const char *pkgname, const char *instruction_set)
638{
639    static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig
640    static const unsigned int MAX_INSTRUCTION_SET_LEN = 32;
641
642    static const char* PATCHOAT_BIN = "/system/bin/patchoat";
643    if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
644        ALOGE("Instruction set %s longer than max length of %d",
645              instruction_set, MAX_INSTRUCTION_SET_LEN);
646        return;
647    }
648
649    /* input_file_name/input_fd should be the .odex/.oat file that is precompiled. I think*/
650    char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
651    char output_oat_fd_arg[strlen("--output-oat-fd=") + MAX_INT_LEN];
652    char input_oat_fd_arg[strlen("--input-oat-fd=") + MAX_INT_LEN];
653    const char* patched_image_location_arg = "--patched-image-location=/system/framework/boot.art";
654    // The caller has already gotten all the locks we need.
655    const char* no_lock_arg = "--no-lock-output";
656    sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
657    sprintf(output_oat_fd_arg, "--output-oat-fd=%d", oat_fd);
658    sprintf(input_oat_fd_arg, "--input-oat-fd=%d", input_fd);
659    ALOGE("Running %s isa=%s in-fd=%d (%s) out-fd=%d (%s)\n",
660          PATCHOAT_BIN, instruction_set, input_fd, input_file_name, oat_fd, output_file_name);
661
662    /* patchoat, patched-image-location, no-lock, isa, input-fd, output-fd */
663    char* argv[7];
664    argv[0] = (char*) PATCHOAT_BIN;
665    argv[1] = (char*) patched_image_location_arg;
666    argv[2] = (char*) no_lock_arg;
667    argv[3] = instruction_set_arg;
668    argv[4] = output_oat_fd_arg;
669    argv[5] = input_oat_fd_arg;
670    argv[6] = NULL;
671
672    execv(PATCHOAT_BIN, (char* const *)argv);
673    ALOGE("execv(%s) failed: %s\n", PATCHOAT_BIN, strerror(errno));
674}
675
676static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name,
677    const char* output_file_name, const char *pkgname, const char *instruction_set)
678{
679    char prop_buf[PROPERTY_VALUE_MAX];
680    bool profiler = (property_get("dalvik.vm.profiler", prop_buf, "0") > 0) && (prop_buf[0] == '1');
681
682    char dex2oat_Xms_flag[PROPERTY_VALUE_MAX];
683    bool have_dex2oat_Xms_flag = property_get("dalvik.vm.dex2oat-Xms", dex2oat_Xms_flag, NULL) > 0;
684
685    char dex2oat_Xmx_flag[PROPERTY_VALUE_MAX];
686    bool have_dex2oat_Xmx_flag = property_get("dalvik.vm.dex2oat-Xmx", dex2oat_Xmx_flag, NULL) > 0;
687
688    char dex2oat_compiler_filter_flag[PROPERTY_VALUE_MAX];
689    bool have_dex2oat_compiler_filter_flag = property_get("dalvik.vm.dex2oat-filter",
690                                                          dex2oat_compiler_filter_flag, NULL) > 0;
691
692    char dex2oat_flags[PROPERTY_VALUE_MAX];
693    bool have_dex2oat_flags = property_get("dalvik.vm.dex2oat-flags", dex2oat_flags, NULL) > 0;
694    ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags);
695
696    // If we booting without the real /data, don't spend time compiling.
697    char vold_decrypt[PROPERTY_VALUE_MAX];
698    bool have_vold_decrypt = property_get("vold.decrypt", vold_decrypt, "") > 0;
699    bool skip_compilation = (have_vold_decrypt &&
700                             (strcmp(vold_decrypt, "trigger_restart_min_framework") == 0 ||
701                             (strcmp(vold_decrypt, "1") == 0)));
702
703    static const char* DEX2OAT_BIN = "/system/bin/dex2oat";
704
705    static const char* RUNTIME_ARG = "--runtime-arg";
706
707    static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig
708    static const unsigned int MAX_INSTRUCTION_SET_LEN = 32;
709
710    if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
711        ALOGE("Instruction set %s longer than max length of %d",
712              instruction_set, MAX_INSTRUCTION_SET_LEN);
713        return;
714    }
715
716    char zip_fd_arg[strlen("--zip-fd=") + MAX_INT_LEN];
717    char zip_location_arg[strlen("--zip-location=") + PKG_PATH_MAX];
718    char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];
719    char oat_location_arg[strlen("--oat-location=") + PKG_PATH_MAX];
720    char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
721    char profile_file_arg[strlen("--profile-file=") + PKG_PATH_MAX];
722    char top_k_profile_threshold_arg[strlen("--top-k-profile-threshold=") + PROPERTY_VALUE_MAX];
723    char dex2oat_Xms_arg[strlen("-Xms") + PROPERTY_VALUE_MAX];
724    char dex2oat_Xmx_arg[strlen("-Xmx") + PROPERTY_VALUE_MAX];
725    char dex2oat_compiler_filter_arg[strlen("--compiler-filter=") + PROPERTY_VALUE_MAX];
726
727    sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
728    sprintf(zip_location_arg, "--zip-location=%s", input_file_name);
729    sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);
730    sprintf(oat_location_arg, "--oat-location=%s", output_file_name);
731    sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
732
733    bool have_profile_file = false;
734    bool have_top_k_profile_threshold = false;
735    if (profiler && (strcmp(pkgname, "*") != 0)) {
736        char profile_file[PKG_PATH_MAX];
737        snprintf(profile_file, sizeof(profile_file), "%s/%s",
738                 DALVIK_CACHE_PREFIX "profiles", pkgname);
739        struct stat st;
740        if ((stat(profile_file, &st) == 0) && (st.st_size > 0)) {
741            sprintf(profile_file_arg, "--profile-file=%s", profile_file);
742            have_profile_file = true;
743            if (property_get("dalvik.vm.profile.top-k-thr", prop_buf, NULL) > 0) {
744                snprintf(top_k_profile_threshold_arg, sizeof(top_k_profile_threshold_arg),
745                         "--top-k-profile-threshold=%s", prop_buf);
746                have_top_k_profile_threshold = true;
747            }
748        }
749    }
750
751    if (have_dex2oat_Xms_flag) {
752        sprintf(dex2oat_Xms_arg, "-Xms%s", dex2oat_Xms_flag);
753    }
754    if (have_dex2oat_Xmx_flag) {
755        sprintf(dex2oat_Xmx_arg, "-Xmx%s", dex2oat_Xmx_flag);
756    }
757    if (skip_compilation) {
758        strcpy(dex2oat_compiler_filter_arg, "--compiler-filter=verify-none");
759        have_dex2oat_compiler_filter_flag = true;
760    } else if (have_dex2oat_compiler_filter_flag) {
761        sprintf(dex2oat_compiler_filter_arg, "--compiler-filter=%s", dex2oat_compiler_filter_flag);
762    }
763
764    ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, input_file_name, output_file_name);
765
766    char* argv[7  // program name, mandatory arguments and the final NULL
767               + (have_profile_file ? 1 : 0)
768               + (have_top_k_profile_threshold ? 1 : 0)
769               + (have_dex2oat_Xms_flag ? 2 : 0)
770               + (have_dex2oat_Xmx_flag ? 2 : 0)
771               + (have_dex2oat_compiler_filter_flag ? 1 : 0)
772               + (have_dex2oat_flags ? 1 : 0)];
773    int i = 0;
774    argv[i++] = (char*)DEX2OAT_BIN;
775    argv[i++] = zip_fd_arg;
776    argv[i++] = zip_location_arg;
777    argv[i++] = oat_fd_arg;
778    argv[i++] = oat_location_arg;
779    argv[i++] = instruction_set_arg;
780    if (have_profile_file) {
781        argv[i++] = profile_file_arg;
782    }
783    if (have_top_k_profile_threshold) {
784        argv[i++] = top_k_profile_threshold_arg;
785    }
786    if (have_dex2oat_Xms_flag) {
787        argv[i++] = (char*)RUNTIME_ARG;
788        argv[i++] = dex2oat_Xms_arg;
789    }
790    if (have_dex2oat_Xmx_flag) {
791        argv[i++] = (char*)RUNTIME_ARG;
792        argv[i++] = dex2oat_Xmx_arg;
793    }
794    if (have_dex2oat_compiler_filter_flag) {
795        argv[i++] = dex2oat_compiler_filter_arg;
796    }
797    if (have_dex2oat_flags) {
798        argv[i++] = dex2oat_flags;
799    }
800    // Do not add after dex2oat_flags, they should override others for debugging.
801    argv[i] = NULL;
802
803    execv(DEX2OAT_BIN, (char* const *)argv);
804    ALOGE("execl(%s) failed: %s\n", DEX2OAT_BIN, strerror(errno));
805}
806
807static int wait_child(pid_t pid)
808{
809    int status;
810    pid_t got_pid;
811
812    while (1) {
813        got_pid = waitpid(pid, &status, 0);
814        if (got_pid == -1 && errno == EINTR) {
815            printf("waitpid interrupted, retrying\n");
816        } else {
817            break;
818        }
819    }
820    if (got_pid != pid) {
821        ALOGW("waitpid failed: wanted %d, got %d: %s\n",
822            (int) pid, (int) got_pid, strerror(errno));
823        return 1;
824    }
825
826    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
827        return 0;
828    } else {
829        return status;      /* always nonzero */
830    }
831}
832
833int dexopt(const char *apk_path, uid_t uid, int is_public,
834           const char *pkgname, const char *instruction_set,
835           int is_patchoat)
836{
837    struct utimbuf ut;
838    struct stat input_stat, dex_stat;
839    char out_path[PKG_PATH_MAX];
840    char persist_sys_dalvik_vm_lib[PROPERTY_VALUE_MAX];
841    char *end;
842    const char *input_file;
843    char in_odex_path[PKG_PATH_MAX];
844    int res, input_fd=-1, out_fd=-1;
845
846    if (strlen(apk_path) >= (PKG_PATH_MAX - 8)) {
847        return -1;
848    }
849
850    /* The command to run depend on the value of persist.sys.dalvik.vm.lib */
851    property_get("persist.sys.dalvik.vm.lib.2", persist_sys_dalvik_vm_lib, "libart.so");
852
853    if (is_patchoat && strncmp(persist_sys_dalvik_vm_lib, "libart", 6) != 0) {
854        /* We may only patch if we are libart */
855        ALOGE("Patching is only supported in libart\n");
856        return -1;
857    }
858
859    /* Before anything else: is there a .odex file?  If so, we have
860     * precompiled the apk and there is nothing to do here.
861     *
862     * We skip this if we are doing a patchoat.
863     */
864    strcpy(out_path, apk_path);
865    end = strrchr(out_path, '.');
866    if (end != NULL && !is_patchoat) {
867        strcpy(end, ".odex");
868        if (stat(out_path, &dex_stat) == 0) {
869            return 0;
870        }
871    }
872
873    if (create_cache_path(out_path, apk_path, instruction_set)) {
874        return -1;
875    }
876
877    if (is_patchoat) {
878        /* /system/framework/whatever.jar -> /system/framework/<isa>/whatever.odex */
879        strcpy(in_odex_path, apk_path);
880        end = strrchr(in_odex_path, '/');
881        if (end == NULL) {
882            ALOGE("apk_path '%s' has no '/'s in it?!\n", apk_path);
883            return -1;
884        }
885        const char *apk_end = apk_path + (end - in_odex_path); // strrchr(apk_path, '/');
886        strcpy(end + 1, instruction_set); // in_odex_path now is /system/framework/<isa>\0
887        strcat(in_odex_path, apk_end);
888        end = strrchr(in_odex_path, '.');
889        if (end == NULL) {
890            return -1;
891        }
892        strcpy(end + 1, "odex");
893        input_file = in_odex_path;
894    } else {
895        input_file = apk_path;
896    }
897
898    memset(&input_stat, 0, sizeof(input_stat));
899    stat(input_file, &input_stat);
900
901    input_fd = open(input_file, O_RDONLY, 0);
902    if (input_fd < 0) {
903        ALOGE("installd cannot open '%s' for input during dexopt\n", input_file);
904        return -1;
905    }
906
907    unlink(out_path);
908    out_fd = open(out_path, O_RDWR | O_CREAT | O_EXCL, 0644);
909    if (out_fd < 0) {
910        ALOGE("installd cannot open '%s' for output during dexopt\n", out_path);
911        goto fail;
912    }
913    if (fchmod(out_fd,
914               S_IRUSR|S_IWUSR|S_IRGRP |
915               (is_public ? S_IROTH : 0)) < 0) {
916        ALOGE("installd cannot chmod '%s' during dexopt\n", out_path);
917        goto fail;
918    }
919    if (fchown(out_fd, AID_SYSTEM, uid) < 0) {
920        ALOGE("installd cannot chown '%s' during dexopt\n", out_path);
921        goto fail;
922    }
923
924    // Create profile file if there is a package name present.
925    if (strcmp(pkgname, "*") != 0) {
926        create_profile_file(pkgname, uid);
927    }
928
929
930    ALOGV("DexInv: --- BEGIN '%s' ---\n", input_file);
931
932    pid_t pid;
933    pid = fork();
934    if (pid == 0) {
935        /* child -- drop privileges before continuing */
936        if (setgid(uid) != 0) {
937            ALOGE("setgid(%d) failed in installd during dexopt\n", uid);
938            exit(64);
939        }
940        if (setuid(uid) != 0) {
941            ALOGE("setuid(%d) failed in installd during dexopt\n", uid);
942            exit(65);
943        }
944        // drop capabilities
945        struct __user_cap_header_struct capheader;
946        struct __user_cap_data_struct capdata[2];
947        memset(&capheader, 0, sizeof(capheader));
948        memset(&capdata, 0, sizeof(capdata));
949        capheader.version = _LINUX_CAPABILITY_VERSION_3;
950        if (capset(&capheader, &capdata[0]) < 0) {
951            ALOGE("capset failed: %s\n", strerror(errno));
952            exit(66);
953        }
954        if (set_sched_policy(0, SP_BACKGROUND) < 0) {
955            ALOGE("set_sched_policy failed: %s\n", strerror(errno));
956            exit(70);
957        }
958        if (flock(out_fd, LOCK_EX | LOCK_NB) != 0) {
959            ALOGE("flock(%s) failed: %s\n", out_path, strerror(errno));
960            exit(67);
961        }
962
963        if (strncmp(persist_sys_dalvik_vm_lib, "libdvm", 6) == 0) {
964            run_dexopt(input_fd, out_fd, input_file, out_path);
965        } else if (strncmp(persist_sys_dalvik_vm_lib, "libart", 6) == 0) {
966            if (is_patchoat) {
967                run_patchoat(input_fd, out_fd, input_file, out_path, pkgname, instruction_set);
968            } else {
969                run_dex2oat(input_fd, out_fd, input_file, out_path, pkgname, instruction_set);
970            }
971        } else {
972            exit(69);   /* Unexpected persist.sys.dalvik.vm.lib value */
973        }
974        exit(68);   /* only get here on exec failure */
975    } else {
976        res = wait_child(pid);
977        if (res == 0) {
978            ALOGV("DexInv: --- END '%s' (success) ---\n", input_file);
979        } else {
980            ALOGE("DexInv: --- END '%s' --- status=0x%04x, process failed\n", input_file, res);
981            goto fail;
982        }
983    }
984
985    ut.actime = input_stat.st_atime;
986    ut.modtime = input_stat.st_mtime;
987    utime(out_path, &ut);
988
989    close(out_fd);
990    close(input_fd);
991    return 0;
992
993fail:
994    if (out_fd >= 0) {
995        close(out_fd);
996        unlink(out_path);
997    }
998    if (input_fd >= 0) {
999        close(input_fd);
1000    }
1001    return -1;
1002}
1003
1004void mkinnerdirs(char* path, int basepos, mode_t mode, int uid, int gid,
1005        struct stat* statbuf)
1006{
1007    while (path[basepos] != 0) {
1008        if (path[basepos] == '/') {
1009            path[basepos] = 0;
1010            if (lstat(path, statbuf) < 0) {
1011                ALOGV("Making directory: %s\n", path);
1012                if (mkdir(path, mode) == 0) {
1013                    chown(path, uid, gid);
1014                } else {
1015                    ALOGW("Unable to make directory %s: %s\n", path, strerror(errno));
1016                }
1017            }
1018            path[basepos] = '/';
1019            basepos++;
1020        }
1021        basepos++;
1022    }
1023}
1024
1025int movefileordir(char* srcpath, char* dstpath, int dstbasepos,
1026        int dstuid, int dstgid, struct stat* statbuf)
1027{
1028    DIR *d;
1029    struct dirent *de;
1030    int res;
1031
1032    int srcend = strlen(srcpath);
1033    int dstend = strlen(dstpath);
1034
1035    if (lstat(srcpath, statbuf) < 0) {
1036        ALOGW("Unable to stat %s: %s\n", srcpath, strerror(errno));
1037        return 1;
1038    }
1039
1040    if ((statbuf->st_mode&S_IFDIR) == 0) {
1041        mkinnerdirs(dstpath, dstbasepos, S_IRWXU|S_IRWXG|S_IXOTH,
1042                dstuid, dstgid, statbuf);
1043        ALOGV("Renaming %s to %s (uid %d)\n", srcpath, dstpath, dstuid);
1044        if (rename(srcpath, dstpath) >= 0) {
1045            if (chown(dstpath, dstuid, dstgid) < 0) {
1046                ALOGE("cannot chown %s: %s\n", dstpath, strerror(errno));
1047                unlink(dstpath);
1048                return 1;
1049            }
1050        } else {
1051            ALOGW("Unable to rename %s to %s: %s\n",
1052                srcpath, dstpath, strerror(errno));
1053            return 1;
1054        }
1055        return 0;
1056    }
1057
1058    d = opendir(srcpath);
1059    if (d == NULL) {
1060        ALOGW("Unable to opendir %s: %s\n", srcpath, strerror(errno));
1061        return 1;
1062    }
1063
1064    res = 0;
1065
1066    while ((de = readdir(d))) {
1067        const char *name = de->d_name;
1068            /* always skip "." and ".." */
1069        if (name[0] == '.') {
1070            if (name[1] == 0) continue;
1071            if ((name[1] == '.') && (name[2] == 0)) continue;
1072        }
1073
1074        if ((srcend+strlen(name)) >= (PKG_PATH_MAX-2)) {
1075            ALOGW("Source path too long; skipping: %s/%s\n", srcpath, name);
1076            continue;
1077        }
1078
1079        if ((dstend+strlen(name)) >= (PKG_PATH_MAX-2)) {
1080            ALOGW("Destination path too long; skipping: %s/%s\n", dstpath, name);
1081            continue;
1082        }
1083
1084        srcpath[srcend] = dstpath[dstend] = '/';
1085        strcpy(srcpath+srcend+1, name);
1086        strcpy(dstpath+dstend+1, name);
1087
1088        if (movefileordir(srcpath, dstpath, dstbasepos, dstuid, dstgid, statbuf) != 0) {
1089            res = 1;
1090        }
1091
1092        // Note: we will be leaving empty directories behind in srcpath,
1093        // but that is okay, the package manager will be erasing all of the
1094        // data associated with .apks that disappear.
1095
1096        srcpath[srcend] = dstpath[dstend] = 0;
1097    }
1098
1099    closedir(d);
1100    return res;
1101}
1102
1103int movefiles()
1104{
1105    DIR *d;
1106    int dfd, subfd;
1107    struct dirent *de;
1108    struct stat s;
1109    char buf[PKG_PATH_MAX+1];
1110    int bufp, bufe, bufi, readlen;
1111
1112    char srcpkg[PKG_NAME_MAX];
1113    char dstpkg[PKG_NAME_MAX];
1114    char srcpath[PKG_PATH_MAX];
1115    char dstpath[PKG_PATH_MAX];
1116    int dstuid=-1, dstgid=-1;
1117    int hasspace;
1118
1119    d = opendir(UPDATE_COMMANDS_DIR_PREFIX);
1120    if (d == NULL) {
1121        goto done;
1122    }
1123    dfd = dirfd(d);
1124
1125        /* Iterate through all files in the directory, executing the
1126         * file movements requested there-in.
1127         */
1128    while ((de = readdir(d))) {
1129        const char *name = de->d_name;
1130
1131        if (de->d_type == DT_DIR) {
1132            continue;
1133        } else {
1134            subfd = openat(dfd, name, O_RDONLY);
1135            if (subfd < 0) {
1136                ALOGW("Unable to open update commands at %s%s\n",
1137                        UPDATE_COMMANDS_DIR_PREFIX, name);
1138                continue;
1139            }
1140
1141            bufp = 0;
1142            bufe = 0;
1143            buf[PKG_PATH_MAX] = 0;
1144            srcpkg[0] = dstpkg[0] = 0;
1145            while (1) {
1146                bufi = bufp;
1147                while (bufi < bufe && buf[bufi] != '\n') {
1148                    bufi++;
1149                }
1150                if (bufi < bufe) {
1151                    buf[bufi] = 0;
1152                    ALOGV("Processing line: %s\n", buf+bufp);
1153                    hasspace = 0;
1154                    while (bufp < bufi && isspace(buf[bufp])) {
1155                        hasspace = 1;
1156                        bufp++;
1157                    }
1158                    if (buf[bufp] == '#' || bufp == bufi) {
1159                        // skip comments and empty lines.
1160                    } else if (hasspace) {
1161                        if (dstpkg[0] == 0) {
1162                            ALOGW("Path before package line in %s%s: %s\n",
1163                                    UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1164                        } else if (srcpkg[0] == 0) {
1165                            // Skip -- source package no longer exists.
1166                        } else {
1167                            ALOGV("Move file: %s (from %s to %s)\n", buf+bufp, srcpkg, dstpkg);
1168                            if (!create_move_path(srcpath, srcpkg, buf+bufp, 0) &&
1169                                    !create_move_path(dstpath, dstpkg, buf+bufp, 0)) {
1170                                movefileordir(srcpath, dstpath,
1171                                        strlen(dstpath)-strlen(buf+bufp),
1172                                        dstuid, dstgid, &s);
1173                            }
1174                        }
1175                    } else {
1176                        char* div = strchr(buf+bufp, ':');
1177                        if (div == NULL) {
1178                            ALOGW("Bad package spec in %s%s; no ':' sep: %s\n",
1179                                    UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1180                        } else {
1181                            *div = 0;
1182                            div++;
1183                            if (strlen(buf+bufp) < PKG_NAME_MAX) {
1184                                strcpy(dstpkg, buf+bufp);
1185                            } else {
1186                                srcpkg[0] = dstpkg[0] = 0;
1187                                ALOGW("Package name too long in %s%s: %s\n",
1188                                        UPDATE_COMMANDS_DIR_PREFIX, name, buf+bufp);
1189                            }
1190                            if (strlen(div) < PKG_NAME_MAX) {
1191                                strcpy(srcpkg, div);
1192                            } else {
1193                                srcpkg[0] = dstpkg[0] = 0;
1194                                ALOGW("Package name too long in %s%s: %s\n",
1195                                        UPDATE_COMMANDS_DIR_PREFIX, name, div);
1196                            }
1197                            if (srcpkg[0] != 0) {
1198                                if (!create_pkg_path(srcpath, srcpkg, PKG_DIR_POSTFIX, 0)) {
1199                                    if (lstat(srcpath, &s) < 0) {
1200                                        // Package no longer exists -- skip.
1201                                        srcpkg[0] = 0;
1202                                    }
1203                                } else {
1204                                    srcpkg[0] = 0;
1205                                    ALOGW("Can't create path %s in %s%s\n",
1206                                            div, UPDATE_COMMANDS_DIR_PREFIX, name);
1207                                }
1208                                if (srcpkg[0] != 0) {
1209                                    if (!create_pkg_path(dstpath, dstpkg, PKG_DIR_POSTFIX, 0)) {
1210                                        if (lstat(dstpath, &s) == 0) {
1211                                            dstuid = s.st_uid;
1212                                            dstgid = s.st_gid;
1213                                        } else {
1214                                            // Destination package doesn't
1215                                            // exist...  due to original-package,
1216                                            // this is normal, so don't be
1217                                            // noisy about it.
1218                                            srcpkg[0] = 0;
1219                                        }
1220                                    } else {
1221                                        srcpkg[0] = 0;
1222                                        ALOGW("Can't create path %s in %s%s\n",
1223                                                div, UPDATE_COMMANDS_DIR_PREFIX, name);
1224                                    }
1225                                }
1226                                ALOGV("Transfering from %s to %s: uid=%d\n",
1227                                    srcpkg, dstpkg, dstuid);
1228                            }
1229                        }
1230                    }
1231                    bufp = bufi+1;
1232                } else {
1233                    if (bufp == 0) {
1234                        if (bufp < bufe) {
1235                            ALOGW("Line too long in %s%s, skipping: %s\n",
1236                                    UPDATE_COMMANDS_DIR_PREFIX, name, buf);
1237                        }
1238                    } else if (bufp < bufe) {
1239                        memcpy(buf, buf+bufp, bufe-bufp);
1240                        bufe -= bufp;
1241                        bufp = 0;
1242                    }
1243                    readlen = read(subfd, buf+bufe, PKG_PATH_MAX-bufe);
1244                    if (readlen < 0) {
1245                        ALOGW("Failure reading update commands in %s%s: %s\n",
1246                                UPDATE_COMMANDS_DIR_PREFIX, name, strerror(errno));
1247                        break;
1248                    } else if (readlen == 0) {
1249                        break;
1250                    }
1251                    bufe += readlen;
1252                    buf[bufe] = 0;
1253                    ALOGV("Read buf: %s\n", buf);
1254                }
1255            }
1256            close(subfd);
1257        }
1258    }
1259    closedir(d);
1260done:
1261    return 0;
1262}
1263
1264int linklib(const char* pkgname, const char* asecLibDir, int userId)
1265{
1266    char pkgdir[PKG_PATH_MAX];
1267    char libsymlink[PKG_PATH_MAX];
1268    struct stat s, libStat;
1269    int rc = 0;
1270
1271    if (create_pkg_path(pkgdir, pkgname, PKG_DIR_POSTFIX, userId)) {
1272        ALOGE("cannot create package path\n");
1273        return -1;
1274    }
1275    if (create_pkg_path(libsymlink, pkgname, PKG_LIB_POSTFIX, userId)) {
1276        ALOGE("cannot create package lib symlink origin path\n");
1277        return -1;
1278    }
1279
1280    if (stat(pkgdir, &s) < 0) return -1;
1281
1282    if (chown(pkgdir, AID_INSTALL, AID_INSTALL) < 0) {
1283        ALOGE("failed to chown '%s': %s\n", pkgdir, strerror(errno));
1284        return -1;
1285    }
1286
1287    if (chmod(pkgdir, 0700) < 0) {
1288        ALOGE("linklib() 1: failed to chmod '%s': %s\n", pkgdir, strerror(errno));
1289        rc = -1;
1290        goto out;
1291    }
1292
1293    if (lstat(libsymlink, &libStat) < 0) {
1294        if (errno != ENOENT) {
1295            ALOGE("couldn't stat lib dir: %s\n", strerror(errno));
1296            rc = -1;
1297            goto out;
1298        }
1299    } else {
1300        if (S_ISDIR(libStat.st_mode)) {
1301            if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
1302                rc = -1;
1303                goto out;
1304            }
1305        } else if (S_ISLNK(libStat.st_mode)) {
1306            if (unlink(libsymlink) < 0) {
1307                ALOGE("couldn't unlink lib dir: %s\n", strerror(errno));
1308                rc = -1;
1309                goto out;
1310            }
1311        }
1312    }
1313
1314    if (symlink(asecLibDir, libsymlink) < 0) {
1315        ALOGE("couldn't symlink directory '%s' -> '%s': %s\n", libsymlink, asecLibDir,
1316                strerror(errno));
1317        rc = -errno;
1318        goto out;
1319    }
1320
1321out:
1322    if (chmod(pkgdir, s.st_mode) < 0) {
1323        ALOGE("linklib() 2: failed to chmod '%s': %s\n", pkgdir, strerror(errno));
1324        rc = -errno;
1325    }
1326
1327    if (chown(pkgdir, s.st_uid, s.st_gid) < 0) {
1328        ALOGE("failed to chown '%s' : %s\n", pkgdir, strerror(errno));
1329        return -errno;
1330    }
1331
1332    return rc;
1333}
1334
1335static void run_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
1336{
1337    static const char *IDMAP_BIN = "/system/bin/idmap";
1338    static const size_t MAX_INT_LEN = 32;
1339    char idmap_str[MAX_INT_LEN];
1340
1341    snprintf(idmap_str, sizeof(idmap_str), "%d", idmap_fd);
1342
1343    execl(IDMAP_BIN, IDMAP_BIN, "--fd", target_apk, overlay_apk, idmap_str, (char*)NULL);
1344    ALOGE("execl(%s) failed: %s\n", IDMAP_BIN, strerror(errno));
1345}
1346
1347// Transform string /a/b/c.apk to (prefix)/a@b@c.apk@(suffix)
1348// eg /a/b/c.apk to /data/resource-cache/a@b@c.apk@idmap
1349static int flatten_path(const char *prefix, const char *suffix,
1350        const char *overlay_path, char *idmap_path, size_t N)
1351{
1352    if (overlay_path == NULL || idmap_path == NULL) {
1353        return -1;
1354    }
1355    const size_t len_overlay_path = strlen(overlay_path);
1356    // will access overlay_path + 1 further below; requires absolute path
1357    if (len_overlay_path < 2 || *overlay_path != '/') {
1358        return -1;
1359    }
1360    const size_t len_idmap_root = strlen(prefix);
1361    const size_t len_suffix = strlen(suffix);
1362    if (SIZE_MAX - len_idmap_root < len_overlay_path ||
1363            SIZE_MAX - (len_idmap_root + len_overlay_path) < len_suffix) {
1364        // additions below would cause overflow
1365        return -1;
1366    }
1367    if (N < len_idmap_root + len_overlay_path + len_suffix) {
1368        return -1;
1369    }
1370    memset(idmap_path, 0, N);
1371    snprintf(idmap_path, N, "%s%s%s", prefix, overlay_path + 1, suffix);
1372    char *ch = idmap_path + len_idmap_root;
1373    while (*ch != '\0') {
1374        if (*ch == '/') {
1375            *ch = '@';
1376        }
1377        ++ch;
1378    }
1379    return 0;
1380}
1381
1382int idmap(const char *target_apk, const char *overlay_apk, uid_t uid)
1383{
1384    ALOGV("idmap target_apk=%s overlay_apk=%s uid=%d\n", target_apk, overlay_apk, uid);
1385
1386    int idmap_fd = -1;
1387    char idmap_path[PATH_MAX];
1388
1389    if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
1390                idmap_path, sizeof(idmap_path)) == -1) {
1391        ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
1392        goto fail;
1393    }
1394
1395    unlink(idmap_path);
1396    idmap_fd = open(idmap_path, O_RDWR | O_CREAT | O_EXCL, 0644);
1397    if (idmap_fd < 0) {
1398        ALOGE("idmap cannot open '%s' for output: %s\n", idmap_path, strerror(errno));
1399        goto fail;
1400    }
1401    if (fchown(idmap_fd, AID_SYSTEM, uid) < 0) {
1402        ALOGE("idmap cannot chown '%s'\n", idmap_path);
1403        goto fail;
1404    }
1405    if (fchmod(idmap_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
1406        ALOGE("idmap cannot chmod '%s'\n", idmap_path);
1407        goto fail;
1408    }
1409
1410    pid_t pid;
1411    pid = fork();
1412    if (pid == 0) {
1413        /* child -- drop privileges before continuing */
1414        if (setgid(uid) != 0) {
1415            ALOGE("setgid(%d) failed during idmap\n", uid);
1416            exit(1);
1417        }
1418        if (setuid(uid) != 0) {
1419            ALOGE("setuid(%d) failed during idmap\n", uid);
1420            exit(1);
1421        }
1422        if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
1423            ALOGE("flock(%s) failed during idmap: %s\n", idmap_path, strerror(errno));
1424            exit(1);
1425        }
1426
1427        run_idmap(target_apk, overlay_apk, idmap_fd);
1428        exit(1); /* only if exec call to idmap failed */
1429    } else {
1430        int status = wait_child(pid);
1431        if (status != 0) {
1432            ALOGE("idmap failed, status=0x%04x\n", status);
1433            goto fail;
1434        }
1435    }
1436
1437    close(idmap_fd);
1438    return 0;
1439fail:
1440    if (idmap_fd >= 0) {
1441        close(idmap_fd);
1442        unlink(idmap_path);
1443    }
1444    return -1;
1445}
1446
1447int restorecon_data(const char* pkgName, const char* seinfo, uid_t uid)
1448{
1449    struct dirent *entry;
1450    DIR *d;
1451    struct stat s;
1452    char *userdir;
1453    char *primarydir;
1454    char *pkgdir;
1455    int ret = 0;
1456
1457    // SELINUX_ANDROID_RESTORECON_DATADATA flag is set by libselinux. Not needed here.
1458    unsigned int flags = SELINUX_ANDROID_RESTORECON_RECURSE;
1459
1460    if (!pkgName || !seinfo) {
1461        ALOGE("Package name or seinfo tag is null when trying to restorecon.");
1462        return -1;
1463    }
1464
1465    if (asprintf(&primarydir, "%s%s%s", android_data_dir.path, PRIMARY_USER_PREFIX, pkgName) < 0) {
1466        return -1;
1467    }
1468
1469    // Relabel for primary user.
1470    if (selinux_android_restorecon_pkgdir(primarydir, seinfo, uid, flags) < 0) {
1471        ALOGE("restorecon failed for %s: %s\n", primarydir, strerror(errno));
1472        ret |= -1;
1473    }
1474
1475    if (asprintf(&userdir, "%s%s", android_data_dir.path, SECONDARY_USER_PREFIX) < 0) {
1476        free(primarydir);
1477        return -1;
1478    }
1479
1480    // Relabel package directory for all secondary users.
1481    d = opendir(userdir);
1482    if (d == NULL) {
1483        free(primarydir);
1484        free(userdir);
1485        return -1;
1486    }
1487
1488    while ((entry = readdir(d))) {
1489        if (entry->d_type != DT_DIR) {
1490            continue;
1491        }
1492
1493        const char *user = entry->d_name;
1494        // Ignore "." and ".."
1495        if (!strcmp(user, ".") || !strcmp(user, "..")) {
1496            continue;
1497        }
1498
1499        // user directories start with a number
1500        if (user[0] < '0' || user[0] > '9') {
1501            ALOGE("Expecting numbered directory during restorecon. Instead got '%s'.", user);
1502            continue;
1503        }
1504
1505        if (asprintf(&pkgdir, "%s%s/%s", userdir, user, pkgName) < 0) {
1506            continue;
1507        }
1508
1509        if (stat(pkgdir, &s) < 0) {
1510            free(pkgdir);
1511            continue;
1512        }
1513
1514        if (selinux_android_restorecon_pkgdir(pkgdir, seinfo, uid, flags) < 0) {
1515            ALOGE("restorecon failed for %s: %s\n", pkgdir, strerror(errno));
1516            ret |= -1;
1517        }
1518        free(pkgdir);
1519    }
1520
1521    closedir(d);
1522    free(primarydir);
1523    free(userdir);
1524    return ret;
1525}
1526
1527static int prune_dex_exclusion_predicate(const char *file_name, const int is_dir)
1528{
1529    // Exclude all directories. The top level command will be
1530    // given a list of ISA specific directories that are assumed
1531    // to be flat.
1532    if (is_dir) {
1533      return 1;
1534    }
1535
1536
1537    // Don't exclude regular files that start with the list
1538    // of prefixes.
1539    static const char data_app_prefix[] = "data@app@";
1540    static const char data_priv_app_prefix[] = "data@priv-app@";
1541    if (!strncmp(file_name, data_app_prefix, sizeof(data_app_prefix) - 1) ||
1542        !strncmp(file_name, data_priv_app_prefix, sizeof(data_priv_app_prefix) - 1)) {
1543      return 0;
1544    }
1545
1546    // Exclude all regular files that don't start with the prefix "data@app@" or
1547    // "data@priv-app@".
1548    return 1;
1549}
1550
1551int prune_dex_cache(const char* subdir) {
1552    // "." is handled as a special case, and refers to
1553    // DALVIK_CACHE_PREFIX (usually /data/dalvik-cache).
1554    const bool is_dalvik_cache_root = !strcmp(subdir, ".");
1555
1556    // Don't allow the path to contain "." or ".." except for the
1557    // special case above. This is much stricter than we need to be,
1558    // but there's no good reason to support them.
1559    if (strchr(subdir, '.' ) != NULL && !is_dalvik_cache_root) {
1560        return -1;
1561    }
1562
1563    if (!is_dalvik_cache_root) {
1564        char full_path[PKG_PATH_MAX];
1565        snprintf(full_path, sizeof(full_path), "%s%s", DALVIK_CACHE_PREFIX, subdir);
1566        return delete_dir_contents(full_path, 0, &prune_dex_exclusion_predicate);
1567    }
1568
1569
1570    // When subdir == ".", clean the contents of the top level
1571    // dalvik-cache directory.
1572    return delete_dir_contents(DALVIK_CACHE_PREFIX, 0, &prune_dex_exclusion_predicate);
1573}
1574