| /* |
| * 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 "Flags.h" |
| #include "ResourceTable.h" |
| #include "ValueVisitor.h" |
| #include "io/ZipArchive.h" |
| #include "process/IResourceTableConsumer.h" |
| #include "process/SymbolTable.h" |
| #include "unflatten/BinaryResourceParser.h" |
| |
| #include <android-base/macros.h> |
| |
| namespace aapt { |
| |
| class DiffContext : public IAaptContext { |
| public: |
| const std::string& getCompilationPackage() override { return mEmpty; } |
| |
| uint8_t getPackageId() override { return 0x0; } |
| |
| IDiagnostics* getDiagnostics() override { return &mDiagnostics; } |
| |
| NameMangler* getNameMangler() override { return &mNameMangler; } |
| |
| SymbolTable* getExternalSymbols() override { return &mSymbolTable; } |
| |
| bool verbose() override { return false; } |
| |
| int getMinSdkVersion() override { return 0; } |
| |
| private: |
| std::string mEmpty; |
| StdErrDiagnostics mDiagnostics; |
| NameMangler mNameMangler = NameMangler(NameManglerPolicy{}); |
| SymbolTable mSymbolTable; |
| }; |
| |
| class LoadedApk { |
| public: |
| LoadedApk(const Source& source, std::unique_ptr<io::IFileCollection> apk, |
| std::unique_ptr<ResourceTable> table) |
| : mSource(source), mApk(std::move(apk)), mTable(std::move(table)) {} |
| |
| io::IFileCollection* getFileCollection() { return mApk.get(); } |
| |
| ResourceTable* getResourceTable() { return mTable.get(); } |
| |
| const Source& getSource() { return mSource; } |
| |
| private: |
| Source mSource; |
| std::unique_ptr<io::IFileCollection> mApk; |
| std::unique_ptr<ResourceTable> mTable; |
| |
| DISALLOW_COPY_AND_ASSIGN(LoadedApk); |
| }; |
| |
| static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context, |
| const StringPiece& path) { |
| Source source(path); |
| std::string error; |
| std::unique_ptr<io::ZipFileCollection> apk = |
| io::ZipFileCollection::create(path, &error); |
| if (!apk) { |
| context->getDiagnostics()->error(DiagMessage(source) << error); |
| return {}; |
| } |
| |
| io::IFile* file = apk->findFile("resources.arsc"); |
| if (!file) { |
| context->getDiagnostics()->error(DiagMessage(source) |
| << "no resources.arsc found"); |
| return {}; |
| } |
| |
| std::unique_ptr<io::IData> data = file->openAsData(); |
| if (!data) { |
| context->getDiagnostics()->error(DiagMessage(source) |
| << "could not open resources.arsc"); |
| return {}; |
| } |
| |
| std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>(); |
| BinaryResourceParser parser(context, table.get(), source, data->data(), |
| data->size()); |
| if (!parser.parse()) { |
| return {}; |
| } |
| |
| return util::make_unique<LoadedApk>(source, std::move(apk), std::move(table)); |
| } |
| |
| static void emitDiffLine(const Source& source, const StringPiece& message) { |
| std::cerr << source << ": " << message << "\n"; |
| } |
| |
| static bool isSymbolVisibilityDifferent(const Symbol& symbolA, |
| const Symbol& symbolB) { |
| return symbolA.state != symbolB.state; |
| } |
| |
| template <typename Id> |
| static bool isIdDiff(const Symbol& symbolA, const Maybe<Id>& idA, |
| const Symbol& symbolB, const Maybe<Id>& idB) { |
| if (symbolA.state == SymbolState::kPublic || |
| symbolB.state == SymbolState::kPublic) { |
| return idA != idB; |
| } |
| return false; |
| } |
| |
| static bool emitResourceConfigValueDiff( |
| IAaptContext* context, LoadedApk* apkA, ResourceTablePackage* pkgA, |
| ResourceTableType* typeA, ResourceEntry* entryA, |
| ResourceConfigValue* configValueA, LoadedApk* apkB, |
| ResourceTablePackage* pkgB, ResourceTableType* typeB, ResourceEntry* entryB, |
| ResourceConfigValue* configValueB) { |
| Value* valueA = configValueA->value.get(); |
| Value* valueB = configValueB->value.get(); |
| if (!valueA->equals(valueB)) { |
| std::stringstream strStream; |
| strStream << "value " << pkgA->name << ":" << typeA->type << "/" |
| << entryA->name << " config=" << configValueA->config |
| << " does not match:\n"; |
| valueA->print(&strStream); |
| strStream << "\n vs \n"; |
| valueB->print(&strStream); |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| return true; |
| } |
| return false; |
| } |
| |
| static bool emitResourceEntryDiff(IAaptContext* context, LoadedApk* apkA, |
| ResourceTablePackage* pkgA, |
| ResourceTableType* typeA, |
| ResourceEntry* entryA, LoadedApk* apkB, |
| ResourceTablePackage* pkgB, |
| ResourceTableType* typeB, |
| ResourceEntry* entryB) { |
| bool diff = false; |
| for (std::unique_ptr<ResourceConfigValue>& configValueA : entryA->values) { |
| ResourceConfigValue* configValueB = entryB->findValue(configValueA->config); |
| if (!configValueB) { |
| std::stringstream strStream; |
| strStream << "missing " << pkgA->name << ":" << typeA->type << "/" |
| << entryA->name << " config=" << configValueA->config; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } else { |
| diff |= emitResourceConfigValueDiff(context, apkA, pkgA, typeA, entryA, |
| configValueA.get(), apkB, pkgB, typeB, |
| entryB, configValueB); |
| } |
| } |
| |
| // Check for any newly added config values. |
| for (std::unique_ptr<ResourceConfigValue>& configValueB : entryB->values) { |
| ResourceConfigValue* configValueA = entryA->findValue(configValueB->config); |
| if (!configValueA) { |
| std::stringstream strStream; |
| strStream << "new config " << pkgB->name << ":" << typeB->type << "/" |
| << entryB->name << " config=" << configValueB->config; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| } |
| return false; |
| } |
| |
| static bool emitResourceTypeDiff(IAaptContext* context, LoadedApk* apkA, |
| ResourceTablePackage* pkgA, |
| ResourceTableType* typeA, LoadedApk* apkB, |
| ResourceTablePackage* pkgB, |
| ResourceTableType* typeB) { |
| bool diff = false; |
| for (std::unique_ptr<ResourceEntry>& entryA : typeA->entries) { |
| ResourceEntry* entryB = typeB->findEntry(entryA->name); |
| if (!entryB) { |
| std::stringstream strStream; |
| strStream << "missing " << pkgA->name << ":" << typeA->type << "/" |
| << entryA->name; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } else { |
| if (isSymbolVisibilityDifferent(entryA->symbolStatus, |
| entryB->symbolStatus)) { |
| std::stringstream strStream; |
| strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name |
| << " has different visibility ("; |
| if (entryB->symbolStatus.state == SymbolState::kPublic) { |
| strStream << "PUBLIC"; |
| } else { |
| strStream << "PRIVATE"; |
| } |
| strStream << " vs "; |
| if (entryA->symbolStatus.state == SymbolState::kPublic) { |
| strStream << "PUBLIC"; |
| } else { |
| strStream << "PRIVATE"; |
| } |
| strStream << ")"; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } else if (isIdDiff(entryA->symbolStatus, entryA->id, |
| entryB->symbolStatus, entryB->id)) { |
| std::stringstream strStream; |
| strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name |
| << " has different public ID ("; |
| if (entryB->id) { |
| strStream << "0x" << std::hex << entryB->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << " vs "; |
| if (entryA->id) { |
| strStream << "0x " << std::hex << entryA->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << ")"; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| diff |= emitResourceEntryDiff(context, apkA, pkgA, typeA, entryA.get(), |
| apkB, pkgB, typeB, entryB); |
| } |
| } |
| |
| // Check for any newly added entries. |
| for (std::unique_ptr<ResourceEntry>& entryB : typeB->entries) { |
| ResourceEntry* entryA = typeA->findEntry(entryB->name); |
| if (!entryA) { |
| std::stringstream strStream; |
| strStream << "new entry " << pkgB->name << ":" << typeB->type << "/" |
| << entryB->name; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| } |
| return diff; |
| } |
| |
| static bool emitResourcePackageDiff(IAaptContext* context, LoadedApk* apkA, |
| ResourceTablePackage* pkgA, LoadedApk* apkB, |
| ResourceTablePackage* pkgB) { |
| bool diff = false; |
| for (std::unique_ptr<ResourceTableType>& typeA : pkgA->types) { |
| ResourceTableType* typeB = pkgB->findType(typeA->type); |
| if (!typeB) { |
| std::stringstream strStream; |
| strStream << "missing " << pkgA->name << ":" << typeA->type; |
| emitDiffLine(apkA->getSource(), strStream.str()); |
| diff = true; |
| } else { |
| if (isSymbolVisibilityDifferent(typeA->symbolStatus, |
| typeB->symbolStatus)) { |
| std::stringstream strStream; |
| strStream << pkgA->name << ":" << typeA->type |
| << " has different visibility ("; |
| if (typeB->symbolStatus.state == SymbolState::kPublic) { |
| strStream << "PUBLIC"; |
| } else { |
| strStream << "PRIVATE"; |
| } |
| strStream << " vs "; |
| if (typeA->symbolStatus.state == SymbolState::kPublic) { |
| strStream << "PUBLIC"; |
| } else { |
| strStream << "PRIVATE"; |
| } |
| strStream << ")"; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } else if (isIdDiff(typeA->symbolStatus, typeA->id, typeB->symbolStatus, |
| typeB->id)) { |
| std::stringstream strStream; |
| strStream << pkgA->name << ":" << typeA->type |
| << " has different public ID ("; |
| if (typeB->id) { |
| strStream << "0x" << std::hex << typeB->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << " vs "; |
| if (typeA->id) { |
| strStream << "0x " << std::hex << typeA->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << ")"; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| diff |= emitResourceTypeDiff(context, apkA, pkgA, typeA.get(), apkB, pkgB, |
| typeB); |
| } |
| } |
| |
| // Check for any newly added types. |
| for (std::unique_ptr<ResourceTableType>& typeB : pkgB->types) { |
| ResourceTableType* typeA = pkgA->findType(typeB->type); |
| if (!typeA) { |
| std::stringstream strStream; |
| strStream << "new type " << pkgB->name << ":" << typeB->type; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| } |
| return diff; |
| } |
| |
| static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA, |
| LoadedApk* apkB) { |
| ResourceTable* tableA = apkA->getResourceTable(); |
| ResourceTable* tableB = apkB->getResourceTable(); |
| |
| bool diff = false; |
| for (std::unique_ptr<ResourceTablePackage>& pkgA : tableA->packages) { |
| ResourceTablePackage* pkgB = tableB->findPackage(pkgA->name); |
| if (!pkgB) { |
| std::stringstream strStream; |
| strStream << "missing package " << pkgA->name; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } else { |
| if (pkgA->id != pkgB->id) { |
| std::stringstream strStream; |
| strStream << "package '" << pkgA->name << "' has different id ("; |
| if (pkgB->id) { |
| strStream << "0x" << std::hex << pkgB->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << " vs "; |
| if (pkgA->id) { |
| strStream << "0x" << std::hex << pkgA->id.value(); |
| } else { |
| strStream << "none"; |
| } |
| strStream << ")"; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| diff |= emitResourcePackageDiff(context, apkA, pkgA.get(), apkB, pkgB); |
| } |
| } |
| |
| // Check for any newly added packages. |
| for (std::unique_ptr<ResourceTablePackage>& pkgB : tableB->packages) { |
| ResourceTablePackage* pkgA = tableA->findPackage(pkgB->name); |
| if (!pkgA) { |
| std::stringstream strStream; |
| strStream << "new package " << pkgB->name; |
| emitDiffLine(apkB->getSource(), strStream.str()); |
| diff = true; |
| } |
| } |
| return diff; |
| } |
| |
| class ZeroingReferenceVisitor : public ValueVisitor { |
| public: |
| using ValueVisitor::visit; |
| |
| void visit(Reference* ref) override { |
| if (ref->name && ref->id) { |
| if (ref->id.value().packageId() == 0x7f) { |
| ref->id = {}; |
| } |
| } |
| } |
| }; |
| |
| static void zeroOutAppReferences(ResourceTable* table) { |
| ZeroingReferenceVisitor visitor; |
| visitAllValuesInTable(table, &visitor); |
| } |
| |
| int diff(const std::vector<StringPiece>& args) { |
| DiffContext context; |
| |
| Flags flags; |
| if (!flags.parse("aapt2 diff", args, &std::cerr)) { |
| return 1; |
| } |
| |
| if (flags.getArgs().size() != 2u) { |
| std::cerr << "must have two apks as arguments.\n\n"; |
| flags.usage("aapt2 diff", &std::cerr); |
| return 1; |
| } |
| |
| std::unique_ptr<LoadedApk> apkA = |
| loadApkFromPath(&context, flags.getArgs()[0]); |
| std::unique_ptr<LoadedApk> apkB = |
| loadApkFromPath(&context, flags.getArgs()[1]); |
| if (!apkA || !apkB) { |
| return 1; |
| } |
| |
| // Zero out Application IDs in references. |
| zeroOutAppReferences(apkA->getResourceTable()); |
| zeroOutAppReferences(apkB->getResourceTable()); |
| |
| if (emitResourceTableDiff(&context, apkA.get(), apkB.get())) { |
| // We emitted a diff, so return 1 (failure). |
| return 1; |
| } |
| return 0; |
| } |
| |
| } // namespace aapt |