blob: 0965910ca8539cbb809d09b4939954c99e7b5781 [file] [log] [blame]
/*
* 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 <vector>
#include "androidfw/StringPiece.h"
#include "Debug.h"
#include "Diagnostics.h"
#include "Flags.h"
#include "io/ZipArchive.h"
#include "process/IResourceTableConsumer.h"
#include "proto/ProtoSerialize.h"
#include "unflatten/BinaryResourceParser.h"
#include "util/Files.h"
using ::android::StringPiece;
namespace aapt {
bool DumpCompiledFile(const pb::internal::CompiledFile& pb_file, const void* data, size_t len,
const Source& source, IAaptContext* context) {
std::unique_ptr<ResourceFile> file =
DeserializeCompiledFileFromPb(pb_file, source, context->GetDiagnostics());
if (!file) {
context->GetDiagnostics()->Warn(DiagMessage() << "failed to read compiled file");
return false;
}
std::cout << "Resource: " << file->name << "\n"
<< "Config: " << file->config << "\n"
<< "Source: " << file->source << "\n";
return true;
}
bool TryDumpFile(IAaptContext* context, const std::string& file_path) {
std::unique_ptr<ResourceTable> table;
std::string err;
std::unique_ptr<io::ZipFileCollection> zip = io::ZipFileCollection::Create(file_path, &err);
if (zip) {
io::IFile* file = zip->FindFile("resources.arsc.flat");
if (file) {
std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
context->GetDiagnostics()->Error(DiagMessage(file_path)
<< "failed to open resources.arsc.flat");
return false;
}
pb::ResourceTable pb_table;
if (!pb_table.ParseFromArray(data->data(), data->size())) {
context->GetDiagnostics()->Error(DiagMessage(file_path) << "invalid resources.arsc.flat");
return false;
}
table = DeserializeTableFromPb(pb_table, Source(file_path), context->GetDiagnostics());
if (!table) {
return false;
}
}
if (!table) {
file = zip->FindFile("resources.arsc");
if (file) {
std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
context->GetDiagnostics()->Error(DiagMessage(file_path)
<< "failed to open resources.arsc");
return false;
}
table = util::make_unique<ResourceTable>();
BinaryResourceParser parser(context, table.get(), Source(file_path), data->data(),
data->size());
if (!parser.Parse()) {
return false;
}
}
}
}
if (!table) {
Maybe<android::FileMap> file = file::MmapPath(file_path, &err);
if (!file) {
context->GetDiagnostics()->Error(DiagMessage(file_path) << err);
return false;
}
android::FileMap* file_map = &file.value();
// Try as a compiled table.
pb::ResourceTable pb_table;
if (pb_table.ParseFromArray(file_map->getDataPtr(), file_map->getDataLength())) {
table = DeserializeTableFromPb(pb_table, Source(file_path), context->GetDiagnostics());
}
if (!table) {
// Try as a compiled file.
CompiledFileInputStream input(file_map->getDataPtr(), file_map->getDataLength());
uint32_t num_files = 0;
if (!input.ReadLittleEndian32(&num_files)) {
return false;
}
for (uint32_t i = 0; i < num_files; i++) {
pb::internal::CompiledFile compiled_file;
if (!input.ReadCompiledFile(&compiled_file)) {
context->GetDiagnostics()->Warn(DiagMessage() << "failed to read compiled file");
return false;
}
uint64_t offset, len;
if (!input.ReadDataMetaData(&offset, &len)) {
context->GetDiagnostics()->Warn(DiagMessage() << "failed to read meta data");
return false;
}
const void* data = static_cast<const uint8_t*>(file_map->getDataPtr()) + offset;
if (!DumpCompiledFile(compiled_file, data, len, Source(file_path), context)) {
return false;
}
}
}
}
if (table) {
DebugPrintTableOptions options;
options.show_sources = true;
Debug::PrintTable(table.get(), options);
}
return true;
}
class DumpContext : public IAaptContext {
public:
PackageType GetPackageType() override {
// Doesn't matter.
return PackageType::kApp;
}
IDiagnostics* GetDiagnostics() override {
return &diagnostics_;
}
NameMangler* GetNameMangler() override {
abort();
return nullptr;
}
const std::string& GetCompilationPackage() override {
static std::string empty;
return empty;
}
uint8_t GetPackageId() override {
return 0;
}
SymbolTable* GetExternalSymbols() override {
abort();
return nullptr;
}
bool IsVerbose() override {
return verbose_;
}
void SetVerbose(bool val) {
verbose_ = val;
}
int GetMinSdkVersion() override {
return 0;
}
private:
StdErrDiagnostics diagnostics_;
bool verbose_ = false;
};
/**
* Entry point for dump command.
*/
int Dump(const std::vector<StringPiece>& args) {
bool verbose = false;
Flags flags = Flags().OptionalSwitch("-v", "increase verbosity of output", &verbose);
if (!flags.Parse("aapt2 dump", args, &std::cerr)) {
return 1;
}
DumpContext context;
context.SetVerbose(verbose);
for (const std::string& arg : flags.GetArgs()) {
if (!TryDumpFile(&context, arg)) {
return 1;
}
}
return 0;
}
} // namespace aapt