pa-fazil
/
android_system_core
mirror of https://github.com/fazilsheik96/android_system_core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
android_system_core/init/host_init_verifier.cpp

348 lines
12 KiB
C++
Raw Blame History

//
// Copyright (C) 2018 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.
//
#include "host_init_verifier.h"
#include <errno.h>
#include <getopt.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
#include <generated_android_ids.h>
#include <hidl/metadata.h>
#include <property_info_serializer/property_info_serializer.h>
#include "action.h"
#include "action_manager.h"
#include "action_parser.h"
#include "check_builtins.h"
#include "host_import_parser.h"
#include "host_init_stubs.h"
#include "interface_utils.h"
#include "parser.h"
#include "result.h"
#include "service.h"
#include "service_list.h"
#include "service_parser.h"
using namespace std::literals;
using android::base::EndsWith;
using android::base::ParseInt;
using android::base::ReadFileToString;
using android::base::Split;
using android::properties::BuildTrie;
using android::properties::ParsePropertyInfoFile;
using android::properties::PropertyInfoArea;
using android::properties::PropertyInfoEntry;
static std::vector<std::string> passwd_files;
// NOTE: Keep this in sync with the order used by init.cpp LoadBootScripts()
static const std::vector<std::string> partition_search_order =
std::vector<std::string>({"system", "system_ext", "odm", "vendor", "product"});
static std::vector<std::pair<std::string, int>> GetVendorPasswd(const std::string& passwd_file) {
std::string passwd;
if (!ReadFileToString(passwd_file, &passwd)) {
return {};
}
std::vector<std::pair<std::string, int>> result;
auto passwd_lines = Split(passwd, "\n");
for (const auto& line : passwd_lines) {
auto split_line = Split(line, ":");
if (split_line.size() < 3) {
continue;
}
int uid = 0;
if (!ParseInt(split_line[2], &uid)) {
continue;
}
result.emplace_back(split_line[0], uid);
}
return result;
}
static std::vector<std::pair<std::string, int>> GetVendorPasswd() {
std::vector<std::pair<std::string, int>> result;
for (const auto& passwd_file : passwd_files) {
auto individual_result = GetVendorPasswd(passwd_file);
std::move(individual_result.begin(), individual_result.end(),
std::back_insert_iterator(result));
}
return result;
}
passwd* getpwnam(const char* login) { // NOLINT: implementing bad function.
// This isn't thread safe, but that's okay for our purposes.
static char static_name[32] = "";
static char static_dir[32] = "/";
static char static_shell[32] = "/system/bin/sh";
static passwd static_passwd = {
.pw_name = static_name,
.pw_dir = static_dir,
.pw_shell = static_shell,
.pw_uid = 0,
.pw_gid = 0,
};
for (size_t n = 0; n < android_id_count; ++n) {
if (!strcmp(android_ids[n].name, login)) {
snprintf(static_name, sizeof(static_name), "%s", android_ids[n].name);
static_passwd.pw_uid = android_ids[n].aid;
static_passwd.pw_gid = android_ids[n].aid;
return &static_passwd;
}
}
static const auto vendor_passwd = GetVendorPasswd();
for (const auto& [name, uid] : vendor_passwd) {
if (name == login) {
snprintf(static_name, sizeof(static_name), "%s", name.c_str());
static_passwd.pw_uid = uid;
static_passwd.pw_gid = uid;
return &static_passwd;
}
}
unsigned int oem_uid;
if (sscanf(login, "oem_%u", &oem_uid) == 1) {
snprintf(static_name, sizeof(static_name), "%s", login);
static_passwd.pw_uid = oem_uid;
static_passwd.pw_gid = oem_uid;
return &static_passwd;
}
errno = ENOENT;
return nullptr;
}
namespace android {
namespace init {
static Result<void> check_stub(const BuiltinArguments& args) {
return {};
}
#include "generated_stub_builtin_function_map.h"
void PrintUsage() {
fprintf(stdout, R"(usage: host_init_verifier [options]
Tests init script(s) for correctness.
Generic options:
-p FILE Search this passwd file for users and groups.
--property_contexts=FILE Use this file for property_contexts.
Single script mode options:
[init rc file] Positional argument; test this init script.
Multiple script mode options:
--out_system=DIR Path to the output product directory for the system partition.
--out_system_ext=DIR Path to the output product directory for the system_ext partition.
--out_odm=DIR Path to the output product directory for the odm partition.
--out_vendor=DIR Path to the output product directory for the vendor partition.
--out_product=DIR Path to the output product directory for the product partition.
)");
}
Result<InterfaceInheritanceHierarchyMap> ReadInterfaceInheritanceHierarchy() {
InterfaceInheritanceHierarchyMap result;
for (const HidlInterfaceMetadata& iface : HidlInterfaceMetadata::all()) {
std::set<FQName> inherited_interfaces;
for (const std::string& intf : iface.inherited) {
FQName fqname;
if (!fqname.setTo(intf)) {
return Error() << "Unable to parse interface '" << intf << "'";
}
inherited_interfaces.insert(fqname);
}
FQName fqname;
if (!fqname.setTo(iface.name)) {
return Error() << "Unable to parse interface '" << iface.name << "'";
}
result[fqname] = inherited_interfaces;
}
return result;
}
const PropertyInfoArea* property_info_area;
void HandlePropertyContexts(const std::string& filename,
std::vector<PropertyInfoEntry>* property_infos) {
auto file_contents = std::string();
if (!ReadFileToString(filename, &file_contents)) {
PLOG(ERROR) << "Could not read properties from '" << filename << "'";
exit(EXIT_FAILURE);
}
auto errors = std::vector<std::string>{};
ParsePropertyInfoFile(file_contents, true, property_infos, &errors);
for (const auto& error : errors) {
LOG(ERROR) << "Could not read line from '" << filename << "': " << error;
}
if (!errors.empty()) {
exit(EXIT_FAILURE);
}
}
int main(int argc, char** argv) {
android::base::InitLogging(argv, &android::base::StdioLogger);
android::base::SetMinimumLogSeverity(android::base::ERROR);
auto property_infos = std::vector<PropertyInfoEntry>();
std::map<std::string, std::string> partition_map;
while (true) {
static const char kPropertyContexts[] = "property-contexts=";
static const struct option long_options[] = {
{"help", no_argument, nullptr, 'h'},
{kPropertyContexts, required_argument, nullptr, 0},
{"out_system", required_argument, nullptr, 0},
{"out_system_ext", required_argument, nullptr, 0},
{"out_odm", required_argument, nullptr, 0},
{"out_vendor", required_argument, nullptr, 0},
{"out_product", required_argument, nullptr, 0},
{nullptr, 0, nullptr, 0},
};
int option_index;
int arg = getopt_long(argc, argv, "p:", long_options, &option_index);
if (arg == -1) {
break;
}
switch (arg) {
case 0:
if (long_options[option_index].name == kPropertyContexts) {
HandlePropertyContexts(optarg, &property_infos);
}
for (const auto& p : partition_search_order) {
if (long_options[option_index].name == "out_" + p) {
if (partition_map.find(p) != partition_map.end()) {
PrintUsage();
return EXIT_FAILURE;
}
partition_map[p] =
EndsWith(optarg, "/") ? optarg : std::string(optarg) + "/";
}
}
break;
case 'h':
PrintUsage();
return EXIT_FAILURE;
case 'p':
passwd_files.emplace_back(optarg);
break;
default:
std::cerr << "getprop: getopt returned invalid result: " << arg << std::endl;
return EXIT_FAILURE;
}
}
argc -= optind;
argv += optind;
// If provided, use the partition map to check multiple init rc files.
// Otherwise, check a single init rc file.
if ((!partition_map.empty() && argc != 0) || (partition_map.empty() && argc != 1)) {
PrintUsage();
return EXIT_FAILURE;
}
auto interface_inheritance_hierarchy_map = ReadInterfaceInheritanceHierarchy();
if (!interface_inheritance_hierarchy_map.ok()) {
LOG(ERROR) << interface_inheritance_hierarchy_map.error();
return EXIT_FAILURE;
}
SetKnownInterfaces(*interface_inheritance_hierarchy_map);
std::string serialized_contexts;
std::string trie_error;
if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
&trie_error)) {
LOG(ERROR) << "Unable to serialize property contexts: " << trie_error;
return EXIT_FAILURE;
}
property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
if (!partition_map.empty()) {
std::vector<std::string> vendor_prefixes;
for (const auto& partition : {"vendor", "odm"}) {
if (partition_map.find(partition) != partition_map.end()) {
vendor_prefixes.push_back(partition_map.at(partition));
}
}
InitializeHostSubcontext(vendor_prefixes);
}
const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();
Action::set_function_map(&function_map);
ActionManager& am = ActionManager::GetInstance();
ServiceList& sl = ServiceList::GetInstance();
Parser parser;
parser.AddSectionParser("service",
std::make_unique<ServiceParser>(&sl, GetSubcontext(),
*interface_inheritance_hierarchy_map));
parser.AddSectionParser("on", std::make_unique<ActionParser>(&am, GetSubcontext()));
parser.AddSectionParser("import", std::make_unique<HostImportParser>());
if (!partition_map.empty()) {
for (const auto& p : partition_search_order) {
if (partition_map.find(p) != partition_map.end()) {
parser.ParseConfig(partition_map.at(p) + "etc/init");
}
}
} else {
if (!parser.ParseConfigFileInsecure(*argv)) {
LOG(ERROR) << "Failed to open init rc script '" << *argv << "'";
return EXIT_FAILURE;
}
}
size_t failures = parser.parse_error_count() + am.CheckAllCommands() + sl.CheckAllCommands();
if (failures > 0) {
LOG(ERROR) << "Failed to parse init scripts with " << failures << " error(s).";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
} // namespace init
} // namespace android
int main(int argc, char** argv) {
return android::init::main(argc, argv);
}
Reference in New Issue View Git Blame Copy Permalink