895e19edf0
Test: aapt2 dump packagename foo.apk bar.apk Bug: 113105112 Change-Id: Ibea429adc3a2a890be10548824583addc59ad42d Merged-In: Ibea429adc3a2a890be10548824583addc59ad42d
376 lines
11 KiB
C++
376 lines
11 KiB
C++
/*
|
|
* 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 <cinttypes>
|
|
#include <vector>
|
|
|
|
#include "android-base/stringprintf.h"
|
|
#include "androidfw/StringPiece.h"
|
|
|
|
#include "Debug.h"
|
|
#include "Diagnostics.h"
|
|
#include "Flags.h"
|
|
#include "LoadedApk.h"
|
|
#include "format/Container.h"
|
|
#include "format/binary/BinaryResourceParser.h"
|
|
#include "format/proto/ProtoDeserialize.h"
|
|
#include "io/FileStream.h"
|
|
#include "io/ZipArchive.h"
|
|
#include "process/IResourceTableConsumer.h"
|
|
#include "text/Printer.h"
|
|
#include "util/Files.h"
|
|
|
|
using ::aapt::text::Printer;
|
|
using ::android::StringPiece;
|
|
using ::android::base::StringPrintf;
|
|
|
|
namespace aapt {
|
|
|
|
struct DumpOptions {
|
|
DebugPrintTableOptions print_options;
|
|
|
|
// The path to a file within an APK to dump.
|
|
Maybe<std::string> file_to_dump_path;
|
|
};
|
|
|
|
static const char* ResourceFileTypeToString(const ResourceFile::Type& type) {
|
|
switch (type) {
|
|
case ResourceFile::Type::kPng:
|
|
return "PNG";
|
|
case ResourceFile::Type::kBinaryXml:
|
|
return "BINARY_XML";
|
|
case ResourceFile::Type::kProtoXml:
|
|
return "PROTO_XML";
|
|
default:
|
|
break;
|
|
}
|
|
return "UNKNOWN";
|
|
}
|
|
|
|
static void DumpCompiledFile(const ResourceFile& file, const Source& source, off64_t offset,
|
|
size_t len, Printer* printer) {
|
|
printer->Print("Resource: ");
|
|
printer->Println(file.name.to_string());
|
|
|
|
printer->Print("Config: ");
|
|
printer->Println(file.config.to_string());
|
|
|
|
printer->Print("Source: ");
|
|
printer->Println(file.source.to_string());
|
|
|
|
printer->Print("Type: ");
|
|
printer->Println(ResourceFileTypeToString(file.type));
|
|
|
|
printer->Println(StringPrintf("Data: offset=%" PRIi64 " length=%zd", offset, len));
|
|
}
|
|
|
|
static bool DumpXmlFile(IAaptContext* context, io::IFile* file, bool proto,
|
|
text::Printer* printer) {
|
|
std::unique_ptr<xml::XmlResource> doc;
|
|
if (proto) {
|
|
std::unique_ptr<io::InputStream> in = file->OpenInputStream();
|
|
if (in == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "failed to open file");
|
|
return false;
|
|
}
|
|
|
|
io::ZeroCopyInputAdaptor adaptor(in.get());
|
|
pb::XmlNode pb_node;
|
|
if (!pb_node.ParseFromZeroCopyStream(&adaptor)) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "failed to parse file as proto XML");
|
|
return false;
|
|
}
|
|
|
|
std::string err;
|
|
doc = DeserializeXmlResourceFromPb(pb_node, &err);
|
|
if (doc == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "failed to deserialize proto XML");
|
|
return false;
|
|
}
|
|
printer->Println("Proto XML");
|
|
} else {
|
|
std::unique_ptr<io::IData> data = file->OpenAsData();
|
|
if (data == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "failed to open file");
|
|
return false;
|
|
}
|
|
|
|
std::string err;
|
|
doc = xml::Inflate(data->data(), data->size(), &err);
|
|
if (doc == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "failed to parse file as binary XML");
|
|
return false;
|
|
}
|
|
printer->Println("Binary XML");
|
|
}
|
|
|
|
Debug::DumpXml(*doc, printer);
|
|
return true;
|
|
}
|
|
|
|
static bool TryDumpFile(IAaptContext* context, const std::string& file_path,
|
|
const DumpOptions& options) {
|
|
// Use a smaller buffer so that there is less latency for dumping to stdout.
|
|
constexpr size_t kStdOutBufferSize = 1024u;
|
|
io::FileOutputStream fout(STDOUT_FILENO, kStdOutBufferSize);
|
|
Printer printer(&fout);
|
|
|
|
std::string err;
|
|
std::unique_ptr<io::ZipFileCollection> zip = io::ZipFileCollection::Create(file_path, &err);
|
|
if (zip) {
|
|
ResourceTable table;
|
|
bool proto = false;
|
|
if (io::IFile* file = zip->FindFile("resources.pb")) {
|
|
proto = true;
|
|
|
|
std::unique_ptr<io::IData> data = file->OpenAsData();
|
|
if (data == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path) << "failed to open resources.pb");
|
|
return false;
|
|
}
|
|
|
|
pb::ResourceTable pb_table;
|
|
if (!pb_table.ParseFromArray(data->data(), data->size())) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path) << "invalid resources.pb");
|
|
return false;
|
|
}
|
|
|
|
if (!DeserializeTableFromPb(pb_table, zip.get(), &table, &err)) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "failed to parse table: " << err);
|
|
return false;
|
|
}
|
|
} else if (io::IFile* file = zip->FindFile("resources.arsc")) {
|
|
std::unique_ptr<io::IData> data = file->OpenAsData();
|
|
if (!data) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path) << "failed to open resources.arsc");
|
|
return false;
|
|
}
|
|
|
|
BinaryResourceParser parser(context->GetDiagnostics(), &table, Source(file_path),
|
|
data->data(), data->size());
|
|
if (!parser.Parse()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!options.file_to_dump_path) {
|
|
if (proto) {
|
|
printer.Println("Proto APK");
|
|
} else {
|
|
printer.Println("Binary APK");
|
|
}
|
|
Debug::PrintTable(table, options.print_options, &printer);
|
|
return true;
|
|
}
|
|
|
|
io::IFile* file = zip->FindFile(options.file_to_dump_path.value());
|
|
if (file == nullptr) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "file '" << options.file_to_dump_path.value()
|
|
<< "' not found in APK");
|
|
return false;
|
|
}
|
|
return DumpXmlFile(context, file, proto, &printer);
|
|
}
|
|
|
|
err.clear();
|
|
|
|
io::FileInputStream input(file_path);
|
|
if (input.HadError()) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "failed to open file: " << input.GetError());
|
|
return false;
|
|
}
|
|
|
|
// Try as a compiled file.
|
|
ContainerReader reader(&input);
|
|
if (reader.HadError()) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "failed to read container: " << reader.GetError());
|
|
return false;
|
|
}
|
|
|
|
printer.Println("AAPT2 Container (APC)");
|
|
ContainerReaderEntry* entry;
|
|
while ((entry = reader.Next()) != nullptr) {
|
|
if (entry->Type() == ContainerEntryType::kResTable) {
|
|
printer.Println("kResTable");
|
|
|
|
pb::ResourceTable pb_table;
|
|
if (!entry->GetResTable(&pb_table)) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "failed to parse proto table: " << entry->GetError());
|
|
continue;
|
|
}
|
|
|
|
ResourceTable table;
|
|
err.clear();
|
|
if (!DeserializeTableFromPb(pb_table, nullptr /*files*/, &table, &err)) {
|
|
context->GetDiagnostics()->Error(DiagMessage(file_path)
|
|
<< "failed to parse table: " << err);
|
|
continue;
|
|
}
|
|
|
|
printer.Indent();
|
|
Debug::PrintTable(table, options.print_options, &printer);
|
|
printer.Undent();
|
|
} else if (entry->Type() == ContainerEntryType::kResFile) {
|
|
printer.Println("kResFile");
|
|
pb::internal::CompiledFile pb_compiled_file;
|
|
off64_t offset;
|
|
size_t length;
|
|
if (!entry->GetResFileOffsets(&pb_compiled_file, &offset, &length)) {
|
|
context->GetDiagnostics()->Error(
|
|
DiagMessage(file_path) << "failed to parse compiled proto file: " << entry->GetError());
|
|
continue;
|
|
}
|
|
|
|
ResourceFile file;
|
|
std::string error;
|
|
if (!DeserializeCompiledFileFromPb(pb_compiled_file, &file, &error)) {
|
|
context->GetDiagnostics()->Warn(DiagMessage(file_path)
|
|
<< "failed to parse compiled file: " << error);
|
|
continue;
|
|
}
|
|
|
|
printer.Indent();
|
|
DumpCompiledFile(file, Source(file_path), offset, length, &printer);
|
|
printer.Undent();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool DumpPackageName(IAaptContext* context, const std::string& file_path) {
|
|
auto loaded_apk = LoadedApk::LoadApkFromPath(file_path, context->GetDiagnostics());
|
|
if (!loaded_apk) {
|
|
return false;
|
|
}
|
|
|
|
constexpr size_t kStdOutBufferSize = 1024u;
|
|
io::FileOutputStream fout(STDOUT_FILENO, kStdOutBufferSize);
|
|
Printer printer(&fout);
|
|
|
|
xml::Element* manifest_el = loaded_apk->GetManifest()->root.get();
|
|
if (!manifest_el) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "No AndroidManifest.");
|
|
return false;
|
|
}
|
|
|
|
xml::Attribute* attr = manifest_el->FindAttribute({}, "package");
|
|
if (!attr) {
|
|
context->GetDiagnostics()->Error(DiagMessage() << "No package name.");
|
|
return false;
|
|
}
|
|
printer.Println(StringPrintf("%s", attr->value.c_str()));
|
|
|
|
return true;
|
|
}
|
|
|
|
namespace {
|
|
|
|
class DumpContext : public IAaptContext {
|
|
public:
|
|
PackageType GetPackageType() override {
|
|
// Doesn't matter.
|
|
return PackageType::kApp;
|
|
}
|
|
|
|
IDiagnostics* GetDiagnostics() override {
|
|
return &diagnostics_;
|
|
}
|
|
|
|
NameMangler* GetNameMangler() override {
|
|
UNIMPLEMENTED(FATAL);
|
|
return nullptr;
|
|
}
|
|
|
|
const std::string& GetCompilationPackage() override {
|
|
static std::string empty;
|
|
return empty;
|
|
}
|
|
|
|
uint8_t GetPackageId() override {
|
|
return 0;
|
|
}
|
|
|
|
SymbolTable* GetExternalSymbols() override {
|
|
UNIMPLEMENTED(FATAL);
|
|
return nullptr;
|
|
}
|
|
|
|
bool IsVerbose() override {
|
|
return verbose_;
|
|
}
|
|
|
|
void SetVerbose(bool val) {
|
|
verbose_ = val;
|
|
}
|
|
|
|
int GetMinSdkVersion() override {
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
StdErrDiagnostics diagnostics_;
|
|
bool verbose_ = false;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Entry point for dump command.
|
|
int Dump(const std::vector<StringPiece>& args) {
|
|
bool verbose = false;
|
|
bool no_values = false;
|
|
DumpOptions options;
|
|
Flags flags = Flags()
|
|
.OptionalSwitch("--no-values",
|
|
"Suppresses output of values when displaying resource tables.",
|
|
&no_values)
|
|
.OptionalFlag("--file", "Dumps the specified file from the APK passed as arg.",
|
|
&options.file_to_dump_path)
|
|
.OptionalSwitch("-v", "increase verbosity of output", &verbose);
|
|
if (!flags.Parse("aapt2 dump", args, &std::cerr)) {
|
|
return 1;
|
|
}
|
|
|
|
DumpContext context;
|
|
context.SetVerbose(verbose);
|
|
|
|
auto parsedArgs = flags.GetArgs();
|
|
if (parsedArgs.size() > 1 && parsedArgs[0] == "packagename") {
|
|
parsedArgs.erase(parsedArgs.begin());
|
|
for (const std::string& arg : parsedArgs) {
|
|
if (!DumpPackageName(&context, arg)) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
options.print_options.show_sources = true;
|
|
options.print_options.show_values = !no_values;
|
|
for (const std::string& arg : parsedArgs) {
|
|
if (!TryDumpFile(&context, arg, options)) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
} // namespace aapt
|