tools/aapt2/diff/Diff.cpp

/*
 * 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