You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
241 lines
7.1 KiB
241 lines
7.1 KiB
/*
|
|
** Copyright 2008, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
#define LOG_TAG "installd"
|
|
|
|
#include <fcntl.h>
|
|
#include <selinux/android.h>
|
|
#include <selinux/avc.h>
|
|
#include <sys/capability.h>
|
|
#include <sys/fsuid.h>
|
|
#include <sys/prctl.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <cutils/fs.h>
|
|
#include <cutils/properties.h>
|
|
#include <log/log.h> // TODO: Move everything to base::logging.
|
|
#include <private/android_filesystem_config.h>
|
|
|
|
#include "InstalldNativeService.h"
|
|
#include "dexopt.h"
|
|
#include "globals.h"
|
|
#include "installd_constants.h"
|
|
#include "installd_deps.h" // Need to fill in requirements of commands.
|
|
#include "utils.h"
|
|
|
|
namespace android {
|
|
namespace installd {
|
|
|
|
// Check that installd-deps sizes match cutils sizes.
|
|
static_assert(kPropertyKeyMax == PROPERTY_KEY_MAX, "Size mismatch.");
|
|
static_assert(kPropertyValueMax == PROPERTY_VALUE_MAX, "Size mismatch.");
|
|
|
|
////////////////////////
|
|
// Plug-in functions. //
|
|
////////////////////////
|
|
|
|
int get_property(const char *key, char *value, const char *default_value) {
|
|
return property_get(key, value, default_value);
|
|
}
|
|
|
|
bool calculate_oat_file_path(char path[PKG_PATH_MAX], const char *oat_dir, const char *apk_path,
|
|
const char *instruction_set) {
|
|
return calculate_oat_file_path_default(path, oat_dir, apk_path, instruction_set);
|
|
}
|
|
|
|
bool calculate_odex_file_path(char path[PKG_PATH_MAX], const char *apk_path,
|
|
const char *instruction_set) {
|
|
return calculate_odex_file_path_default(path, apk_path, instruction_set);
|
|
}
|
|
|
|
bool create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set) {
|
|
return create_cache_path_default(path, src, instruction_set);
|
|
}
|
|
|
|
static bool initialize_globals() {
|
|
return init_globals_from_data_and_root();
|
|
}
|
|
|
|
static int initialize_directories() {
|
|
int res = -1;
|
|
|
|
// Read current filesystem layout version to handle upgrade paths
|
|
char version_path[PATH_MAX];
|
|
snprintf(version_path, PATH_MAX, "%smisc/installd/layout_version", android_data_dir.c_str());
|
|
|
|
int oldVersion;
|
|
if (fs_read_atomic_int(version_path, &oldVersion) == -1) {
|
|
oldVersion = 0;
|
|
}
|
|
int version = oldVersion;
|
|
|
|
if (version < 2) {
|
|
SLOGD("Assuming that device has multi-user storage layout; upgrade no longer supported");
|
|
version = 2;
|
|
}
|
|
|
|
if (ensure_config_user_dirs(0) == -1) {
|
|
SLOGE("Failed to setup misc for user 0");
|
|
goto fail;
|
|
}
|
|
|
|
if (version == 2) {
|
|
SLOGD("Upgrading to /data/misc/user directories");
|
|
|
|
char misc_dir[PATH_MAX];
|
|
snprintf(misc_dir, PATH_MAX, "%smisc", android_data_dir.c_str());
|
|
|
|
char keychain_added_dir[PATH_MAX];
|
|
snprintf(keychain_added_dir, PATH_MAX, "%s/keychain/cacerts-added", misc_dir);
|
|
|
|
char keychain_removed_dir[PATH_MAX];
|
|
snprintf(keychain_removed_dir, PATH_MAX, "%s/keychain/cacerts-removed", misc_dir);
|
|
|
|
DIR *dir;
|
|
struct dirent *dirent;
|
|
dir = opendir("/data/user");
|
|
if (dir != nullptr) {
|
|
while ((dirent = readdir(dir))) {
|
|
const char *name = dirent->d_name;
|
|
|
|
// skip "." and ".."
|
|
if (name[0] == '.') {
|
|
if (name[1] == 0) continue;
|
|
if ((name[1] == '.') && (name[2] == 0)) continue;
|
|
}
|
|
|
|
uint32_t user_id = std::stoi(name);
|
|
|
|
// /data/misc/user/<user_id>
|
|
if (ensure_config_user_dirs(user_id) == -1) {
|
|
goto fail;
|
|
}
|
|
|
|
char misc_added_dir[PATH_MAX];
|
|
snprintf(misc_added_dir, PATH_MAX, "%s/user/%s/cacerts-added", misc_dir, name);
|
|
|
|
char misc_removed_dir[PATH_MAX];
|
|
snprintf(misc_removed_dir, PATH_MAX, "%s/user/%s/cacerts-removed", misc_dir, name);
|
|
|
|
uid_t uid = multiuser_get_uid(user_id, AID_SYSTEM);
|
|
gid_t gid = uid;
|
|
if (access(keychain_added_dir, F_OK) == 0) {
|
|
if (copy_dir_files(keychain_added_dir, misc_added_dir, uid, gid) != 0) {
|
|
SLOGE("Some files failed to copy");
|
|
}
|
|
}
|
|
if (access(keychain_removed_dir, F_OK) == 0) {
|
|
if (copy_dir_files(keychain_removed_dir, misc_removed_dir, uid, gid) != 0) {
|
|
SLOGE("Some files failed to copy");
|
|
}
|
|
}
|
|
}
|
|
closedir(dir);
|
|
|
|
if (access(keychain_added_dir, F_OK) == 0) {
|
|
delete_dir_contents(keychain_added_dir, 1, nullptr);
|
|
}
|
|
if (access(keychain_removed_dir, F_OK) == 0) {
|
|
delete_dir_contents(keychain_removed_dir, 1, nullptr);
|
|
}
|
|
}
|
|
|
|
version = 3;
|
|
}
|
|
|
|
// Persist layout version if changed
|
|
if (version != oldVersion) {
|
|
if (fs_write_atomic_int(version_path, version) == -1) {
|
|
SLOGE("Failed to save version to %s: %s", version_path, strerror(errno));
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
// Success!
|
|
res = 0;
|
|
|
|
fail:
|
|
return res;
|
|
}
|
|
|
|
static int log_callback(int type, const char *fmt, ...) { // NOLINT
|
|
va_list ap;
|
|
int priority;
|
|
|
|
switch (type) {
|
|
case SELINUX_WARNING:
|
|
priority = ANDROID_LOG_WARN;
|
|
break;
|
|
case SELINUX_INFO:
|
|
priority = ANDROID_LOG_INFO;
|
|
break;
|
|
default:
|
|
priority = ANDROID_LOG_ERROR;
|
|
break;
|
|
}
|
|
va_start(ap, fmt);
|
|
LOG_PRI_VA(priority, "SELinux", fmt, ap);
|
|
va_end(ap);
|
|
return 0;
|
|
}
|
|
|
|
static int installd_main(const int argc ATTRIBUTE_UNUSED, char *argv[]) {
|
|
int ret;
|
|
int selinux_enabled = (is_selinux_enabled() > 0);
|
|
|
|
setenv("ANDROID_LOG_TAGS", "*:v", 1);
|
|
android::base::InitLogging(argv);
|
|
|
|
SLOGI("installd firing up");
|
|
|
|
union selinux_callback cb;
|
|
cb.func_log = log_callback;
|
|
selinux_set_callback(SELINUX_CB_LOG, cb);
|
|
|
|
if (!initialize_globals()) {
|
|
SLOGE("Could not initialize globals; exiting.\n");
|
|
exit(1);
|
|
}
|
|
|
|
if (initialize_directories() < 0) {
|
|
SLOGE("Could not create directories; exiting.\n");
|
|
exit(1);
|
|
}
|
|
|
|
if (selinux_enabled && selinux_status_open(true) < 0) {
|
|
SLOGE("Could not open selinux status; exiting.\n");
|
|
exit(1);
|
|
}
|
|
|
|
if ((ret = InstalldNativeService::start()) != android::OK) {
|
|
SLOGE("Unable to start InstalldNativeService: %d", ret);
|
|
exit(1);
|
|
}
|
|
|
|
IPCThreadState::self()->joinThreadPool();
|
|
|
|
LOG(INFO) << "installd shutting down";
|
|
|
|
return 0;
|
|
}
|
|
|
|
} // namespace installd
|
|
} // namespace android
|
|
|
|
int main(const int argc, char *argv[]) {
|
|
return android::installd::installd_main(argc, argv);
|
|
}
|