installd.cpp revision 9087400f3c82b97aa17a74329c7e65c0a5ff4062 
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 <fcntl.h>
18#include <selinux/android.h>
19#include <selinux/avc.h>
20#include <sys/capability.h>
21#include <sys/fsuid.h>
22#include <sys/prctl.h>
23#include <sys/socket.h>
24#include <sys/stat.h>
25
26#include <android-base/logging.h>
27#include <cutils/fs.h>
28#include <cutils/log.h>               // TODO: Move everything to base::logging.
29#include <cutils/properties.h>
30#include <cutils/sockets.h>
31#include <private/android_filesystem_config.h>
32
33#include <InstalldNativeService.h>
34
35#include <commands.h>
36#include <globals.h>
37#include <installd_constants.h>
38#include <installd_deps.h>  // Need to fill in requirements of commands.
39#include <utils.h>
40
41#ifndef LOG_TAG
42#define LOG_TAG "installd"
43#endif
44#define SOCKET_PATH "installd"
45
46#define BUFFER_MAX    1024  /* input buffer for commands */
47#define TOKEN_MAX     16    /* max number of arguments in buffer */
48#define REPLY_MAX     256   /* largest reply allowed */
49
50namespace android {
51namespace installd {
52
53// Check that installd-deps sizes match cutils sizes.
54static_assert(kPropertyKeyMax == PROPERTY_KEY_MAX, "Size mismatch.");
55static_assert(kPropertyValueMax == PROPERTY_VALUE_MAX, "Size mismatch.");
56
57////////////////////////
58// Plug-in functions. //
59////////////////////////
60
61int get_property(const char *key, char *value, const char *default_value) {
62    return property_get(key, value, default_value);
63}
64
65// Compute the output path of
66bool calculate_oat_file_path(char path[PKG_PATH_MAX],
67                             const char *oat_dir,
68                             const char *apk_path,
69                             const char *instruction_set) {
70    const char *file_name_start;
71    const char *file_name_end;
72
73    file_name_start = strrchr(apk_path, '/');
74    if (file_name_start == NULL) {
75        ALOGE("apk_path '%s' has no '/'s in it\n", apk_path);
76        return false;
77    }
78    file_name_end = strrchr(apk_path, '.');
79    if (file_name_end < file_name_start) {
80        ALOGE("apk_path '%s' has no extension\n", apk_path);
81        return false;
82    }
83
84    // Calculate file_name
85    int file_name_len = file_name_end - file_name_start - 1;
86    char file_name[file_name_len + 1];
87    memcpy(file_name, file_name_start + 1, file_name_len);
88    file_name[file_name_len] = '\0';
89
90    // <apk_parent_dir>/oat/<isa>/<file_name>.odex
91    snprintf(path, PKG_PATH_MAX, "%s/%s/%s.odex", oat_dir, instruction_set, file_name);
92    return true;
93}
94
95/*
96 * Computes the odex file for the given apk_path and instruction_set.
97 * /system/framework/whatever.jar -> /system/framework/oat/<isa>/whatever.odex
98 *
99 * Returns false if it failed to determine the odex file path.
100 */
101bool calculate_odex_file_path(char path[PKG_PATH_MAX],
102                              const char *apk_path,
103                              const char *instruction_set) {
104    if (strlen(apk_path) + strlen("oat/") + strlen(instruction_set)
105            + strlen("/") + strlen("odex") + 1 > PKG_PATH_MAX) {
106        ALOGE("apk_path '%s' may be too long to form odex file path.\n", apk_path);
107        return false;
108    }
109
110    strcpy(path, apk_path);
111    char *end = strrchr(path, '/');
112    if (end == NULL) {
113        ALOGE("apk_path '%s' has no '/'s in it?!\n", apk_path);
114        return false;
115    }
116    const char *apk_end = apk_path + (end - path); // strrchr(apk_path, '/');
117
118    strcpy(end + 1, "oat/");       // path = /system/framework/oat/\0
119    strcat(path, instruction_set); // path = /system/framework/oat/<isa>\0
120    strcat(path, apk_end);         // path = /system/framework/oat/<isa>/whatever.jar\0
121    end = strrchr(path, '.');
122    if (end == NULL) {
123        ALOGE("apk_path '%s' has no extension.\n", apk_path);
124        return false;
125    }
126    strcpy(end + 1, "odex");
127    return true;
128}
129
130bool create_cache_path(char path[PKG_PATH_MAX],
131                       const char *src,
132                       const char *instruction_set) {
133    /* demand that we are an absolute path */
134    if ((src == nullptr) || (src[0] != '/') || strstr(src,"..")) {
135        return false;
136    }
137
138    size_t srclen = strlen(src);
139
140    if (srclen > PKG_PATH_MAX) {        // XXX: PKG_NAME_MAX?
141        return false;
142    }
143
144    size_t dstlen =
145        android_data_dir.len +
146        strlen(DALVIK_CACHE) +
147        1 +
148        strlen(instruction_set) +
149        srclen +
150        strlen(DALVIK_CACHE_POSTFIX) + 2;
151
152    if (dstlen > PKG_PATH_MAX) {
153        return false;
154    }
155
156    sprintf(path,"%s%s/%s/%s",
157            android_data_dir.path,
158            DALVIK_CACHE,
159            instruction_set,
160            src + 1 /* skip the leading / */);
161
162    char* tmp =
163            path +
164            android_data_dir.len +
165            strlen(DALVIK_CACHE) +
166            1 +
167            strlen(instruction_set) + 1;
168
169    for(; *tmp; tmp++) {
170        if (*tmp == '/') {
171            *tmp = '@';
172        }
173    }
174
175    strcat(path, DALVIK_CACHE_POSTFIX);
176    return true;
177}
178
179
180static char* parse_null(char* arg) {
181    if (strcmp(arg, "!") == 0) {
182        return nullptr;
183    } else {
184        return arg;
185    }
186}
187
188static int do_ping(char **arg ATTRIBUTE_UNUSED, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
189{
190    return 0;
191}
192
193static int do_create_app_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
194    /* const char *uuid, const char *pkgname, userid_t userid, int flags,
195            appid_t appid, const char* seinfo, int target_sdk_version */
196    return create_app_data(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]),
197                           atoi(arg[4]), arg[5], atoi(arg[6]));
198}
199
200static int do_restorecon_app_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
201    /* const char* uuid, const char* pkgName, userid_t userid, int flags,
202            appid_t appid, const char* seinfo */
203    return restorecon_app_data(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]), atoi(arg[4]), arg[5]);
204}
205
206static int do_migrate_app_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
207    /* const char *uuid, const char *pkgname, userid_t userid, int flags */
208    return migrate_app_data(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]));
209}
210
211static int do_clear_app_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
212    /* const char *uuid, const char *pkgname, userid_t userid, int flags, ino_t ce_data_inode */
213    return clear_app_data(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]), atol(arg[4]));
214}
215
216static int do_destroy_app_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
217    /* const char *uuid, const char *pkgname, userid_t userid, int flags, ino_t ce_data_inode */
218    return destroy_app_data(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]), atol(arg[4]));
219}
220
221// We use otapreopt_chroot to get into the chroot.
222static constexpr const char* kOtaPreopt = "/system/bin/otapreopt_chroot";
223
224static int do_ota_dexopt(const char* args[DEXOPT_PARAM_COUNT],
225                         char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
226    // Time to fork and run otapreopt.
227
228    // Check that the tool exists.
229    struct stat s;
230    if (stat(kOtaPreopt, &s) != 0) {
231        LOG(ERROR) << "Otapreopt chroot tool not found.";
232        return -1;
233    }
234
235    pid_t pid = fork();
236    if (pid == 0) {
237        const char* argv[1 + DEXOPT_PARAM_COUNT + 1];
238        argv[0] = kOtaPreopt;
239
240        for (size_t i = 0; i < DEXOPT_PARAM_COUNT; ++i) {
241            argv[i + 1] = args[i];
242        }
243
244        argv[DEXOPT_PARAM_COUNT + 1] = nullptr;
245
246        execv(argv[0], (char * const *)argv);
247        PLOG(ERROR) << "execv(OTAPREOPT_CHROOT) failed";
248        exit(99);
249    } else {
250        int res = wait_child(pid);
251        if (res == 0) {
252            ALOGV("DexInv: --- END OTAPREOPT (success) ---\n");
253        } else {
254            ALOGE("DexInv: --- END OTAPREOPT --- status=0x%04x, process failed\n", res);
255        }
256        return res;
257    }
258}
259
260static int do_regular_dexopt(const char* args[DEXOPT_PARAM_COUNT],
261                             char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
262    return dexopt(args);
263}
264
265using DexoptFn = int (*)(const char* args[DEXOPT_PARAM_COUNT],
266                         char reply[REPLY_MAX]);
267
268static int do_dexopt(char **arg, char reply[REPLY_MAX])
269{
270    const char* args[DEXOPT_PARAM_COUNT];
271    for (size_t i = 0; i < DEXOPT_PARAM_COUNT; ++i) {
272        CHECK(arg[i] != nullptr);
273        args[i] = arg[i];
274    }
275
276    int dexopt_flags = atoi(arg[6]);
277    DexoptFn dexopt_fn;
278    if ((dexopt_flags & DEXOPT_OTA) != 0) {
279        dexopt_fn = do_ota_dexopt;
280    } else {
281        dexopt_fn = do_regular_dexopt;
282    }
283    return dexopt_fn(args, reply);
284}
285
286static int do_merge_profiles(char **arg, char reply[REPLY_MAX])
287{
288    uid_t uid = static_cast<uid_t>(atoi(arg[0]));
289    const char* pkgname = arg[1];
290    if (merge_profiles(uid, pkgname)) {
291        strncpy(reply, "true", REPLY_MAX);
292    } else {
293        strncpy(reply, "false", REPLY_MAX);
294    }
295    return 0;
296}
297
298static int do_dump_profiles(char **arg, char reply[REPLY_MAX])
299{
300    uid_t uid = static_cast<uid_t>(atoi(arg[0]));
301    const char* pkgname = arg[1];
302    const char* dex_files = arg[2];
303    if (dump_profile(uid, pkgname, dex_files)) {
304        strncpy(reply, "true", REPLY_MAX);
305    } else {
306        strncpy(reply, "false", REPLY_MAX);
307    }
308    return 0;
309}
310
311static int do_mark_boot_complete(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
312{
313    return mark_boot_complete(arg[0] /* instruction set */);
314}
315
316static int do_rm_dex(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
317{
318    return rm_dex(arg[0], arg[1]); /* pkgname, instruction_set */
319}
320
321static int do_free_cache(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) /* TODO int:free_size */
322{
323    return free_cache(parse_null(arg[0]), (int64_t)atoll(arg[1])); /* uuid, free_size */
324}
325
326static int do_get_app_size(char **arg, char reply[REPLY_MAX]) {
327    int64_t codesize = 0;
328    int64_t datasize = 0;
329    int64_t cachesize = 0;
330    int64_t asecsize = 0;
331    int res = 0;
332
333    /* const char *uuid, const char *pkgname, int userid, int flags, ino_t ce_data_inode,
334            const char* code_path */
335    res = get_app_size(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]), atol(arg[4]),
336            arg[5], &codesize, &datasize, &cachesize, &asecsize);
337
338    /*
339     * Each int64_t can take up 22 characters printed out. Make sure it
340     * doesn't go over REPLY_MAX in the future.
341     */
342    snprintf(reply, REPLY_MAX, "%" PRId64 " %" PRId64 " %" PRId64 " %" PRId64,
343            codesize, datasize, cachesize, asecsize);
344    return res;
345}
346
347static int do_get_app_data_inode(char **arg, char reply[REPLY_MAX]) {
348    ino_t inode = 0;
349    int res = 0;
350
351    /* const char *uuid, const char *pkgname, int userid, int flags */
352    res = get_app_data_inode(parse_null(arg[0]), arg[1], atoi(arg[2]), atoi(arg[3]), &inode);
353
354    snprintf(reply, REPLY_MAX, "%" PRId64, (int64_t) inode);
355    return res;
356}
357
358static int do_move_complete_app(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
359    /* const char* from_uuid, const char *to_uuid, const char *package_name,
360            const char *data_app_name, appid_t appid, const char* seinfo,
361            int target_sdk_version */
362    return move_complete_app(parse_null(arg[0]), parse_null(arg[1]), arg[2], arg[3],
363                             atoi(arg[4]), arg[5], atoi(arg[6]));
364}
365
366static int do_create_user_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
367{
368    /* const char *uuid, userid_t userid, int user_serial, int flags */
369    return create_user_data(parse_null(arg[0]), atoi(arg[1]), atoi(arg[2]), atoi(arg[3]));
370}
371
372static int do_destroy_user_data(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
373{
374    /* const char *uuid, userid_t userid, int flags */
375    return destroy_user_data(parse_null(arg[0]), atoi(arg[1]), atoi(arg[2]));
376}
377
378static int do_linklib(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
379{
380    return linklib(parse_null(arg[0]), arg[1], arg[2], atoi(arg[3]));
381}
382
383static int do_idmap(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
384{
385    return idmap(arg[0], arg[1], atoi(arg[2]));
386}
387
388static int do_create_oat_dir(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
389{
390    /* oat_dir, instruction_set */
391    return create_oat_dir(arg[0], arg[1]);
392}
393
394static int do_rm_package_dir(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
395{
396    /* oat_dir */
397    return rm_package_dir(arg[0]);
398}
399
400static int do_clear_app_profiles(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
401{
402    /* package_name */
403    return clear_app_profiles(arg[0]);
404}
405
406static int do_destroy_app_profiles(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
407{
408    /* package_name */
409    return destroy_app_profiles(arg[0]);
410}
411
412static int do_link_file(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED)
413{
414    /* relative_path, from_base, to_base */
415    return link_file(arg[0], arg[1], arg[2]);
416}
417
418static int do_move_ab(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
419    // apk_path, instruction_set, oat_dir
420    return move_ab(arg[0], arg[1], arg[2]);
421}
422
423static int do_delete_odex(char **arg, char reply[REPLY_MAX] ATTRIBUTE_UNUSED) {
424    // apk_path, instruction_set, oat_dir
425    return delete_odex(arg[0], arg[1], arg[2]) ? 0 : -1;
426}
427
428struct cmdinfo {
429    const char *name;
430    unsigned numargs;
431    int (*func)(char **arg, char reply[REPLY_MAX]);
432};
433
434struct cmdinfo cmds[] = {
435    { "ping",                 0, do_ping },
436
437    { "create_app_data",      7, do_create_app_data },
438    { "restorecon_app_data",  6, do_restorecon_app_data },
439    { "migrate_app_data",     4, do_migrate_app_data },
440    { "clear_app_data",       5, do_clear_app_data },
441    { "destroy_app_data",     5, do_destroy_app_data },
442    { "move_complete_app",    7, do_move_complete_app },
443    { "get_app_size",         6, do_get_app_size },
444    { "get_app_data_inode",   4, do_get_app_data_inode },
445
446    { "create_user_data",     4, do_create_user_data },
447    { "destroy_user_data",    3, do_destroy_user_data },
448
449    { "dexopt",              10, do_dexopt },
450    { "markbootcomplete",     1, do_mark_boot_complete },
451    { "rmdex",                2, do_rm_dex },
452    { "freecache",            2, do_free_cache },
453    { "linklib",              4, do_linklib },
454    { "idmap",                3, do_idmap },
455    { "createoatdir",         2, do_create_oat_dir },
456    { "rmpackagedir",         1, do_rm_package_dir },
457    { "clear_app_profiles",   1, do_clear_app_profiles },
458    { "destroy_app_profiles", 1, do_destroy_app_profiles },
459    { "linkfile",             3, do_link_file },
460    { "move_ab",              3, do_move_ab },
461    { "merge_profiles",       2, do_merge_profiles },
462    { "dump_profiles",        3, do_dump_profiles },
463    { "delete_odex",          3, do_delete_odex },
464};
465
466static int readx(int s, void *_buf, int count)
467{
468    char *buf = (char *) _buf;
469    int n = 0, r;
470    if (count < 0) return -1;
471    while (n < count) {
472        r = read(s, buf + n, count - n);
473        if (r < 0) {
474            if (errno == EINTR) continue;
475            ALOGE("read error: %s\n", strerror(errno));
476            return -1;
477        }
478        if (r == 0) {
479            ALOGE("eof\n");
480            return -1; /* EOF */
481        }
482        n += r;
483    }
484    return 0;
485}
486
487static int writex(int s, const void *_buf, int count)
488{
489    const char *buf = (const char *) _buf;
490    int n = 0, r;
491    if (count < 0) return -1;
492    while (n < count) {
493        r = write(s, buf + n, count - n);
494        if (r < 0) {
495            if (errno == EINTR) continue;
496            ALOGE("write error: %s\n", strerror(errno));
497            return -1;
498        }
499        n += r;
500    }
501    return 0;
502}
503
504
505/* Tokenize the command buffer, locate a matching command,
506 * ensure that the required number of arguments are provided,
507 * call the function(), return the result.
508 */
509static int execute(int s, char cmd[BUFFER_MAX])
510{
511    char reply[REPLY_MAX];
512    char *arg[TOKEN_MAX+1];
513    unsigned i;
514    unsigned n = 0;
515    unsigned short count;
516    int ret = -1;
517
518    // ALOGI("execute('%s')\n", cmd);
519
520        /* default reply is "" */
521    reply[0] = 0;
522
523        /* n is number of args (not counting arg[0]) */
524    arg[0] = cmd;
525    while (*cmd) {
526        if (isspace(*cmd)) {
527            *cmd++ = 0;
528            n++;
529            arg[n] = cmd;
530            if (n == TOKEN_MAX) {
531                ALOGE("too many arguments\n");
532                goto done;
533            }
534        }
535        if (*cmd) {
536          cmd++;
537        }
538    }
539
540    for (i = 0; i < sizeof(cmds) / sizeof(cmds[0]); i++) {
541        if (!strcmp(cmds[i].name,arg[0])) {
542            if (n != cmds[i].numargs) {
543                ALOGE("%s requires %d arguments (%d given)\n",
544                     cmds[i].name, cmds[i].numargs, n);
545            } else {
546                ret = cmds[i].func(arg + 1, reply);
547            }
548            goto done;
549        }
550    }
551    ALOGE("unsupported command '%s'\n", arg[0]);
552
553done:
554    if (reply[0]) {
555        n = snprintf(cmd, BUFFER_MAX, "%d %s", ret, reply);
556    } else {
557        n = snprintf(cmd, BUFFER_MAX, "%d", ret);
558    }
559    if (n > BUFFER_MAX) n = BUFFER_MAX;
560    count = n;
561
562    // ALOGI("reply: '%s'\n", cmd);
563    if (writex(s, &count, sizeof(count))) return -1;
564    if (writex(s, cmd, count)) return -1;
565    return 0;
566}
567
568static bool initialize_globals() {
569    const char* data_path = getenv("ANDROID_DATA");
570    if (data_path == nullptr) {
571        ALOGE("Could not find ANDROID_DATA");
572        return false;
573    }
574    const char* root_path = getenv("ANDROID_ROOT");
575    if (root_path == nullptr) {
576        ALOGE("Could not find ANDROID_ROOT");
577        return false;
578    }
579
580    return init_globals_from_data_and_root(data_path, root_path);
581}
582
583static int initialize_directories() {
584    int res = -1;
585
586    // Read current filesystem layout version to handle upgrade paths
587    char version_path[PATH_MAX];
588    snprintf(version_path, PATH_MAX, "%s.layout_version", android_data_dir.path);
589
590    int oldVersion;
591    if (fs_read_atomic_int(version_path, &oldVersion) == -1) {
592        oldVersion = 0;
593    }
594    int version = oldVersion;
595
596    if (version < 2) {
597        SLOGD("Assuming that device has multi-user storage layout; upgrade no longer supported");
598        version = 2;
599    }
600
601    if (ensure_config_user_dirs(0) == -1) {
602        ALOGE("Failed to setup misc for user 0");
603        goto fail;
604    }
605
606    if (version == 2) {
607        ALOGD("Upgrading to /data/misc/user directories");
608
609        char misc_dir[PATH_MAX];
610        snprintf(misc_dir, PATH_MAX, "%smisc", android_data_dir.path);
611
612        char keychain_added_dir[PATH_MAX];
613        snprintf(keychain_added_dir, PATH_MAX, "%s/keychain/cacerts-added", misc_dir);
614
615        char keychain_removed_dir[PATH_MAX];
616        snprintf(keychain_removed_dir, PATH_MAX, "%s/keychain/cacerts-removed", misc_dir);
617
618        DIR *dir;
619        struct dirent *dirent;
620        dir = opendir("/data/user");
621        if (dir != NULL) {
622            while ((dirent = readdir(dir))) {
623                const char *name = dirent->d_name;
624
625                // skip "." and ".."
626                if (name[0] == '.') {
627                    if (name[1] == 0) continue;
628                    if ((name[1] == '.') && (name[2] == 0)) continue;
629                }
630
631                uint32_t user_id = atoi(name);
632
633                // /data/misc/user/<user_id>
634                if (ensure_config_user_dirs(user_id) == -1) {
635                    goto fail;
636                }
637
638                char misc_added_dir[PATH_MAX];
639                snprintf(misc_added_dir, PATH_MAX, "%s/user/%s/cacerts-added", misc_dir, name);
640
641                char misc_removed_dir[PATH_MAX];
642                snprintf(misc_removed_dir, PATH_MAX, "%s/user/%s/cacerts-removed", misc_dir, name);
643
644                uid_t uid = multiuser_get_uid(user_id, AID_SYSTEM);
645                gid_t gid = uid;
646                if (access(keychain_added_dir, F_OK) == 0) {
647                    if (copy_dir_files(keychain_added_dir, misc_added_dir, uid, gid) != 0) {
648                        ALOGE("Some files failed to copy");
649                    }
650                }
651                if (access(keychain_removed_dir, F_OK) == 0) {
652                    if (copy_dir_files(keychain_removed_dir, misc_removed_dir, uid, gid) != 0) {
653                        ALOGE("Some files failed to copy");
654                    }
655                }
656            }
657            closedir(dir);
658
659            if (access(keychain_added_dir, F_OK) == 0) {
660                delete_dir_contents(keychain_added_dir, 1, 0);
661            }
662            if (access(keychain_removed_dir, F_OK) == 0) {
663                delete_dir_contents(keychain_removed_dir, 1, 0);
664            }
665        }
666
667        version = 3;
668    }
669
670    // Persist layout version if changed
671    if (version != oldVersion) {
672        if (fs_write_atomic_int(version_path, version) == -1) {
673            ALOGE("Failed to save version to %s: %s", version_path, strerror(errno));
674            goto fail;
675        }
676    }
677
678    // Success!
679    res = 0;
680
681fail:
682    return res;
683}
684
685static int log_callback(int type, const char *fmt, ...) {
686    va_list ap;
687    int priority;
688
689    switch (type) {
690    case SELINUX_WARNING:
691        priority = ANDROID_LOG_WARN;
692        break;
693    case SELINUX_INFO:
694        priority = ANDROID_LOG_INFO;
695        break;
696    default:
697        priority = ANDROID_LOG_ERROR;
698        break;
699    }
700    va_start(ap, fmt);
701    LOG_PRI_VA(priority, "SELinux", fmt, ap);
702    va_end(ap);
703    return 0;
704}
705
706static int installd_main(const int argc ATTRIBUTE_UNUSED, char *argv[]) {
707    char buf[BUFFER_MAX];
708    struct sockaddr addr;
709    socklen_t alen;
710    int lsocket, s, ret;
711    int selinux_enabled = (is_selinux_enabled() > 0);
712
713    setenv("ANDROID_LOG_TAGS", "*:v", 1);
714    android::base::InitLogging(argv);
715
716    ALOGI("installd firing up\n");
717
718    union selinux_callback cb;
719    cb.func_log = log_callback;
720    selinux_set_callback(SELINUX_CB_LOG, cb);
721
722    if (!initialize_globals()) {
723        ALOGE("Could not initialize globals; exiting.\n");
724        exit(1);
725    }
726
727    if (initialize_directories() < 0) {
728        ALOGE("Could not create directories; exiting.\n");
729        exit(1);
730    }
731
732    if (selinux_enabled && selinux_status_open(true) < 0) {
733        ALOGE("Could not open selinux status; exiting.\n");
734        exit(1);
735    }
736
737    if ((ret = InstalldNativeService::start()) != android::OK) {
738        ALOGE("Unable to start InstalldNativeService: %d", ret);
739        exit(1);
740    }
741
742    lsocket = android_get_control_socket(SOCKET_PATH);
743    if (lsocket < 0) {
744        ALOGE("Failed to get socket from environment: %s\n", strerror(errno));
745        exit(1);
746    }
747    if (listen(lsocket, 5)) {
748        ALOGE("Listen on socket failed: %s\n", strerror(errno));
749        exit(1);
750    }
751    fcntl(lsocket, F_SETFD, FD_CLOEXEC);
752
753    for (;;) {
754        alen = sizeof(addr);
755        s = accept(lsocket, &addr, &alen);
756        if (s < 0) {
757            ALOGE("Accept failed: %s\n", strerror(errno));
758            continue;
759        }
760        fcntl(s, F_SETFD, FD_CLOEXEC);
761
762        ALOGI("new connection\n");
763        for (;;) {
764            unsigned short count;
765            if (readx(s, &count, sizeof(count))) {
766                ALOGE("failed to read size\n");
767                break;
768            }
769            if ((count < 1) || (count >= BUFFER_MAX)) {
770                ALOGE("invalid size %d\n", count);
771                break;
772            }
773            if (readx(s, buf, count)) {
774                ALOGE("failed to read command\n");
775                break;
776            }
777            buf[count] = 0;
778            if (selinux_enabled && selinux_status_updated() > 0) {
779                selinux_android_seapp_context_reload();
780            }
781            if (execute(s, buf)) break;
782        }
783        ALOGI("closing connection\n");
784        close(s);
785    }
786
787    return 0;
788}
789
790}  // namespace installd
791}  // namespace android
792
793int main(const int argc, char *argv[]) {
794    return android::installd::installd_main(argc, argv);
795}
796