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