| /* |
| * Copyright (C) 2016 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 "Coordinator.h" |
| |
| #include <dirent.h> |
| #include <sys/stat.h> |
| |
| #include <algorithm> |
| #include <iterator> |
| |
| #include <android-base/logging.h> |
| #include <hidl-hash/Hash.h> |
| #include <hidl-util/StringHelper.h> |
| |
| #include "AST.h" |
| #include "Interface.h" |
| |
| extern android::status_t parseFile(android::AST *ast); |
| |
| static bool existdir(const char *name) { |
| DIR *dir = opendir(name); |
| if (dir == NULL) { |
| return false; |
| } |
| closedir(dir); |
| return true; |
| } |
| |
| namespace android { |
| |
| Coordinator::Coordinator( |
| const std::vector<std::string> &packageRootPaths, |
| const std::vector<std::string> &packageRoots) |
| : mPackageRootPaths(packageRootPaths), |
| mPackageRoots(packageRoots) { |
| // empty |
| } |
| |
| Coordinator::~Coordinator() { |
| // empty |
| } |
| |
| AST *Coordinator::parse(const FQName &fqName, std::set<AST *> *parsedASTs, bool enforce) { |
| CHECK(fqName.isFullyQualified()); |
| |
| auto it = mCache.find(fqName); |
| if (it != mCache.end()) { |
| AST *ast = (*it).second; |
| |
| if (ast != nullptr && parsedASTs != nullptr) { |
| parsedASTs->insert(ast); |
| } |
| |
| return ast; |
| } |
| |
| // Add this to the cache immediately, so we can discover circular imports. |
| mCache[fqName] = nullptr; |
| |
| AST *typesAST = nullptr; |
| |
| if (fqName.name() != "types") { |
| // Any interface file implicitly imports its package's types.hal. |
| FQName typesName = fqName.getTypesForPackage(); |
| // Do not enforce on imports. |
| typesAST = parse(typesName, parsedASTs, false /* enforce */); |
| |
| // fall through. |
| } |
| |
| std::string path = getPackagePath(fqName); |
| |
| path.append(fqName.name()); |
| path.append(".hal"); |
| |
| AST *ast = new AST(this, path); |
| |
| if (typesAST != NULL) { |
| // If types.hal for this AST's package existed, make it's defined |
| // types available to the (about to be parsed) AST right away. |
| ast->addImportedAST(typesAST); |
| } |
| |
| status_t err = parseFile(ast); |
| |
| if (err != OK) { |
| // LOG(ERROR) << "parsing '" << path << "' FAILED."; |
| |
| delete ast; |
| ast = nullptr; |
| |
| return nullptr; |
| } |
| |
| if (ast->package().package() != fqName.package() |
| || ast->package().version() != fqName.version()) { |
| fprintf(stderr, |
| "ERROR: File at '%s' does not match expected package and/or " |
| "version.\n", |
| path.c_str()); |
| |
| err = UNKNOWN_ERROR; |
| } else { |
| std::string ifaceName; |
| if (ast->isInterface(&ifaceName)) { |
| if (fqName.name() == "types") { |
| fprintf(stderr, |
| "ERROR: File at '%s' declares an interface '%s' " |
| "instead of the expected types common to the package.\n", |
| path.c_str(), |
| ifaceName.c_str()); |
| |
| err = UNKNOWN_ERROR; |
| } else if (ifaceName != fqName.name()) { |
| fprintf(stderr, |
| "ERROR: File at '%s' does not declare interface type " |
| "'%s'.\n", |
| path.c_str(), |
| fqName.name().c_str()); |
| |
| err = UNKNOWN_ERROR; |
| } |
| } else if (fqName.name() != "types") { |
| fprintf(stderr, |
| "ERROR: File at '%s' declares types rather than the " |
| "expected interface type '%s'.\n", |
| path.c_str(), |
| fqName.name().c_str()); |
| |
| err = UNKNOWN_ERROR; |
| } else if (ast->containsInterfaces()) { |
| fprintf(stderr, |
| "ERROR: types.hal file at '%s' declares at least one " |
| "interface type.\n", |
| path.c_str()); |
| |
| err = UNKNOWN_ERROR; |
| } |
| } |
| |
| if (err != OK) { |
| delete ast; |
| ast = nullptr; |
| |
| return nullptr; |
| } |
| |
| if (parsedASTs != nullptr) { parsedASTs->insert(ast); } |
| |
| // put it into the cache now, so that enforceRestrictionsOnPackage can |
| // parse fqName. |
| mCache[fqName] = ast; |
| |
| if (enforce) { |
| // For each .hal file that hidl-gen parses, the whole package will be checked. |
| err = enforceRestrictionsOnPackage(fqName); |
| if (err != OK) { |
| mCache[fqName] = nullptr; |
| delete ast; |
| ast = nullptr; |
| return nullptr; |
| } |
| } |
| |
| return ast; |
| } |
| |
| std::vector<std::string>::const_iterator |
| Coordinator::findPackageRoot(const FQName &fqName) const { |
| CHECK(!fqName.package().empty()); |
| CHECK(!fqName.version().empty()); |
| |
| // Find the right package prefix and path for this FQName. For |
| // example, if FQName is "android.hardware.nfc@1.0::INfc", and the |
| // prefix:root is set to [ "android.hardware:hardware/interfaces", |
| // "vendor.qcom.hardware:vendor/qcom"], then we will identify the |
| // prefix "android.hardware" and the package root |
| // "hardware/interfaces". |
| |
| auto it = mPackageRoots.begin(); |
| auto ret = mPackageRoots.end(); |
| for (; it != mPackageRoots.end(); it++) { |
| if (!fqName.inPackage(*it)) { |
| continue; |
| } |
| |
| CHECK(ret == mPackageRoots.end()) |
| << "Multiple package roots found for " << fqName.string() |
| << " (" << *it << " and " << *ret << ")"; |
| |
| ret = it; |
| } |
| CHECK(ret != mPackageRoots.end()) |
| << "Unable to find package root for " << fqName.string(); |
| |
| return ret; |
| } |
| |
| std::string Coordinator::getPackageRoot(const FQName &fqName) const { |
| auto it = findPackageRoot(fqName); |
| auto prefix = *it; |
| return prefix; |
| } |
| |
| std::string Coordinator::getPackageRootPath(const FQName &fqName) const { |
| auto it = findPackageRoot(fqName); |
| auto root = mPackageRootPaths[std::distance(mPackageRoots.begin(), it)]; |
| return root; |
| } |
| |
| std::string Coordinator::getPackageRootOption(const FQName &fqName) const { |
| return getPackageRoot(fqName) + ":" + getPackageRootPath(fqName); |
| } |
| |
| std::string Coordinator::getPackagePath( |
| const FQName &fqName, bool relative, bool sanitized) const { |
| |
| auto it = findPackageRoot(fqName); |
| auto prefix = *it; |
| auto root = mPackageRootPaths[std::distance(mPackageRoots.begin(), it)]; |
| |
| // Make sure the prefix ends on a '.' and the root path on a '/' |
| if ((*--prefix.end()) != '.') { |
| prefix += '.'; |
| } |
| |
| if ((*--root.end()) != '/') { |
| root += '/'; |
| } |
| |
| // Given FQName of "android.hardware.nfc@1.0::IFoo" and a prefix |
| // "android.hardware.", the suffix is "nfc@1.0::IFoo". |
| const std::string packageSuffix = fqName.package().substr(prefix.length()); |
| |
| std::string packagePath; |
| if (!relative) { |
| packagePath = root; |
| } |
| |
| size_t startPos = 0; |
| size_t dotPos; |
| while ((dotPos = packageSuffix.find('.', startPos)) != std::string::npos) { |
| packagePath.append(packageSuffix.substr(startPos, dotPos - startPos)); |
| packagePath.append("/"); |
| |
| startPos = dotPos + 1; |
| } |
| CHECK_LT(startPos + 1, packageSuffix.length()); |
| packagePath.append(packageSuffix.substr(startPos)); |
| packagePath.append("/"); |
| |
| packagePath.append(sanitized ? fqName.sanitizedVersion() : fqName.version()); |
| packagePath.append("/"); |
| |
| return packagePath; |
| } |
| |
| status_t Coordinator::getPackageInterfaceFiles( |
| const FQName &package, |
| std::vector<std::string> *fileNames) const { |
| fileNames->clear(); |
| |
| const std::string packagePath = getPackagePath(package); |
| |
| DIR *dir = opendir(packagePath.c_str()); |
| |
| if (dir == NULL) { |
| LOG(ERROR) << "Could not open package path: " << packagePath; |
| return -errno; |
| } |
| |
| struct dirent *ent; |
| while ((ent = readdir(dir)) != NULL) { |
| if (ent->d_type != DT_REG) { |
| continue; |
| } |
| |
| const auto suffix = ".hal"; |
| const auto suffix_len = std::strlen(suffix); |
| const auto d_namelen = strlen(ent->d_name); |
| |
| if (d_namelen < suffix_len |
| || strcmp(ent->d_name + d_namelen - suffix_len, suffix)) { |
| continue; |
| } |
| |
| fileNames->push_back(std::string(ent->d_name, d_namelen - suffix_len)); |
| } |
| |
| closedir(dir); |
| dir = NULL; |
| |
| std::sort(fileNames->begin(), fileNames->end(), |
| [](const std::string& lhs, const std::string& rhs) -> bool { |
| if (lhs == "types") { |
| return true; |
| } |
| if (rhs == "types") { |
| return false; |
| } |
| return lhs < rhs; |
| }); |
| |
| return OK; |
| } |
| |
| status_t Coordinator::appendPackageInterfacesToVector( |
| const FQName &package, |
| std::vector<FQName> *packageInterfaces) const { |
| packageInterfaces->clear(); |
| |
| std::vector<std::string> fileNames; |
| status_t err = getPackageInterfaceFiles(package, &fileNames); |
| |
| if (err != OK) { |
| return err; |
| } |
| |
| for (const auto &fileName : fileNames) { |
| FQName subFQName( |
| package.package() + package.atVersion() + "::" + fileName); |
| |
| if (!subFQName.isValid()) { |
| LOG(WARNING) |
| << "Whole-package import encountered invalid filename '" |
| << fileName |
| << "' in package " |
| << package.package() |
| << package.atVersion(); |
| |
| continue; |
| } |
| |
| packageInterfaces->push_back(subFQName); |
| } |
| |
| return OK; |
| } |
| |
| std::string Coordinator::convertPackageRootToPath(const FQName &fqName) const { |
| std::string packageRoot = getPackageRoot(fqName); |
| |
| if (*(packageRoot.end()--) != '.') { |
| packageRoot += '.'; |
| } |
| |
| std::replace(packageRoot.begin(), packageRoot.end(), '.', '/'); |
| |
| return packageRoot; // now converted to a path |
| } |
| |
| |
| status_t Coordinator::enforceRestrictionsOnPackage(const FQName &fqName) { |
| // need fqName to be something like android.hardware.foo@1.0. |
| // name and valueName is ignored. |
| if (fqName.package().empty() || fqName.version().empty()) { |
| LOG(ERROR) << "Cannot enforce restrictions on package " << fqName.string() |
| << ": package or version is missing."; |
| return BAD_VALUE; |
| } |
| FQName package = fqName.getPackageAndVersion(); |
| // look up cache. |
| if (mPackagesEnforced.find(package) != mPackagesEnforced.end()) { |
| return OK; |
| } |
| |
| // enforce all rules. |
| status_t err; |
| |
| err = enforceMinorVersionUprevs(package); |
| if (err != OK) { |
| return err; |
| } |
| |
| err = enforceHashes(package); |
| if (err != OK) { |
| return err; |
| } |
| |
| // cache it so that it won't need to be enforced again. |
| mPackagesEnforced.insert(package); |
| return OK; |
| } |
| |
| status_t Coordinator::enforceMinorVersionUprevs(const FQName ¤tPackage) { |
| if(!currentPackage.hasVersion()) { |
| LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string() |
| << ": missing version."; |
| return UNKNOWN_ERROR; |
| } |
| |
| if (currentPackage.getPackageMinorVersion() == 0) { |
| return OK; // ignore for @x.0 |
| } |
| |
| bool hasPrevPackage = false; |
| FQName prevPacakge = currentPackage; |
| while (prevPacakge.getPackageMinorVersion() > 0) { |
| prevPacakge = prevPacakge.downRev(); |
| if (existdir(getPackagePath(prevPacakge).c_str())) { |
| hasPrevPackage = true; |
| break; |
| } |
| } |
| if (!hasPrevPackage) { |
| // no @x.z, where z < y, exist. |
| return OK; |
| } |
| |
| if (prevPacakge != currentPackage.downRev()) { |
| LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string() |
| << ": Found package " << prevPacakge.string() << " but missing " |
| << currentPackage.downRev().string() << "; you cannot skip a minor version."; |
| return UNKNOWN_ERROR; |
| } |
| |
| status_t err; |
| std::vector<FQName> packageInterfaces; |
| err = appendPackageInterfacesToVector(currentPackage, &packageInterfaces); |
| if (err != OK) { |
| return err; |
| } |
| |
| bool extendedInterface = false; |
| for (const FQName ¤tFQName : packageInterfaces) { |
| if (currentFQName.name() == "types") { |
| continue; // ignore types.hal |
| } |
| // Assume that currentFQName == android.hardware.foo@2.2::IFoo. |
| // Then prevFQName == android.hardware.foo@2.1::IFoo. |
| const Interface *iface = nullptr; |
| AST *currentAST = parse(currentFQName); |
| if (currentAST != nullptr) { |
| iface = currentAST->getInterface(); |
| } |
| if (iface == nullptr) { |
| if (currentAST == nullptr) { |
| LOG(WARNING) << "Warning: Skipping " << currentFQName.string() |
| << " because it could not be found or parsed" |
| << " or " << currentPackage.string() |
| << " doesn't pass all requirements."; |
| } else { |
| LOG(WARNING) << "Warning: Skipping " << currentFQName.string() |
| << " because the file might contain more than one interface."; |
| } |
| continue; |
| } |
| |
| // android.hardware.foo@2.2::IFoo exists. Now make sure |
| // @2.2::IFoo extends @2.1::IFoo. If any interface IFoo in @2.2 |
| // ensures this, @2.2 passes the enforcement. |
| FQName prevFQName(prevPacakge.package(), prevPacakge.version(), |
| currentFQName.name()); |
| if (iface->superType() == nullptr) { |
| // @2.2::IFoo doesn't extend anything. (This is probably IBase.) |
| continue; |
| } |
| if (iface->superType()->fqName() != prevFQName) { |
| // @2.2::IFoo doesn't extend @2.1::IFoo. |
| if (iface->superType()->fqName().getPackageAndVersion() == |
| prevPacakge.getPackageAndVersion()) { |
| LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string() |
| << ": " << iface->fqName().string() << " extends " |
| << iface->superType()->fqName().string() << ", which is not allowed."; |
| return UNKNOWN_ERROR; |
| } |
| // @2.2::IFoo extends something from a package with a different package name. |
| // Check the next interface. |
| continue; |
| } |
| |
| // @2.2::IFoo passes. Check next interface. |
| extendedInterface = true; |
| LOG(VERBOSE) << "enforceMinorVersionUprevs: " << currentFQName.string() << " passes."; |
| } |
| |
| if (!extendedInterface) { |
| // No interface extends the interface with the same name in @x.(y-1). |
| LOG(ERROR) << currentPackage.string() << " doesn't pass minor version uprev requirement. " |
| << "Requires at least one interface to extend an interface with the same name " |
| << "from " << prevPacakge.string() << "."; |
| return UNKNOWN_ERROR; |
| } |
| |
| return OK; |
| } |
| |
| status_t Coordinator::enforceHashes(const FQName ¤tPackage) { |
| status_t err = OK; |
| std::vector<FQName> packageInterfaces; |
| err = appendPackageInterfacesToVector(currentPackage, &packageInterfaces); |
| if (err != OK) { |
| return err; |
| } |
| |
| for (const FQName ¤tFQName : packageInterfaces) { |
| AST *ast = parse(currentFQName); |
| |
| if (ast == nullptr) { |
| err = UNKNOWN_ERROR; |
| continue; |
| } |
| |
| std::string hashPath = getPackageRootPath(currentFQName) + "/current.txt"; |
| std::string error; |
| std::vector<std::string> frozen = Hash::lookupHash(hashPath, currentFQName.string(), &error); |
| |
| if (error.size() > 0) { |
| LOG(ERROR) << error; |
| err = UNKNOWN_ERROR; |
| continue; |
| } |
| |
| // hash not define, interface not frozen |
| if (frozen.size() == 0) { |
| continue; |
| } |
| |
| std::string currentHash = Hash::getHash(ast->getFilename()).hexString(); |
| |
| if(std::find(frozen.begin(), frozen.end(), currentHash) == frozen.end()) { |
| LOG(ERROR) << currentFQName.string() << " has hash " << currentHash |
| << " which does not match hash on record. This interface has " |
| << "been frozen. Do not change it!"; |
| err = UNKNOWN_ERROR; |
| continue; |
| } |
| } |
| |
| return err; |
| } |
| |
| // static |
| bool Coordinator::MakeParentHierarchy(const std::string &path) { |
| static const mode_t kMode = 0755; |
| |
| size_t start = 1; // Ignore leading '/' |
| size_t slashPos; |
| while ((slashPos = path.find("/", start)) != std::string::npos) { |
| std::string partial = path.substr(0, slashPos); |
| |
| struct stat st; |
| if (stat(partial.c_str(), &st) < 0) { |
| if (errno != ENOENT) { |
| return false; |
| } |
| |
| int res = mkdir(partial.c_str(), kMode); |
| if (res < 0) { |
| return false; |
| } |
| } else if (!S_ISDIR(st.st_mode)) { |
| return false; |
| } |
| |
| start = slashPos + 1; |
| } |
| |
| return true; |
| } |
| |
| } // namespace android |
| |
