| // Copyright 2016 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Library to provide access to the Chrome OS master configuration |
| |
| #include "chromeos-config/libcros_config/cros_config.h" |
| #include "chromeos-config/libcros_config/identity.h" |
| |
| // TODO(sjg@chromium.org): See if this can be accepted upstream. |
| extern "C" { |
| #include <libfdt.h> |
| }; |
| #include <stdlib.h> |
| |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <base/logging.h> |
| #include <base/strings/string_split.h> |
| #include <base/strings/string_util.h> |
| |
| namespace { |
| const char kConfigDtbPath[] = "/usr/share/chromeos-config/config.dtb"; |
| const char kTargetDirsPath[] = "/chromeos/schema/target-dirs"; |
| const char kSchemaPath[] = "/chromeos/schema"; |
| const char kPhandleProperties[] = "phandle-properties"; |
| } // namespace |
| |
| namespace brillo { |
| |
| bool CrosConfigInterface::IsLoggingEnabled() { |
| static const char* logging_var = getenv("CROS_CONFIG_DEBUG"); |
| static bool enabled = logging_var && *logging_var; |
| return enabled; |
| } |
| |
| bool CrosConfig::InitModel() { |
| return InitForConfig(base::FilePath(kConfigDtbPath)); |
| } |
| |
| std::string CrosConfig::GetFullPath(int offset) { |
| const void* blob = blob_.c_str(); |
| char buf[256]; |
| int err; |
| |
| err = fdt_get_path(blob, offset, buf, sizeof(buf)); |
| if (err) { |
| CROS_CONFIG_LOG(WARNING) << "Cannot get full path: " << fdt_strerror(err); |
| return "unknown"; |
| } |
| |
| return std::string(buf); |
| } |
| |
| int CrosConfig::GetPathOffset(int base_offset, const std::string& path) { |
| const void* blob = blob_.c_str(); |
| auto parts = base::SplitString(path.substr(1), "/", base::KEEP_WHITESPACE, |
| base::SPLIT_WANT_ALL); |
| int offset = base_offset; |
| for (auto part : parts) { |
| offset = fdt_subnode_offset(blob, offset, part.c_str()); |
| if (offset < 0) { |
| break; |
| } |
| } |
| return offset; |
| } |
| |
| bool CrosConfig::GetString(int base_offset, const std::string& path, |
| const std::string& prop, std::string* val_out, |
| std::vector<std::string>* log_msgs_out) { |
| const void* blob = blob_.c_str(); |
| |
| int subnode = GetPathOffset(base_offset, path); |
| int wl_subnode = -1; |
| if (whitelabel_offset_ != -1) { |
| wl_subnode = GetPathOffset(whitelabel_offset_, path); |
| if (subnode < 0 && wl_subnode >= 0) { |
| CROS_CONFIG_LOG(INFO) |
| << "The path " << GetFullPath(base_offset) << path |
| << " does not exist. Falling back to whitelabel path"; |
| subnode = wl_subnode; |
| } |
| } |
| if (subnode < 0) { |
| log_msgs_out->push_back("The path " + GetFullPath(base_offset) + path |
| + " does not exist."); |
| return false; |
| } |
| |
| int len = 0; |
| const char* ptr = static_cast<const char*>( |
| fdt_getprop(blob, subnode, prop.c_str(), &len)); |
| if (!ptr && wl_subnode >= 0) { |
| ptr = static_cast<const char*>(fdt_getprop(blob, wl_subnode, prop.c_str(), |
| &len)); |
| CROS_CONFIG_LOG(INFO) << "The property " << prop |
| << " does not exist. Falling back to " |
| << "whitelabel property"; |
| } |
| if (!ptr) { |
| int target_node; |
| for (int i = 0; i < phandle_props_.size(); i++) { |
| LookupPhandle(subnode, phandle_props_[i], &target_node); |
| if (target_node >= 0) { |
| ptr = static_cast<const char*>( |
| fdt_getprop(blob, target_node, prop.c_str(), &len)); |
| if (ptr) { |
| CROS_CONFIG_LOG(INFO) |
| << "Followed " << phandle_props_[i] << " phandle"; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (!ptr || len < 0) { |
| log_msgs_out->push_back("Cannot get path " + path + " property " + prop |
| + ": " + "full path " + GetFullPath(subnode) + ": " |
| + fdt_strerror(len)); |
| return false; |
| } |
| |
| // We must have a normally terminated string. This guards against a string |
| // list being used, or perhaps a property that does not contain a valid |
| // string at all. |
| if (!len || strnlen(ptr, len) != static_cast<size_t>(len - 1)) { |
| log_msgs_out->push_back("String at path " + path + " property " + prop |
| + " is invalid"); |
| return false; |
| } |
| |
| val_out->assign(ptr); |
| |
| return true; |
| } |
| |
| bool CrosConfig::GetString(const std::string& path, const std::string& prop, |
| std::string* val_out, |
| std::vector<std::string>* log_msgs_out) { |
| if (!InitCheck()) { |
| return false; |
| } |
| |
| if (model_offset_ < 0) { |
| log_msgs_out->push_back("Please specify the model to access."); |
| return false; |
| } |
| |
| if (path.size() == 0) { |
| log_msgs_out->push_back("Path must be specified"); |
| return false; |
| } |
| |
| if (path.substr(0, 1) != "/") { |
| log_msgs_out->push_back("Path must start with / specifying the root node"); |
| return false; |
| } |
| |
| if (whitelabel_tag_offset_ != -1) { |
| if (path == "/" && |
| GetString(whitelabel_tag_offset_, "/", prop, val_out, log_msgs_out)) { |
| return true; |
| } |
| // TODO(sjg@chromium.org): We are considering moving the key-id to the root |
| // of the model schema. If we do, we can drop this special case. |
| if (path == "/firmware" && prop == "key-id" && |
| GetString(whitelabel_tag_offset_, "/", prop, val_out, log_msgs_out)) { |
| return true; |
| } |
| } |
| if (!GetString(model_offset_, path, prop, val_out, log_msgs_out)) { |
| if (submodel_offset_ != -1 && |
| GetString(submodel_offset_, path, prop, val_out, log_msgs_out)) { |
| return true; |
| } |
| for (int offset : default_offsets_) { |
| if (GetString(offset, path, prop, val_out, log_msgs_out)) |
| return true; |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| bool CrosConfig::GetString(const std::string& path, const std::string& prop, |
| std::string* val_out) { |
| std::vector<std::string> log_msgs; |
| if (!GetString(path, prop, val_out, &log_msgs)) { |
| for (std::string msg : log_msgs) { |
| CROS_CONFIG_LOG(ERROR) << msg; |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| bool CrosConfig::GetAbsPath(const std::string& path, const std::string& prop, |
| std::string* val_out) { |
| std::string val; |
| if (!GetString(path, prop, &val)) { |
| return false; |
| } |
| |
| if (target_dirs_.find(prop) == target_dirs_.end()) { |
| CROS_CONFIG_LOG(ERROR) << "Absolute path requested at path " << path |
| << " property " << prop << ": not found"; |
| return false; |
| } |
| *val_out = target_dirs_[prop] + "/" + val; |
| |
| return true; |
| } |
| |
| bool CrosConfig::LookupPhandle(int node_offset, const std::string& prop_name, |
| int* offset_out) { |
| const void* blob = blob_.c_str(); |
| int len; |
| const fdt32_t* ptr = static_cast<const fdt32_t*>( |
| fdt_getprop(blob, node_offset, prop_name.c_str(), &len)); |
| |
| // We probably don't need all these checks since validation will ensure that |
| // the config is correct. But this is a critical tool and we want to avoid |
| // crashes in any situation. |
| *offset_out = -1; |
| if (!ptr) { |
| return false; |
| } |
| if (len != sizeof(fdt32_t)) { |
| CROS_CONFIG_LOG(ERROR) << prop_name << " phandle for model " << model_ |
| << " is of size " << len << " but should be " |
| << sizeof(fdt32_t); |
| return false; |
| } |
| int phandle = fdt32_to_cpu(*ptr); |
| int offset = fdt_node_offset_by_phandle(blob, phandle); |
| if (offset < 0) { |
| CROS_CONFIG_LOG(ERROR) << prop_name << "lookup for model " << model_ |
| << " failed: " << fdt_strerror(offset); |
| return false; |
| } |
| *offset_out = offset; |
| return true; |
| } |
| |
| bool CrosConfig::InitCommon(const base::FilePath& filepath, |
| const base::FilePath& mem_file, |
| const base::FilePath& vpd_file) { |
| // Many systems will not have a config database (yet), so just skip all the |
| // setup without any errors if the config file doesn't exist. |
| if (!base::PathExists(filepath)) { |
| return false; |
| } |
| |
| if (!base::ReadFileToString(filepath, &blob_)) { |
| CROS_CONFIG_LOG(ERROR) << "Could not read file " << filepath.MaybeAsASCII(); |
| return false; |
| } |
| const void* blob = blob_.c_str(); |
| int ret = fdt_check_header(blob); |
| if (ret) { |
| CROS_CONFIG_LOG(ERROR) << "Config file " << filepath.MaybeAsASCII() |
| << " is invalid: " << fdt_strerror(ret); |
| return false; |
| } |
| CrosConfigIdentity identity; |
| std::string name, customization_id; |
| int sku_id; |
| if (!identity.ReadIdentity(mem_file, vpd_file, &name, &sku_id, |
| &customization_id)) { |
| CROS_CONFIG_LOG(ERROR) << "Cannot read identity"; |
| return false; |
| } |
| if (!SelectModelConfigByIDs(name, sku_id, customization_id)) { |
| CROS_CONFIG_LOG(ERROR) << "Cannot find SKU for name " << name << " SKU ID " |
| << sku_id; |
| return false; |
| } |
| |
| int target_dirs_offset = fdt_path_offset(blob, kTargetDirsPath); |
| if (target_dirs_offset >= 0) { |
| for (int poffset = fdt_first_property_offset(blob, target_dirs_offset); |
| poffset >= 0; |
| poffset = fdt_next_property_offset(blob, poffset)) { |
| int len; |
| const struct fdt_property* prop = fdt_get_property_by_offset(blob, |
| poffset, &len); |
| const char* name = fdt_string(blob, fdt32_to_cpu(prop->nameoff)); |
| target_dirs_[name] = prop->data; |
| } |
| } else if (target_dirs_offset < 0) { |
| CROS_CONFIG_LOG(WARNING) << "Cannot find " << kTargetDirsPath |
| << " node: " << fdt_strerror(target_dirs_offset); |
| } |
| int schema_offset = fdt_path_offset(blob, kSchemaPath); |
| if (schema_offset >= 0) { |
| int len; |
| const char* prop = static_cast<const char*>( |
| fdt_getprop(blob, schema_offset, kPhandleProperties, &len)); |
| if (prop) { |
| const char* end = prop + len; |
| for (const char* ptr = prop; ptr < end; ptr += strlen(ptr) + 1) { |
| phandle_props_.push_back(ptr); |
| } |
| } else { |
| CROS_CONFIG_LOG(WARNING) << "Cannot find property " << kPhandleProperties |
| << " node: " << fdt_strerror(len); |
| } |
| } else if (schema_offset < 0) { |
| CROS_CONFIG_LOG(WARNING) << "Cannot find " << kSchemaPath |
| << " node: " << fdt_strerror(schema_offset); |
| } |
| |
| // See if there is a whitelabel config for this model. |
| if (whitelabel_offset_ == -1) { |
| LookupPhandle(model_offset_, "whitelabel", &whitelabel_offset_); |
| } |
| int next_offset; |
| default_offsets_.clear(); |
| for (int offset = model_offset_; |
| LookupPhandle(offset, "default", &next_offset); |
| offset = next_offset) { |
| if (std::find(default_offsets_.begin(), default_offsets_.end(), |
| next_offset) != default_offsets_.end()) { |
| CROS_CONFIG_LOG(ERROR) << "Circular default at " << GetFullPath(offset); |
| return false; |
| } |
| default_offsets_.push_back(next_offset); |
| } |
| |
| CROS_CONFIG_LOG(INFO) << "Using master configuration for model " |
| << model_name_ << ", submodel " |
| << (submodel_name_.empty() ? "(none)" : submodel_name_); |
| if (whitelabel_offset_ != -1) { |
| CROS_CONFIG_LOG(INFO) << "Whitelabel of " |
| << fdt_get_name(blob, whitelabel_offset_, NULL); |
| } else if (whitelabel_tag_offset_ != -1) { |
| CROS_CONFIG_LOG(INFO) << "Whitelabel tag " |
| << fdt_get_name(blob, whitelabel_tag_offset_, NULL); |
| } |
| inited_ = true; |
| |
| return true; |
| } |
| |
| } // namespace brillo |
