drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/cmds/idmap/inspect.cpp
Adam Lesinski f90f2f8dc3 Support multiple resource tables with same package 
In order to support APK split features, the resource
table needs to support loading multiple resource
tables with the same package but potentially new set
of type IDs.

This adds some complexity as the type ID space changes
from dense and ordered to potentially sparse.

A ByteBucketArray is used to store the type IDs in
a memory efficient way that allows for fast retrieval.

In addition, the IDMAP format has changed. We no longer
need random access to the type data, since we store the
types differently. However, random access to entries of
a given type is still required.

Change-Id: If6f5be680b405b368941d9c1f2b5d2ddca964160
2014-06-18 19:20:08 +00:00

311 lines
9.6 KiB
C++
Raw Blame History

#include "idmap.h"
#include <androidfw/AssetManager.h>
#include <androidfw/ResourceTypes.h>
#include <utils/String8.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
using namespace android;
namespace {
static const uint32_t IDMAP_MAGIC = 0x504D4449;
static const size_t PATH_LENGTH = 256;
void printe(const char *fmt, ...);
class IdmapBuffer {
private:
const char* buf_;
size_t len_;
size_t pos_;
public:
IdmapBuffer() : buf_((const char *)MAP_FAILED), len_(0), pos_(0) {}
~IdmapBuffer() {
if (buf_ != MAP_FAILED) {
munmap(const_cast<char*>(buf_), len_);
}
}
status_t init(const char *idmap_path) {
struct stat st;
int fd;
if (stat(idmap_path, &st) < 0) {
printe("failed to stat idmap '%s': %s\n", idmap_path, strerror(errno));
return UNKNOWN_ERROR;
}
len_ = st.st_size;
if ((fd = TEMP_FAILURE_RETRY(open(idmap_path, O_RDONLY))) < 0) {
printe("failed to open idmap '%s': %s\n", idmap_path, strerror(errno));
return UNKNOWN_ERROR;
}
if ((buf_ = (const char*)mmap(NULL, len_, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) {
close(fd);
printe("failed to mmap idmap: %s\n", strerror(errno));
return UNKNOWN_ERROR;
}
close(fd);
return NO_ERROR;
}
status_t nextUint32(uint32_t* i) {
if (!buf_) {
printe("failed to read next uint32_t: buffer not initialized\n");
return UNKNOWN_ERROR;
}
if (pos_ + sizeof(uint32_t) > len_) {
printe("failed to read next uint32_t: end of buffer reached at pos=0x%08x\n",
pos_);
return UNKNOWN_ERROR;
}
if ((reinterpret_cast<uintptr_t>(buf_ + pos_) & 0x3) != 0) {
printe("failed to read next uint32_t: not aligned on 4-byte boundary\n");
return UNKNOWN_ERROR;
}
*i = dtohl(*reinterpret_cast<const uint32_t*>(buf_ + pos_));
pos_ += sizeof(uint32_t);
return NO_ERROR;
}
status_t nextUint16(uint16_t* i) {
if (!buf_) {
printe("failed to read next uint16_t: buffer not initialized\n");
return UNKNOWN_ERROR;
}
if (pos_ + sizeof(uint16_t) > len_) {
printe("failed to read next uint16_t: end of buffer reached at pos=0x%08x\n",
pos_);
return UNKNOWN_ERROR;
}
if ((reinterpret_cast<uintptr_t>(buf_ + pos_) & 0x1) != 0) {
printe("failed to read next uint32_t: not aligned on 2-byte boundary\n");
return UNKNOWN_ERROR;
}
*i = dtohs(*reinterpret_cast<const uint16_t*>(buf_ + pos_));
pos_ += sizeof(uint16_t);
return NO_ERROR;
}
status_t nextPath(char *b) {
if (!buf_) {
printe("failed to read next path: buffer not initialized\n");
return UNKNOWN_ERROR;
}
if (pos_ + PATH_LENGTH > len_) {
printe("failed to read next path: end of buffer reached at pos=0x%08x\n", pos_);
return UNKNOWN_ERROR;
}
memcpy(b, buf_ + pos_, PATH_LENGTH);
pos_ += PATH_LENGTH;
return NO_ERROR;
}
};
void printe(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "error: ");
vfprintf(stderr, fmt, ap);
va_end(ap);
}
void print_header() {
printf("SECTION ENTRY VALUE COMMENT\n");
}
void print(const char *section, const char *subsection, uint32_t value, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
printf("%-12s %-12s 0x%08x ", section, subsection, value);
vprintf(fmt, ap);
printf("\n");
va_end(ap);
}
void print_path(const char *section, const char *subsection, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
printf("%-12s %-12s .......... ", section, subsection);
vprintf(fmt, ap);
printf("\n");
va_end(ap);
}
status_t resource_metadata(const AssetManager& am, uint32_t res_id,
String8 *package, String8 *type, String8 *name) {
const ResTable& rt = am.getResources();
struct ResTable::resource_name data;
if (!rt.getResourceName(res_id, false, &data)) {
printe("failed to get resource name id=0x%08x\n", res_id);
return UNKNOWN_ERROR;
}
if (package) {
*package = String8(String16(data.package, data.packageLen));
}
if (type) {
*type = String8(String16(data.type, data.typeLen));
}
if (name) {
*name = String8(String16(data.name, data.nameLen));
}
return NO_ERROR;
}
status_t parse_idmap_header(IdmapBuffer& buf, AssetManager& am) {
uint32_t i;
char path[PATH_LENGTH];
status_t err = buf.nextUint32(&i);
if (err != NO_ERROR) {
return err;
}
if (i != IDMAP_MAGIC) {
printe("not an idmap file: actual magic constant 0x%08x does not match expected magic "
"constant 0x%08x\n", i, IDMAP_MAGIC);
return UNKNOWN_ERROR;
}
print_header();
print("IDMAP HEADER", "magic", i, "");
err = buf.nextUint32(&i);
if (err != NO_ERROR) {
return err;
}
print("", "version", i, "");
err = buf.nextUint32(&i);
if (err != NO_ERROR) {
return err;
}
print("", "base crc", i, "");
err = buf.nextUint32(&i);
if (err != NO_ERROR) {
return err;
}
print("", "overlay crc", i, "");
err = buf.nextPath(path);
if (err != NO_ERROR) {
// printe done from IdmapBuffer::nextPath
return err;
}
print_path("", "base path", "%s", path);
if (!am.addAssetPath(String8(path), NULL)) {
printe("failed to add '%s' as asset path\n", path);
return UNKNOWN_ERROR;
}
err = buf.nextPath(path);
if (err != NO_ERROR) {
// printe done from IdmapBuffer::nextPath
return err;
}
print_path("", "overlay path", "%s", path);
return NO_ERROR;
}
status_t parse_data(IdmapBuffer& buf, const AssetManager& am) {
const uint32_t packageId = am.getResources().getBasePackageId(0);
uint16_t data16;
status_t err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
print("DATA HEADER", "target pkg", static_cast<uint32_t>(data16), "");
err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
print("", "types count", static_cast<uint32_t>(data16), "");
uint32_t typeCount = static_cast<uint32_t>(data16);
while (typeCount > 0) {
typeCount--;
err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
const uint32_t targetTypeId = static_cast<uint32_t>(data16);
print("DATA BLOCK", "target type", targetTypeId, "");
err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
print("", "overlay type", static_cast<uint32_t>(data16), "");
err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
const uint32_t entryCount = static_cast<uint32_t>(data16);
print("", "entry count", entryCount, "");
err = buf.nextUint16(&data16);
if (err != NO_ERROR) {
return err;
}
const uint32_t entryOffset = static_cast<uint32_t>(data16);
print("", "entry offset", entryOffset, "");
for (uint32_t i = 0; i < entryCount; i++) {
uint32_t data32;
err = buf.nextUint32(&data32);
if (err != NO_ERROR) {
return err;
}
uint32_t resID = (packageId << 24) | (targetTypeId << 16) | (entryOffset + i);
String8 type;
String8 name;
err = resource_metadata(am, resID, NULL, &type, &name);
if (err != NO_ERROR) {
return err;
}
print("", "entry", data32, "%s/%s", type.string(), name.string());
}
}
return NO_ERROR;
}
}
int idmap_inspect(const char *idmap_path) {
IdmapBuffer buf;
if (buf.init(idmap_path) < 0) {
// printe done from IdmapBuffer::init
return EXIT_FAILURE;
}
AssetManager am;
if (parse_idmap_header(buf, am) != NO_ERROR) {
// printe done from parse_idmap_header
return EXIT_FAILURE;
}
if (parse_data(buf, am) != NO_ERROR) {
// printe done from parse_data_header
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink