d17d5c585e
Allow ueventd configuration to specify what to do with devices based on driver. This responds to bind events and treats them similarly to add events. The format of the driver stanza is exactly the same as that of the subsystem stanza. Bug: 376900376 Test: set up cbc_mbim driver stanza and ensure it properly creates and destroys device nodes when a USB device with that driver appears and disappears or is bound and unbound Change-Id: I31f5c91bd074d14075b74fe7beefaa6ac07a7ac9
303 lines
11 KiB
C++
303 lines
11 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 || args.size() == 6)) {
|
|
return Error() << "/sys/ lines must have 5 or 6 entries";
|
|
}
|
|
|
|
if (!is_sysfs && !(args.size() == 4 || args.size() == 5)) {
|
|
return Error() << "/dev/ lines must have 4 or 5 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;
|
|
|
|
bool no_fnm_pathname = false;
|
|
if (it != args.end()) {
|
|
std::string& flags = *it++;
|
|
if (flags != "no_fnm_pathname") {
|
|
return Error() << "invalid option '" << flags << "', only no_fnm_pathname is supported";
|
|
}
|
|
no_fnm_pathname = true;
|
|
}
|
|
|
|
if (is_sysfs) {
|
|
out_sysfs_permissions->emplace_back(name, sysfs_attribute, perm, uid, gid, no_fnm_pathname);
|
|
} else {
|
|
out_dev_permissions->emplace_back(name, perm, uid, gid, no_fnm_pathname);
|
|
}
|
|
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 && args.size() != 5) {
|
|
return Error() << "external_firmware_handler lines must have 3 or 4 parameters";
|
|
}
|
|
|
|
if (std::find_if(external_firmware_handlers->begin(), external_firmware_handlers->end(),
|
|
[&args](const auto& other) { return other.devpath == args[1]; }) !=
|
|
external_firmware_handlers->end()) {
|
|
return Error() << "found a previous external_firmware_handler with the same devpath, '"
|
|
<< args[1] << "'";
|
|
}
|
|
|
|
passwd* pwd = getpwnam(args[2].c_str());
|
|
if (!pwd) {
|
|
return ErrnoError() << "invalid handler uid'" << args[2] << "'";
|
|
}
|
|
|
|
gid_t gid = 0;
|
|
int handler_index = 3;
|
|
if (args.size() == 5) {
|
|
struct group* grp = getgrnam(args[3].c_str());
|
|
if (!grp) {
|
|
return ErrnoError() << "invalid handler gid '" << args[3] << "'";
|
|
}
|
|
gid = grp->gr_gid;
|
|
handler_index = 4;
|
|
}
|
|
|
|
ExternalFirmwareHandler handler(std::move(args[1]), pwd->pw_uid, gid,
|
|
std::move(args[handler_index]));
|
|
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> ParseParallelRestoreconDirsLine(std::vector<std::string>&& args,
|
|
std::vector<std::string>* parallel_restorecon_dirs) {
|
|
if (args.size() != 2) {
|
|
return Error() << "parallel_restorecon_dir lines must have exactly 2 parameters";
|
|
}
|
|
|
|
std::move(std::next(args.begin()), args.end(), std::back_inserter(*parallel_restorecon_dirs));
|
|
|
|
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 {};
|
|
}
|
|
if (args[1] == "sys_name") {
|
|
subsystem_.devname_source_ = Subsystem::DEVNAME_SYS_NAME;
|
|
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::vector<std::string>& configs) {
|
|
Parser parser;
|
|
UeventdConfiguration ueventd_configuration;
|
|
|
|
parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
|
|
parser.AddSectionParser("subsystem",
|
|
std::make_unique<SubsystemParser>(&ueventd_configuration.subsystems));
|
|
parser.AddSectionParser("driver",
|
|
std::make_unique<SubsystemParser>(&ueventd_configuration.drivers));
|
|
|
|
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_dir",
|
|
std::bind(ParseParallelRestoreconDirsLine, _1,
|
|
&ueventd_configuration.parallel_restorecon_dirs));
|
|
parser.AddSingleLineParser("parallel_restorecon",
|
|
std::bind(ParseEnabledDisabledLine, _1,
|
|
&ueventd_configuration.enable_parallel_restorecon));
|
|
|
|
for (const auto& config : configs) {
|
|
parser.ParseConfig(config);
|
|
}
|
|
|
|
return ueventd_configuration;
|
|
}
|
|
|
|
} // namespace init
|
|
} // namespace android
|