377 lines
12 KiB
C++
377 lines
12 KiB
C++
|
#include "ManifestMerger.h"
|
||
|
|
#include "Maybe.h"
|
||
|
|
#include "ResourceParser.h"
|
||
|
|
#include "Source.h"
|
||
|
|
#include "Util.h"
|
||
|
|
#include "XmlPullParser.h"
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
#include <memory>
|
||
|
|
#include <set>
|
||
|
|
#include <string>
|
||
|
|
|
||
|
|
namespace aapt {
|
||
|
|
|
||
|
|
constexpr const char16_t* kSchemaAndroid = u"http://schemas.android.com/apk/res/android";
|
||
|
|
|
||
|
|
static xml::Element* findManifest(xml::Node* root) {
|
||
|
|
if (!root) {
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (root->type == xml::NodeType::kNamespace) {
|
||
|
|
if (root->children.empty()) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
root = root->children[0].get();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (root && root->type == xml::NodeType::kElement) {
|
||
|
|
xml::Element* el = static_cast<xml::Element*>(root);
|
||
|
|
if (el->namespaceUri.empty() && el->name == u"manifest") {
|
||
|
|
return el;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
static xml::Element* findChildWithSameName(xml::Element* parent, xml::Element* src) {
|
||
|
|
xml::Attribute* attrKey = src->findAttribute(kSchemaAndroid, u"name");
|
||
|
|
if (!attrKey) {
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
return parent->findChildWithAttribute(src->namespaceUri, src->name, attrKey);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool attrLess(const xml::Attribute& lhs, const xml::Attribute& rhs) {
|
||
|
|
return std::tie(lhs.namespaceUri, lhs.name, lhs.value)
|
||
|
|
< std::tie(rhs.namespaceUri, rhs.name, rhs.value);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int compare(xml::Element* lhs, xml::Element* rhs) {
|
||
|
|
int diff = lhs->attributes.size() - rhs->attributes.size();
|
||
|
|
if (diff != 0) {
|
||
|
|
return diff;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::set<xml::Attribute, decltype(&attrLess)> lhsAttrs(&attrLess);
|
||
|
|
lhsAttrs.insert(lhs->attributes.begin(), lhs->attributes.end());
|
||
|
|
for (auto& attr : rhs->attributes) {
|
||
|
|
if (lhsAttrs.erase(attr) == 0) {
|
||
|
|
// The rhs attribute is not in the left.
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!lhsAttrs.empty()) {
|
||
|
|
// The lhs has attributes not in the rhs.
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
ManifestMerger::ManifestMerger(const Options& options) :
|
||
|
|
mOptions(options), mAppLogger({}), mLogger({}) {
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::setAppManifest(const Source& source, const std::u16string& package,
|
||
|
|
std::unique_ptr<xml::Node> root) {
|
||
|
|
|
||
|
|
mAppLogger = SourceLogger{ source };
|
||
|
|
mRoot = std::move(root);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::checkEqual(xml::Element* elA, xml::Element* elB) {
|
||
|
|
if (compare(elA, elB) != 0) {
|
||
|
|
mLogger.error(elB->lineNumber)
|
||
|
|
<< "library tag '" << elB->name << "' conflicts with app tag."
|
||
|
|
<< std::endl;
|
||
|
|
mAppLogger.note(elA->lineNumber)
|
||
|
|
<< "app tag '" << elA->name << "' defined here."
|
||
|
|
<< std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<xml::Element*> childrenA = elA->getChildElements();
|
||
|
|
std::vector<xml::Element*> childrenB = elB->getChildElements();
|
||
|
|
|
||
|
|
if (childrenA.size() != childrenB.size()) {
|
||
|
|
mLogger.error(elB->lineNumber)
|
||
|
|
<< "library tag '" << elB->name << "' children conflict with app tag."
|
||
|
|
<< std::endl;
|
||
|
|
mAppLogger.note(elA->lineNumber)
|
||
|
|
<< "app tag '" << elA->name << "' defined here."
|
||
|
|
<< std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto cmp = [](xml::Element* lhs, xml::Element* rhs) -> bool {
|
||
|
|
return compare(lhs, rhs) < 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
std::sort(childrenA.begin(), childrenA.end(), cmp);
|
||
|
|
std::sort(childrenB.begin(), childrenB.end(), cmp);
|
||
|
|
|
||
|
|
for (size_t i = 0; i < childrenA.size(); i++) {
|
||
|
|
if (!checkEqual(childrenA[i], childrenB[i])) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::mergeNewOrEqual(xml::Element* parentA, xml::Element* elA, xml::Element* elB) {
|
||
|
|
if (!elA) {
|
||
|
|
parentA->addChild(elB->clone());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return checkEqual(elA, elB);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::mergePreferRequired(xml::Element* parentA, xml::Element* elA,
|
||
|
|
xml::Element* elB) {
|
||
|
|
if (!elA) {
|
||
|
|
parentA->addChild(elB->clone());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
xml::Attribute* reqA = elA->findAttribute(kSchemaAndroid, u"required");
|
||
|
|
xml::Attribute* reqB = elB->findAttribute(kSchemaAndroid, u"required");
|
||
|
|
bool requiredA = !reqA || (reqA->value != u"false" && reqA->value != u"FALSE");
|
||
|
|
bool requiredB = !reqB || (reqB->value != u"false" && reqB->value != u"FALSE");
|
||
|
|
if (!requiredA && requiredB) {
|
||
|
|
if (reqA) {
|
||
|
|
*reqA = xml::Attribute{ kSchemaAndroid, u"required", u"true" };
|
||
|
|
} else {
|
||
|
|
elA->attributes.push_back(xml::Attribute{ kSchemaAndroid, u"required", u"true" });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int findIntegerValue(xml::Attribute* attr, int defaultValue) {
|
||
|
|
if (attr) {
|
||
|
|
std::unique_ptr<BinaryPrimitive> integer = ResourceParser::tryParseInt(attr->value);
|
||
|
|
if (integer) {
|
||
|
|
return integer->value.data;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return defaultValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::mergeUsesSdk(xml::Element* elA, xml::Element* elB) {
|
||
|
|
bool error = false;
|
||
|
|
xml::Attribute* minAttrA = nullptr;
|
||
|
|
xml::Attribute* minAttrB = nullptr;
|
||
|
|
if (elA) {
|
||
|
|
minAttrA = elA->findAttribute(kSchemaAndroid, u"minSdkVersion");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (elB) {
|
||
|
|
minAttrB = elB->findAttribute(kSchemaAndroid, u"minSdkVersion");
|
||
|
|
}
|
||
|
|
|
||
|
|
int minSdkA = findIntegerValue(minAttrA, 1);
|
||
|
|
int minSdkB = findIntegerValue(minAttrB, 1);
|
||
|
|
|
||
|
|
if (minSdkA < minSdkB) {
|
||
|
|
std::ostream* out;
|
||
|
|
if (minAttrA) {
|
||
|
|
out = &(mAppLogger.error(elA->lineNumber) << "app declares ");
|
||
|
|
} else if (elA) {
|
||
|
|
out = &(mAppLogger.error(elA->lineNumber) << "app has implied ");
|
||
|
|
} else {
|
||
|
|
out = &(mAppLogger.error() << "app has implied ");
|
||
|
|
}
|
||
|
|
|
||
|
|
*out << "minSdkVersion=" << minSdkA << " but library expects a higher SDK version."
|
||
|
|
<< std::endl;
|
||
|
|
|
||
|
|
// elB is valid because minSdkB wouldn't be greater than minSdkA if it wasn't.
|
||
|
|
mLogger.note(elB->lineNumber)
|
||
|
|
<< "library declares minSdkVersion=" << minSdkB << "."
|
||
|
|
<< std::endl;
|
||
|
|
error = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
xml::Attribute* targetAttrA = nullptr;
|
||
|
|
xml::Attribute* targetAttrB = nullptr;
|
||
|
|
|
||
|
|
if (elA) {
|
||
|
|
targetAttrA = elA->findAttribute(kSchemaAndroid, u"targetSdkVersion");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (elB) {
|
||
|
|
targetAttrB = elB->findAttribute(kSchemaAndroid, u"targetSdkVersion");
|
||
|
|
}
|
||
|
|
|
||
|
|
int targetSdkA = findIntegerValue(targetAttrA, minSdkA);
|
||
|
|
int targetSdkB = findIntegerValue(targetAttrB, minSdkB);
|
||
|
|
|
||
|
|
if (targetSdkA < targetSdkB) {
|
||
|
|
std::ostream* out;
|
||
|
|
if (targetAttrA) {
|
||
|
|
out = &(mAppLogger.warn(elA->lineNumber) << "app declares ");
|
||
|
|
} else if (elA) {
|
||
|
|
out = &(mAppLogger.warn(elA->lineNumber) << "app has implied ");
|
||
|
|
} else {
|
||
|
|
out = &(mAppLogger.warn() << "app has implied ");
|
||
|
|
}
|
||
|
|
|
||
|
|
*out << "targetSdkVerion=" << targetSdkA << " but library expects target SDK "
|
||
|
|
<< targetSdkB << "." << std::endl;
|
||
|
|
|
||
|
|
mLogger.note(elB->lineNumber)
|
||
|
|
<< "library declares targetSdkVersion=" << targetSdkB << "."
|
||
|
|
<< std::endl;
|
||
|
|
error = true;
|
||
|
|
}
|
||
|
|
return !error;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::mergeApplication(xml::Element* applicationA, xml::Element* applicationB) {
|
||
|
|
if (!applicationA || !applicationB) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool error = false;
|
||
|
|
|
||
|
|
// First make sure that the names are identical.
|
||
|
|
xml::Attribute* nameA = applicationA->findAttribute(kSchemaAndroid, u"name");
|
||
|
|
xml::Attribute* nameB = applicationB->findAttribute(kSchemaAndroid, u"name");
|
||
|
|
if (nameB) {
|
||
|
|
if (!nameA) {
|
||
|
|
applicationA->attributes.push_back(*nameB);
|
||
|
|
} else if (nameA->value != nameB->value) {
|
||
|
|
mLogger.error(applicationB->lineNumber)
|
||
|
|
<< "conflicting application name '"
|
||
|
|
<< nameB->value
|
||
|
|
<< "'." << std::endl;
|
||
|
|
mAppLogger.note(applicationA->lineNumber)
|
||
|
|
<< "application defines application name '"
|
||
|
|
<< nameA->value
|
||
|
|
<< "'." << std::endl;
|
||
|
|
error = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now we descend into the activity/receiver/service/provider tags
|
||
|
|
for (xml::Element* elB : applicationB->getChildElements()) {
|
||
|
|
if (!elB->namespaceUri.empty()) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (elB->name == u"activity" || elB->name == u"activity-alias"
|
||
|
|
|| elB->name == u"service" || elB->name == u"receiver"
|
||
|
|
|| elB->name == u"provider" || elB->name == u"meta-data") {
|
||
|
|
xml::Element* elA = findChildWithSameName(applicationA, elB);
|
||
|
|
error |= !mergeNewOrEqual(applicationA, elA, elB);
|
||
|
|
} else if (elB->name == u"uses-library") {
|
||
|
|
xml::Element* elA = findChildWithSameName(applicationA, elB);
|
||
|
|
error |= !mergePreferRequired(applicationA, elA, elB);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return !error;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::mergeLibraryManifest(const Source& source, const std::u16string& package,
|
||
|
|
std::unique_ptr<xml::Node> libRoot) {
|
||
|
|
mLogger = SourceLogger{ source };
|
||
|
|
xml::Element* manifestA = findManifest(mRoot.get());
|
||
|
|
xml::Element* manifestB = findManifest(libRoot.get());
|
||
|
|
if (!manifestA) {
|
||
|
|
mAppLogger.error() << "missing manifest tag." << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!manifestB) {
|
||
|
|
mLogger.error() << "library missing manifest tag." << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool error = false;
|
||
|
|
|
||
|
|
// Do <application> first.
|
||
|
|
xml::Element* applicationA = manifestA->findChild({}, u"application");
|
||
|
|
xml::Element* applicationB = manifestB->findChild({}, u"application");
|
||
|
|
error |= !mergeApplication(applicationA, applicationB);
|
||
|
|
|
||
|
|
// Do <uses-sdk> next.
|
||
|
|
xml::Element* usesSdkA = manifestA->findChild({}, u"uses-sdk");
|
||
|
|
xml::Element* usesSdkB = manifestB->findChild({}, u"uses-sdk");
|
||
|
|
error |= !mergeUsesSdk(usesSdkA, usesSdkB);
|
||
|
|
|
||
|
|
for (xml::Element* elB : manifestB->getChildElements()) {
|
||
|
|
if (!elB->namespaceUri.empty()) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (elB->name == u"uses-permission" || elB->name == u"permission"
|
||
|
|
|| elB->name == u"permission-group" || elB->name == u"permission-tree") {
|
||
|
|
xml::Element* elA = findChildWithSameName(manifestA, elB);
|
||
|
|
error |= !mergeNewOrEqual(manifestA, elA, elB);
|
||
|
|
} else if (elB->name == u"uses-feature") {
|
||
|
|
xml::Element* elA = findChildWithSameName(manifestA, elB);
|
||
|
|
error |= !mergePreferRequired(manifestA, elA, elB);
|
||
|
|
} else if (elB->name == u"uses-configuration" || elB->name == u"supports-screen"
|
||
|
|
|| elB->name == u"compatible-screens" || elB->name == u"supports-gl-texture") {
|
||
|
|
xml::Element* elA = findChildWithSameName(manifestA, elB);
|
||
|
|
error |= !checkEqual(elA, elB);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return !error;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void printMerged(xml::Node* node, int depth) {
|
||
|
|
std::string indent;
|
||
|
|
for (int i = 0; i < depth; i++) {
|
||
|
|
indent += " ";
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (node->type) {
|
||
|
|
case xml::NodeType::kNamespace:
|
||
|
|
std::cerr << indent << "N: "
|
||
|
|
<< "xmlns:" << static_cast<xml::Namespace*>(node)->namespacePrefix
|
||
|
|
<< "=\"" << static_cast<xml::Namespace*>(node)->namespaceUri
|
||
|
|
<< "\"\n";
|
||
|
|
break;
|
||
|
|
|
||
|
|
case xml::NodeType::kElement:
|
||
|
|
std::cerr << indent << "E: "
|
||
|
|
<< static_cast<xml::Element*>(node)->namespaceUri
|
||
|
|
<< ":" << static_cast<xml::Element*>(node)->name
|
||
|
|
<< "\n";
|
||
|
|
for (const auto& attr : static_cast<xml::Element*>(node)->attributes) {
|
||
|
|
std::cerr << indent << " A: "
|
||
|
|
<< attr.namespaceUri
|
||
|
|
<< ":" << attr.name
|
||
|
|
<< "=\"" << attr.value << "\"\n";
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case xml::NodeType::kText:
|
||
|
|
std::cerr << indent << "T: \"" << static_cast<xml::Text*>(node)->text << "\"\n";
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (auto& child : node->children) {
|
||
|
|
printMerged(child.get(), depth + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
xml::Node* ManifestMerger::getMergedXml() {
|
||
|
|
return mRoot.get();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ManifestMerger::printMerged() {
|
||
|
|
if (!mRoot) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
::aapt::printMerged(mRoot.get(), 0);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace aapt
|