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#define LOG_TAG "installd"
17
18#include <fcntl.h>
19#include <selinux/android.h>
20#include <selinux/avc.h>
21#include <sys/capability.h>
22#include <sys/fsuid.h>
23#include <sys/prctl.h>
24#include <sys/stat.h>
25
26#include <android-base/logging.h>
27#include <cutils/fs.h>
28#include <cutils/properties.h>
29#include <log/log.h>              // TODO: Move everything to base::logging.
30#include <private/android_filesystem_config.h>
31
32#include "InstalldNativeService.h"
33#include "globals.h"
34#include "installd_constants.h"
35#include "installd_deps.h"  // Need to fill in requirements of commands.
36#include "utils.h"
37
38namespace android {
39namespace installd {
40
41// Check that installd-deps sizes match cutils sizes.
42static_assert(kPropertyKeyMax == PROPERTY_KEY_MAX, "Size mismatch.");
43static_assert(kPropertyValueMax == PROPERTY_VALUE_MAX, "Size mismatch.");
44
45////////////////////////
46// Plug-in functions. //
47////////////////////////
48
49int get_property(const char *key, char *value, const char *default_value) {
50    return property_get(key, value, default_value);
51}
52
53// Compute the output path of
54bool calculate_oat_file_path(char path[PKG_PATH_MAX],
55                             const char *oat_dir,
56                             const char *apk_path,
57                             const char *instruction_set) {
58    const char *file_name_start;
59    const char *file_name_end;
60
61    file_name_start = strrchr(apk_path, '/');
62    if (file_name_start == NULL) {
63        SLOGE("apk_path '%s' has no '/'s in it\n", apk_path);
64        return false;
65    }
66    file_name_end = strrchr(apk_path, '.');
67    if (file_name_end < file_name_start) {
68        SLOGE("apk_path '%s' has no extension\n", apk_path);
69        return false;
70    }
71
72    // Calculate file_name
73    int file_name_len = file_name_end - file_name_start - 1;
74    char file_name[file_name_len + 1];
75    memcpy(file_name, file_name_start + 1, file_name_len);
76    file_name[file_name_len] = '\0';
77
78    // <apk_parent_dir>/oat/<isa>/<file_name>.odex
79    snprintf(path, PKG_PATH_MAX, "%s/%s/%s.odex", oat_dir, instruction_set, file_name);
80    return true;
81}
82
83/*
84 * Computes the odex file for the given apk_path and instruction_set.
85 * /system/framework/whatever.jar -> /system/framework/oat/<isa>/whatever.odex
86 *
87 * Returns false if it failed to determine the odex file path.
88 */
89bool calculate_odex_file_path(char path[PKG_PATH_MAX],
90                              const char *apk_path,
91                              const char *instruction_set) {
92    if (strlen(apk_path) + strlen("oat/") + strlen(instruction_set)
93            + strlen("/") + strlen("odex") + 1 > PKG_PATH_MAX) {
94        SLOGE("apk_path '%s' may be too long to form odex file path.\n", apk_path);
95        return false;
96    }
97
98    strcpy(path, apk_path);
99    char *end = strrchr(path, '/');
100    if (end == NULL) {
101        SLOGE("apk_path '%s' has no '/'s in it?!\n", apk_path);
102        return false;
103    }
104    const char *apk_end = apk_path + (end - path); // strrchr(apk_path, '/');
105
106    strcpy(end + 1, "oat/");       // path = /system/framework/oat/\0
107    strcat(path, instruction_set); // path = /system/framework/oat/<isa>\0
108    strcat(path, apk_end);         // path = /system/framework/oat/<isa>/whatever.jar\0
109    end = strrchr(path, '.');
110    if (end == NULL) {
111        SLOGE("apk_path '%s' has no extension.\n", apk_path);
112        return false;
113    }
114    strcpy(end + 1, "odex");
115    return true;
116}
117
118bool create_cache_path(char path[PKG_PATH_MAX],
119                       const char *src,
120                       const char *instruction_set) {
121    /* demand that we are an absolute path */
122    if ((src == nullptr) || (src[0] != '/') || strstr(src,"..")) {
123        return false;
124    }
125
126    size_t srclen = strlen(src);
127
128    if (srclen > PKG_PATH_MAX) {        // XXX: PKG_NAME_MAX?
129        return false;
130    }
131
132    size_t dstlen =
133        android_data_dir.len +
134        strlen(DALVIK_CACHE) +
135        1 +
136        strlen(instruction_set) +
137        srclen +
138        strlen(DALVIK_CACHE_POSTFIX) + 2;
139
140    if (dstlen > PKG_PATH_MAX) {
141        return false;
142    }
143
144    sprintf(path,"%s%s/%s/%s",
145            android_data_dir.path,
146            DALVIK_CACHE,
147            instruction_set,
148            src + 1 /* skip the leading / */);
149
150    char* tmp =
151            path +
152            android_data_dir.len +
153            strlen(DALVIK_CACHE) +
154            1 +
155            strlen(instruction_set) + 1;
156
157    for(; *tmp; tmp++) {
158        if (*tmp == '/') {
159            *tmp = '@';
160        }
161    }
162
163    strcat(path, DALVIK_CACHE_POSTFIX);
164    return true;
165}
166
167static bool initialize_globals() {
168    const char* data_path = getenv("ANDROID_DATA");
169    if (data_path == nullptr) {
170        SLOGE("Could not find ANDROID_DATA");
171        return false;
172    }
173    const char* root_path = getenv("ANDROID_ROOT");
174    if (root_path == nullptr) {
175        SLOGE("Could not find ANDROID_ROOT");
176        return false;
177    }
178
179    return init_globals_from_data_and_root(data_path, root_path);
180}
181
182static int initialize_directories() {
183    int res = -1;
184
185    // Read current filesystem layout version to handle upgrade paths
186    char version_path[PATH_MAX];
187    snprintf(version_path, PATH_MAX, "%s.layout_version", android_data_dir.path);
188
189    int oldVersion;
190    if (fs_read_atomic_int(version_path, &oldVersion) == -1) {
191        oldVersion = 0;
192    }
193    int version = oldVersion;
194
195    if (version < 2) {
196        SLOGD("Assuming that device has multi-user storage layout; upgrade no longer supported");
197        version = 2;
198    }
199
200    if (ensure_config_user_dirs(0) == -1) {
201        SLOGE("Failed to setup misc for user 0");
202        goto fail;
203    }
204
205    if (version == 2) {
206        SLOGD("Upgrading to /data/misc/user directories");
207
208        char misc_dir[PATH_MAX];
209        snprintf(misc_dir, PATH_MAX, "%smisc", android_data_dir.path);
210
211        char keychain_added_dir[PATH_MAX];
212        snprintf(keychain_added_dir, PATH_MAX, "%s/keychain/cacerts-added", misc_dir);
213
214        char keychain_removed_dir[PATH_MAX];
215        snprintf(keychain_removed_dir, PATH_MAX, "%s/keychain/cacerts-removed", misc_dir);
216
217        DIR *dir;
218        struct dirent *dirent;
219        dir = opendir("/data/user");
220        if (dir != NULL) {
221            while ((dirent = readdir(dir))) {
222                const char *name = dirent->d_name;
223
224                // skip "." and ".."
225                if (name[0] == '.') {
226                    if (name[1] == 0) continue;
227                    if ((name[1] == '.') && (name[2] == 0)) continue;
228                }
229
230                uint32_t user_id = atoi(name);
231
232                // /data/misc/user/<user_id>
233                if (ensure_config_user_dirs(user_id) == -1) {
234                    goto fail;
235                }
236
237                char misc_added_dir[PATH_MAX];
238                snprintf(misc_added_dir, PATH_MAX, "%s/user/%s/cacerts-added", misc_dir, name);
239
240                char misc_removed_dir[PATH_MAX];
241                snprintf(misc_removed_dir, PATH_MAX, "%s/user/%s/cacerts-removed", misc_dir, name);
242
243                uid_t uid = multiuser_get_uid(user_id, AID_SYSTEM);
244                gid_t gid = uid;
245                if (access(keychain_added_dir, F_OK) == 0) {
246                    if (copy_dir_files(keychain_added_dir, misc_added_dir, uid, gid) != 0) {
247                        SLOGE("Some files failed to copy");
248                    }
249                }
250                if (access(keychain_removed_dir, F_OK) == 0) {
251                    if (copy_dir_files(keychain_removed_dir, misc_removed_dir, uid, gid) != 0) {
252                        SLOGE("Some files failed to copy");
253                    }
254                }
255            }
256            closedir(dir);
257
258            if (access(keychain_added_dir, F_OK) == 0) {
259                delete_dir_contents(keychain_added_dir, 1, 0);
260            }
261            if (access(keychain_removed_dir, F_OK) == 0) {
262                delete_dir_contents(keychain_removed_dir, 1, 0);
263            }
264        }
265
266        version = 3;
267    }
268
269    // Persist layout version if changed
270    if (version != oldVersion) {
271        if (fs_write_atomic_int(version_path, version) == -1) {
272            SLOGE("Failed to save version to %s: %s", version_path, strerror(errno));
273            goto fail;
274        }
275    }
276
277    // Success!
278    res = 0;
279
280fail:
281    return res;
282}
283
284static int log_callback(int type, const char *fmt, ...) {
285    va_list ap;
286    int priority;
287
288    switch (type) {
289    case SELINUX_WARNING:
290        priority = ANDROID_LOG_WARN;
291        break;
292    case SELINUX_INFO:
293        priority = ANDROID_LOG_INFO;
294        break;
295    default:
296        priority = ANDROID_LOG_ERROR;
297        break;
298    }
299    va_start(ap, fmt);
300    LOG_PRI_VA(priority, "SELinux", fmt, ap);
301    va_end(ap);
302    return 0;
303}
304
305static int installd_main(const int argc ATTRIBUTE_UNUSED, char *argv[]) {
306    int ret;
307    int selinux_enabled = (is_selinux_enabled() > 0);
308
309    setenv("ANDROID_LOG_TAGS", "*:v", 1);
310    android::base::InitLogging(argv);
311
312    SLOGI("installd firing up");
313
314    union selinux_callback cb;
315    cb.func_log = log_callback;
316    selinux_set_callback(SELINUX_CB_LOG, cb);
317
318    if (!initialize_globals()) {
319        SLOGE("Could not initialize globals; exiting.\n");
320        exit(1);
321    }
322
323    if (initialize_directories() < 0) {
324        SLOGE("Could not create directories; exiting.\n");
325        exit(1);
326    }
327
328    if (selinux_enabled && selinux_status_open(true) < 0) {
329        SLOGE("Could not open selinux status; exiting.\n");
330        exit(1);
331    }
332
333    if ((ret = InstalldNativeService::start()) != android::OK) {
334        SLOGE("Unable to start InstalldNativeService: %d", ret);
335        exit(1);
336    }
337
338    IPCThreadState::self()->joinThreadPool();
339
340    LOG(INFO) << "installd shutting down";
341
342    return 0;
343}
344
345}  // namespace installd
346}  // namespace android
347
348int main(const int argc, char *argv[]) {
349    return android::installd::installd_main(argc, argv);
350}
351