5b271797de
Vendors have an interest in importing ueventd files based on certain property values. Instead of baking this logic in the ueventd binary, add the import option from the init parser to the ueventd parser, to allow vendors to expand as needed. Test: imported files are parsed Change-Id: I674987fd48f3218e4703528c6d905b1afb5fb366
260 lines
9.1 KiB
C++
260 lines
9.1 KiB
C++
/*
|
|
* Copyright (C) 2017 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 "ueventd_parser.h"
|
|
|
|
#include <grp.h>
|
|
#include <pwd.h>
|
|
|
|
#include <android-base/parseint.h>
|
|
|
|
#include "import_parser.h"
|
|
#include "keyword_map.h"
|
|
#include "parser.h"
|
|
|
|
using android::base::ParseByteCount;
|
|
|
|
namespace android {
|
|
namespace init {
|
|
|
|
Result<void> ParsePermissionsLine(std::vector<std::string>&& args,
|
|
std::vector<SysfsPermissions>* out_sysfs_permissions,
|
|
std::vector<Permissions>* out_dev_permissions) {
|
|
bool is_sysfs = out_sysfs_permissions != nullptr;
|
|
if (is_sysfs && args.size() != 5) {
|
|
return Error() << "/sys/ lines must have 5 entries";
|
|
}
|
|
|
|
if (!is_sysfs && args.size() != 4) {
|
|
return Error() << "/dev/ lines must have 4 entries";
|
|
}
|
|
|
|
auto it = args.begin();
|
|
const std::string& name = *it++;
|
|
|
|
std::string sysfs_attribute;
|
|
if (is_sysfs) sysfs_attribute = *it++;
|
|
|
|
// args is now common to both sys and dev entries and contains: <perm> <uid> <gid>
|
|
std::string& perm_string = *it++;
|
|
char* end_pointer = 0;
|
|
mode_t perm = strtol(perm_string.c_str(), &end_pointer, 8);
|
|
if (end_pointer == nullptr || *end_pointer != '\0') {
|
|
return Error() << "invalid mode '" << perm_string << "'";
|
|
}
|
|
|
|
std::string& uid_string = *it++;
|
|
passwd* pwd = getpwnam(uid_string.c_str());
|
|
if (!pwd) {
|
|
return Error() << "invalid uid '" << uid_string << "'";
|
|
}
|
|
uid_t uid = pwd->pw_uid;
|
|
|
|
std::string& gid_string = *it++;
|
|
struct group* grp = getgrnam(gid_string.c_str());
|
|
if (!grp) {
|
|
return Error() << "invalid gid '" << gid_string << "'";
|
|
}
|
|
gid_t gid = grp->gr_gid;
|
|
|
|
if (is_sysfs) {
|
|
out_sysfs_permissions->emplace_back(name, sysfs_attribute, perm, uid, gid);
|
|
} else {
|
|
out_dev_permissions->emplace_back(name, perm, uid, gid);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
Result<void> ParseFirmwareDirectoriesLine(std::vector<std::string>&& args,
|
|
std::vector<std::string>* firmware_directories) {
|
|
if (args.size() < 2) {
|
|
return Error() << "firmware_directories must have at least 1 entry";
|
|
}
|
|
|
|
std::move(std::next(args.begin()), args.end(), std::back_inserter(*firmware_directories));
|
|
|
|
return {};
|
|
}
|
|
|
|
Result<void> ParseExternalFirmwareHandlerLine(
|
|
std::vector<std::string>&& args,
|
|
std::vector<ExternalFirmwareHandler>* external_firmware_handlers) {
|
|
if (args.size() != 4) {
|
|
return Error() << "external_firmware_handler lines must have exactly 3 parameters";
|
|
}
|
|
|
|
if (std::find_if(external_firmware_handlers->begin(), external_firmware_handlers->end(),
|
|
[&args](const auto& other) { return other.devpath == args[2]; }) !=
|
|
external_firmware_handlers->end()) {
|
|
return Error() << "found a previous external_firmware_handler with the same devpath, '"
|
|
<< args[2] << "'";
|
|
}
|
|
|
|
passwd* pwd = getpwnam(args[2].c_str());
|
|
if (!pwd) {
|
|
return ErrnoError() << "invalid handler uid'" << args[2] << "'";
|
|
}
|
|
|
|
ExternalFirmwareHandler handler(std::move(args[1]), pwd->pw_uid, std::move(args[3]));
|
|
external_firmware_handlers->emplace_back(std::move(handler));
|
|
|
|
return {};
|
|
}
|
|
|
|
Result<void> ParseEnabledDisabledLine(std::vector<std::string>&& args, bool* feature) {
|
|
if (args.size() != 2) {
|
|
return Error() << args[0] << " lines take exactly one parameter";
|
|
}
|
|
|
|
if (args[1] == "enabled") {
|
|
*feature = true;
|
|
} else if (args[1] == "disabled") {
|
|
*feature = false;
|
|
} else {
|
|
return Error() << args[0] << " takes either 'enabled' or 'disabled' as a parameter";
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
Result<void> ParseUeventSocketRcvbufSizeLine(std::vector<std::string>&& args,
|
|
size_t* uevent_socket_rcvbuf_size) {
|
|
if (args.size() != 2) {
|
|
return Error() << "uevent_socket_rcvbuf_size lines take exactly one parameter";
|
|
}
|
|
|
|
size_t parsed_size;
|
|
if (!ParseByteCount(args[1], &parsed_size)) {
|
|
return Error() << "could not parse size '" << args[1] << "' for uevent_socket_rcvbuf_line";
|
|
}
|
|
|
|
*uevent_socket_rcvbuf_size = parsed_size;
|
|
|
|
return {};
|
|
}
|
|
|
|
class SubsystemParser : public SectionParser {
|
|
public:
|
|
SubsystemParser(std::vector<Subsystem>* subsystems) : subsystems_(subsystems) {}
|
|
Result<void> ParseSection(std::vector<std::string>&& args, const std::string& filename,
|
|
int line) override;
|
|
Result<void> ParseLineSection(std::vector<std::string>&& args, int line) override;
|
|
Result<void> EndSection() override;
|
|
|
|
private:
|
|
Result<void> ParseDevName(std::vector<std::string>&& args);
|
|
Result<void> ParseDirName(std::vector<std::string>&& args);
|
|
|
|
Subsystem subsystem_;
|
|
std::vector<Subsystem>* subsystems_;
|
|
};
|
|
|
|
Result<void> SubsystemParser::ParseSection(std::vector<std::string>&& args,
|
|
const std::string& filename, int line) {
|
|
if (args.size() != 2) {
|
|
return Error() << "subsystems must have exactly one name";
|
|
}
|
|
|
|
if (std::find(subsystems_->begin(), subsystems_->end(), args[1]) != subsystems_->end()) {
|
|
return Error() << "ignoring duplicate subsystem entry";
|
|
}
|
|
|
|
subsystem_ = Subsystem(std::move(args[1]));
|
|
|
|
return {};
|
|
}
|
|
|
|
Result<void> SubsystemParser::ParseDevName(std::vector<std::string>&& args) {
|
|
if (args[1] == "uevent_devname") {
|
|
subsystem_.devname_source_ = Subsystem::DEVNAME_UEVENT_DEVNAME;
|
|
return {};
|
|
}
|
|
if (args[1] == "uevent_devpath") {
|
|
subsystem_.devname_source_ = Subsystem::DEVNAME_UEVENT_DEVPATH;
|
|
return {};
|
|
}
|
|
|
|
return Error() << "invalid devname '" << args[1] << "'";
|
|
}
|
|
|
|
Result<void> SubsystemParser::ParseDirName(std::vector<std::string>&& args) {
|
|
if (args[1].front() != '/') {
|
|
return Error() << "dirname '" << args[1] << " ' does not start with '/'";
|
|
}
|
|
|
|
subsystem_.dir_name_ = args[1];
|
|
return {};
|
|
}
|
|
|
|
Result<void> SubsystemParser::ParseLineSection(std::vector<std::string>&& args, int line) {
|
|
using OptionParser = Result<void> (SubsystemParser::*)(std::vector<std::string> && args);
|
|
// clang-format off
|
|
static const KeywordMap<OptionParser> parser_map = {
|
|
{"devname", {1, 1, &SubsystemParser::ParseDevName}},
|
|
{"dirname", {1, 1, &SubsystemParser::ParseDirName}},
|
|
};
|
|
// clang-format on
|
|
|
|
auto parser = parser_map.Find(args);
|
|
|
|
if (!parser.ok()) return Error() << parser.error();
|
|
|
|
return std::invoke(*parser, this, std::move(args));
|
|
}
|
|
|
|
Result<void> SubsystemParser::EndSection() {
|
|
subsystems_->emplace_back(std::move(subsystem_));
|
|
|
|
return {};
|
|
}
|
|
|
|
UeventdConfiguration ParseConfig(const std::string& config) {
|
|
Parser parser;
|
|
UeventdConfiguration ueventd_configuration;
|
|
|
|
parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
|
|
parser.AddSectionParser("subsystem",
|
|
std::make_unique<SubsystemParser>(&ueventd_configuration.subsystems));
|
|
|
|
using namespace std::placeholders;
|
|
parser.AddSingleLineParser(
|
|
"/sys/",
|
|
std::bind(ParsePermissionsLine, _1, &ueventd_configuration.sysfs_permissions, nullptr));
|
|
parser.AddSingleLineParser("/dev/", std::bind(ParsePermissionsLine, _1, nullptr,
|
|
&ueventd_configuration.dev_permissions));
|
|
parser.AddSingleLineParser("firmware_directories",
|
|
std::bind(ParseFirmwareDirectoriesLine, _1,
|
|
&ueventd_configuration.firmware_directories));
|
|
parser.AddSingleLineParser("external_firmware_handler",
|
|
std::bind(ParseExternalFirmwareHandlerLine, _1,
|
|
&ueventd_configuration.external_firmware_handlers));
|
|
parser.AddSingleLineParser("modalias_handling",
|
|
std::bind(ParseEnabledDisabledLine, _1,
|
|
&ueventd_configuration.enable_modalias_handling));
|
|
parser.AddSingleLineParser("uevent_socket_rcvbuf_size",
|
|
std::bind(ParseUeventSocketRcvbufSizeLine, _1,
|
|
&ueventd_configuration.uevent_socket_rcvbuf_size));
|
|
parser.AddSingleLineParser("parallel_restorecon",
|
|
std::bind(ParseEnabledDisabledLine, _1,
|
|
&ueventd_configuration.enable_parallel_restorecon));
|
|
|
|
parser.ParseConfig(config);
|
|
|
|
return ueventd_configuration;
|
|
}
|
|
|
|
} // namespace init
|
|
} // namespace android
|