blob: 6f8a4de93d3c7a4594af926916ccfb50b5722ed3 [file] [log] [blame]
/*
* 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 "persistent_properties.h"
#include <dirent.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/system_properties.h>
#include <sys/types.h>
#include <memory>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include "util.h"
using android::base::Dirname;
using android::base::ReadFdToString;
using android::base::StartsWith;
using android::base::unique_fd;
using android::base::WriteStringToFd;
namespace android {
namespace init {
std::string persistent_property_filename = "/data/property/persistent_properties";
namespace {
constexpr const char kLegacyPersistentPropertyDir[] = "/data/property";
void AddPersistentProperty(const std::string& name, const std::string& value,
PersistentProperties* persistent_properties) {
auto persistent_property_record = persistent_properties->add_properties();
persistent_property_record->set_name(name);
persistent_property_record->set_value(value);
}
Result<PersistentProperties> LoadLegacyPersistentProperties() {
std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kLegacyPersistentPropertyDir), closedir);
if (!dir) {
return ErrnoError() << "Unable to open persistent property directory \""
<< kLegacyPersistentPropertyDir << "\"";
}
PersistentProperties persistent_properties;
dirent* entry;
while ((entry = readdir(dir.get())) != nullptr) {
if (!StartsWith(entry->d_name, "persist.")) {
continue;
}
if (entry->d_type != DT_REG) {
continue;
}
unique_fd fd(openat(dirfd(dir.get()), entry->d_name, O_RDONLY | O_NOFOLLOW | O_CLOEXEC));
if (fd == -1) {
PLOG(ERROR) << "Unable to open persistent property file \"" << entry->d_name << "\"";
continue;
}
struct stat sb;
if (fstat(fd.get(), &sb) == -1) {
PLOG(ERROR) << "fstat on property file \"" << entry->d_name << "\" failed";
continue;
}
// File must not be accessible to others, be owned by root/root, and
// not be a hard link to any other file.
if (((sb.st_mode & (S_IRWXG | S_IRWXO)) != 0) || sb.st_uid != 0 || sb.st_gid != 0 ||
sb.st_nlink != 1) {
PLOG(ERROR) << "skipping insecure property file " << entry->d_name
<< " (uid=" << sb.st_uid << " gid=" << sb.st_gid << " nlink=" << sb.st_nlink
<< " mode=" << std::oct << sb.st_mode << ")";
continue;
}
std::string value;
if (ReadFdToString(fd, &value)) {
AddPersistentProperty(entry->d_name, value, &persistent_properties);
} else {
PLOG(ERROR) << "Unable to read persistent property file " << entry->d_name;
}
}
return persistent_properties;
}
void RemoveLegacyPersistentPropertyFiles() {
std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kLegacyPersistentPropertyDir), closedir);
if (!dir) {
PLOG(ERROR) << "Unable to open persistent property directory \""
<< kLegacyPersistentPropertyDir << "\"";
return;
}
dirent* entry;
while ((entry = readdir(dir.get())) != nullptr) {
if (!StartsWith(entry->d_name, "persist.")) {
continue;
}
if (entry->d_type != DT_REG) {
continue;
}
unlinkat(dirfd(dir.get()), entry->d_name, 0);
}
}
Result<std::string> ReadPersistentPropertyFile() {
const std::string temp_filename = persistent_property_filename + ".tmp";
if (access(temp_filename.c_str(), F_OK) == 0) {
LOG(INFO)
<< "Found temporary property file while attempting to persistent system properties"
" a previous persistent property write may have failed";
unlink(temp_filename.c_str());
}
auto file_contents = ReadFile(persistent_property_filename);
if (!file_contents.ok()) {
return Error() << "Unable to read persistent property file: " << file_contents.error();
}
return *file_contents;
}
Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file_contents) {
PersistentProperties persistent_properties;
if (!persistent_properties.ParseFromString(file_contents)) {
return Error() << "Unable to parse persistent property file: Could not parse protobuf";
}
for (auto& prop : persistent_properties.properties()) {
if (!StartsWith(prop.name(), "persist.") && !StartsWith(prop.name(), "next_boot.")) {
return Error() << "Unable to load persistent property file: property '" << prop.name()
<< "' doesn't start with 'persist.' or 'next_boot.'";
}
}
return persistent_properties;
}
} // namespace
Result<PersistentProperties> LoadPersistentPropertyFile() {
auto file_contents = ReadPersistentPropertyFile();
if (!file_contents.ok()) return file_contents.error();
auto persistent_properties = ParsePersistentPropertyFile(*file_contents);
if (!persistent_properties.ok()) {
// If the file cannot be parsed in either format, then we don't have any recovery
// mechanisms, so we delete it to allow for future writes to take place successfully.
unlink(persistent_property_filename.c_str());
}
return persistent_properties;
}
Result<void> WritePersistentPropertyFile(const PersistentProperties& persistent_properties) {
const std::string temp_filename = persistent_property_filename + ".tmp";
unique_fd fd(TEMP_FAILURE_RETRY(
open(temp_filename.c_str(), O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0600)));
if (fd == -1) {
return ErrnoError() << "Could not open temporary properties file";
}
std::string serialized_string;
if (!persistent_properties.SerializeToString(&serialized_string)) {
return Error() << "Unable to serialize properties";
}
if (!WriteStringToFd(serialized_string, fd)) {
return ErrnoError() << "Unable to write file contents";
}
fsync(fd.get());
fd.reset();
if (rename(temp_filename.c_str(), persistent_property_filename.c_str())) {
int saved_errno = errno;
unlink(temp_filename.c_str());
return Error(saved_errno) << "Unable to rename persistent property file";
}
// rename() is atomic with regards to the kernel's filesystem buffers, but the parent
// directories must be fsync()'ed otherwise, the rename is not necessarily written to storage.
// Note in this case, that the source and destination directories are the same, so only one
// fsync() is required.
auto dir = Dirname(persistent_property_filename);
auto dir_fd = unique_fd{open(dir.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)};
if (dir_fd < 0) {
return ErrnoError() << "Unable to open persistent properties directory for fsync()";
}
fsync(dir_fd.get());
return {};
}
PersistentProperties LoadPersistentPropertiesFromMemory() {
PersistentProperties persistent_properties;
__system_property_foreach(
[](const prop_info* pi, void* cookie) {
__system_property_read_callback(
pi,
[](void* cookie, const char* name, const char* value, unsigned serial) {
if (StartsWith(name, "persist.")) {
auto properties = reinterpret_cast<PersistentProperties*>(cookie);
AddPersistentProperty(name, value, properties);
}
},
cookie);
},
&persistent_properties);
return persistent_properties;
}
// Persistent properties are not written often, so we rather not keep any data in memory and read
// then rewrite the persistent property file for each update.
void WritePersistentProperty(const std::string& name, const std::string& value) {
auto persistent_properties = LoadPersistentPropertyFile();
if (!persistent_properties.ok()) {
LOG(ERROR) << "Recovering persistent properties from memory: "
<< persistent_properties.error();
persistent_properties = LoadPersistentPropertiesFromMemory();
}
auto it = std::find_if(persistent_properties->mutable_properties()->begin(),
persistent_properties->mutable_properties()->end(),
[&name](const auto& record) { return record.name() == name; });
if (it != persistent_properties->mutable_properties()->end()) {
it->set_name(name);
it->set_value(value);
} else {
AddPersistentProperty(name, value, &persistent_properties.value());
}
if (auto result = WritePersistentPropertyFile(*persistent_properties); !result.ok()) {
LOG(ERROR) << "Could not store persistent property: " << result.error();
}
}
PersistentProperties LoadPersistentProperties() {
auto persistent_properties = LoadPersistentPropertyFile();
if (!persistent_properties.ok()) {
LOG(ERROR) << "Could not load single persistent property file, trying legacy directory: "
<< persistent_properties.error();
persistent_properties = LoadLegacyPersistentProperties();
if (!persistent_properties.ok()) {
LOG(ERROR) << "Unable to load legacy persistent properties: "
<< persistent_properties.error();
return {};
}
if (auto result = WritePersistentPropertyFile(*persistent_properties); result.ok()) {
RemoveLegacyPersistentPropertyFiles();
} else {
LOG(ERROR) << "Unable to write single persistent property file: " << result.error();
// Fall through so that we still set the properties that we've read.
}
}
// loop over to find all staged props
auto const staged_prefix = std::string_view("next_boot.");
auto staged_props = std::unordered_map<std::string, std::string>();
for (const auto& property_record : persistent_properties->properties()) {
auto const& prop_name = property_record.name();
auto const& prop_value = property_record.value();
if (StartsWith(prop_name, staged_prefix)) {
auto actual_prop_name = prop_name.substr(staged_prefix.size());
staged_props[actual_prop_name] = prop_value;
}
}
if (staged_props.empty()) {
return *persistent_properties;
}
// if has staging, apply staging and perserve the original prop order
PersistentProperties updated_persistent_properties;
for (const auto& property_record : persistent_properties->properties()) {
auto const& prop_name = property_record.name();
auto const& prop_value = property_record.value();
// don't include staged props anymore
if (StartsWith(prop_name, staged_prefix)) {
continue;
}
auto iter = staged_props.find(prop_name);
if (iter != staged_props.end()) {
AddPersistentProperty(prop_name, iter->second, &updated_persistent_properties);
staged_props.erase(iter);
} else {
AddPersistentProperty(prop_name, prop_value, &updated_persistent_properties);
}
}
// add any additional staged props
for (auto const& [prop_name, prop_value] : staged_props) {
AddPersistentProperty(prop_name, prop_value, &updated_persistent_properties);
}
// write current updated persist prop file
auto result = WritePersistentPropertyFile(updated_persistent_properties);
if (!result.ok()) {
LOG(ERROR) << "Could not store persistent property: " << result.error();
}
return updated_persistent_properties;
}
} // namespace init
} // namespace android