ssize_t fs_config_generate(char *buffer, size_t length, const struct fs_path_config *pc)
{
struct fs_path_config_from_file *p = (struct fs_path_config_from_file *)buffer;
size_t len = ALIGN(sizeof(*p) + strlen(pc->prefix) + 1, sizeof(uint64_t));
if ((length < len) || (len > UINT16_MAX)) {
return -ENOSPC;
}
memset(p, 0, len);
uint16_t host_len = len;
p->len = get2LE((const uint8_t *)&host_len);
p->mode = get2LE((const uint8_t *)&(pc->mode));
p->uid = get2LE((const uint8_t *)&(pc->uid));
p->gid = get2LE((const uint8_t *)&(pc->gid));
p->capabilities = get8LE((const uint8_t *)&(pc->capabilities));
strcpy(p->prefix, pc->prefix);
return len;
}
/*
* Dump a bytecode disassembly.
*/
void dumpBytecodes(DexFile* pDexFile, const DexMethod* pDexMethod)
{
const DexCode* pCode = dexGetCode(pDexFile, pDexMethod);
const u2* insns;
int insnIdx;
FieldMethodInfo methInfo;
int startAddr;
char* className = NULL;
assert(pCode->insnsSize > 0);
insns = pCode->insns;
getMethodInfo(pDexFile, pDexMethod->methodIdx, &methInfo);
startAddr = ((u1*)pCode - pDexFile->baseAddr);
className = descriptorToDot(methInfo.classDescriptor);
printf("%06x: |[%06x] %s.%s:%s\n",
startAddr, startAddr,
className, methInfo.name, methInfo.signature);
insnIdx = 0;
while (insnIdx < (int) pCode->insnsSize) {
int insnWidth;
OpCode opCode;
DecodedInstruction decInsn;
u2 instr;
instr = get2LE((const u1*)insns);
if (instr == kPackedSwitchSignature) {
insnWidth = 4 + get2LE((const u1*)(insns+1)) * 2;
} else if (instr == kSparseSwitchSignature) {
insnWidth = 2 + get2LE((const u1*)(insns+1)) * 4;
} else if (instr == kArrayDataSignature) {
int width = get2LE((const u1*)(insns+1));
int size = get2LE((const u1*)(insns+2)) |
(get2LE((const u1*)(insns+3))<<16);
// The plus 1 is to round up for odd size and width
insnWidth = 4 + ((size * width) + 1) / 2;
} else {
opCode = instr & 0xff;
insnWidth = dexGetInstrWidthAbs(gInstrWidth, opCode);
if (insnWidth == 0) {
fprintf(stderr,
"GLITCH: zero-width instruction at idx=0x%04x\n", insnIdx);
break;
}
}
dexDecodeInstruction(gInstrFormat, insns, &decInsn);
dumpInstruction(pDexFile, pCode, insnIdx, insnWidth, &decInsn);
insns += insnWidth;
insnIdx += insnWidth;
}
free(className);
}
void fs_config(const char *path, int dir, const char *target_out_path,
unsigned *uid, unsigned *gid, unsigned *mode, uint64_t *capabilities)
{
const struct fs_path_config *pc;
int fd, plen;
if (path[0] == '/') {
path++;
}
plen = strlen(path);
fd = fs_config_open(dir, target_out_path);
if (fd >= 0) {
struct fs_path_config_from_file header;
while (TEMP_FAILURE_RETRY(read(fd, &header, sizeof(header))) == sizeof(header)) {
char *prefix;
uint16_t host_len = get2LE((const uint8_t *)&header.len);
ssize_t len, remainder = host_len - sizeof(header);
if (remainder <= 0) {
ALOGE("%s len is corrupted", dir ? conf_dir : conf_file);
break;
}
prefix = calloc(1, remainder);
if (!prefix) {
ALOGE("%s out of memory", dir ? conf_dir : conf_file);
break;
}
if (TEMP_FAILURE_RETRY(read(fd, prefix, remainder)) != remainder) {
free(prefix);
ALOGE("%s prefix is truncated", dir ? conf_dir : conf_file);
break;
}
len = strnlen(prefix, remainder);
if (len >= remainder) { /* missing a terminating null */
free(prefix);
ALOGE("%s is corrupted", dir ? conf_dir : conf_file);
break;
}
if (fs_config_cmp(dir, prefix, len, path, plen)) {
free(prefix);
close(fd);
*uid = get2LE((const uint8_t *)&(header.uid));
*gid = get2LE((const uint8_t *)&(header.gid));
*mode = (*mode & (~07777)) | get2LE((const uint8_t *)&(header.mode));
*capabilities = get8LE((const uint8_t *)&(header.capabilities));
return;
}
free(prefix);
}
close(fd);
}
pc = dir ? android_dirs : android_files;
for(; pc->prefix; pc++) {
if (fs_config_cmp(dir, pc->prefix, strlen(pc->prefix), path, plen)) {
break;
}
}
*uid = pc->uid;
*gid = pc->gid;
*mode = (*mode & (~07777)) | pc->mode;
*capabilities = pc->capabilities;
}
/*
* Get the useful fields from the zip entry.
*
* Returns non-zero if the contents of the fields (particularly the data
* offset) appear to be bogus.
*/
int dexZipGetEntryInfo(const ZipArchive* pArchive, ZipEntry entry,
int* pMethod, size_t* pUncompLen, size_t* pCompLen, off_t* pOffset,
long* pModWhen, long* pCrc32)
{
int ent = entryToIndex(pArchive, entry);
if (ent < 0)
return -1;
/*
* Recover the start of the central directory entry from the filename
* pointer. The filename is the first entry past the fixed-size data,
* so we can just subtract back from that.
*/
const unsigned char* basePtr = (const unsigned char*)
pArchive->mDirectoryMap.addr;
const unsigned char* ptr = (const unsigned char*)
pArchive->mHashTable[ent].name;
off_t cdOffset = pArchive->mDirectoryOffset;
ptr -= kCDELen;
int method = get2LE(ptr + kCDEMethod);
if (pMethod != NULL)
*pMethod = method;
if (pModWhen != NULL)
*pModWhen = get4LE(ptr + kCDEModWhen);
if (pCrc32 != NULL)
*pCrc32 = get4LE(ptr + kCDECRC);
size_t compLen = get4LE(ptr + kCDECompLen);
if (pCompLen != NULL)
*pCompLen = compLen;
size_t uncompLen = get4LE(ptr + kCDEUncompLen);
if (pUncompLen != NULL)
*pUncompLen = uncompLen;
/*
* If requested, determine the offset of the start of the data. All we
* have is the offset to the Local File Header, which is variable size,
* so we have to read the contents of the struct to figure out where
* the actual data starts.
*
* We also need to make sure that the lengths are not so large that
* somebody trying to map the compressed or uncompressed data runs
* off the end of the mapped region.
*
* Note we don't verify compLen/uncompLen if they don't request the
* dataOffset, because dataOffset is expensive to determine. However,
* if they don't have the file offset, they're not likely to be doing
* anything with the contents.
*/
if (pOffset != NULL) {
long localHdrOffset = (long) get4LE(ptr + kCDELocalOffset);
if (localHdrOffset + kLFHLen >= cdOffset) {
LOGW("Zip: bad local hdr offset in zip\n");
return -1;
}
u1 lfhBuf[kLFHLen];
if (lseek(pArchive->mFd, localHdrOffset, SEEK_SET) != localHdrOffset) {
LOGW("Zip: failed seeking to lfh at offset %ld\n", localHdrOffset);
return -1;
}
ssize_t actual =
TEMP_FAILURE_RETRY(read(pArchive->mFd, lfhBuf, sizeof(lfhBuf)));
if (actual != sizeof(lfhBuf)) {
LOGW("Zip: failed reading lfh from offset %ld\n", localHdrOffset);
return -1;
}
if (get4LE(lfhBuf) != kLFHSignature) {
LOGW("Zip: didn't find signature at start of lfh, offset=%ld\n",
localHdrOffset);
return -1;
}
off_t dataOffset = localHdrOffset + kLFHLen
+ get2LE(lfhBuf + kLFHNameLen) + get2LE(lfhBuf + kLFHExtraLen);
if (dataOffset >= cdOffset) {
LOGW("Zip: bad data offset %ld in zip\n", (long) dataOffset);
return -1;
}
/* check lengths */
if ((off_t)(dataOffset + compLen) > cdOffset) {
LOGW("Zip: bad compressed length in zip (%ld + %zd > %ld)\n",
(long) dataOffset, compLen, (long) cdOffset);
return -1;
}
if (method == kCompressStored &&
(off_t)(dataOffset + uncompLen) > cdOffset)
{
LOGW("Zip: bad uncompressed length in zip (%ld + %zd > %ld)\n",
(long) dataOffset, uncompLen, (long) cdOffset);
return -1;
}
*pOffset = dataOffset;
}
return 0;
}
/*
* Parses the Zip archive's Central Directory. Allocates and populates the
* hash table.
*
* Returns 0 on success.
*/
static int parseZipArchive(ZipArchive* pArchive)
{
int result = -1;
const u1* cdPtr = (const u1*)pArchive->mDirectoryMap.addr;
size_t cdLength = pArchive->mDirectoryMap.length;
int numEntries = pArchive->mNumEntries;
/*
* Create hash table. We have a minimum 75% load factor, possibly as
* low as 50% after we round off to a power of 2. There must be at
* least one unused entry to avoid an infinite loop during creation.
*/
pArchive->mHashTableSize = dexRoundUpPower2(1 + (numEntries * 4) / 3);
pArchive->mHashTable = (ZipHashEntry*)
calloc(pArchive->mHashTableSize, sizeof(ZipHashEntry));
/*
* Walk through the central directory, adding entries to the hash
* table and verifying values.
*/
const u1* ptr = cdPtr;
int i;
for (i = 0; i < numEntries; i++) {
if (get4LE(ptr) != kCDESignature) {
LOGW("Zip: missed a central dir sig (at %d)\n", i);
goto bail;
}
if (ptr + kCDELen > cdPtr + cdLength) {
LOGW("Zip: ran off the end (at %d)\n", i);
goto bail;
}
long localHdrOffset = (long) get4LE(ptr + kCDELocalOffset);
if (localHdrOffset >= pArchive->mDirectoryOffset) {
LOGW("Zip: bad LFH offset %ld at entry %d\n", localHdrOffset, i);
goto bail;
}
unsigned int fileNameLen, extraLen, commentLen, hash;
fileNameLen = get2LE(ptr + kCDENameLen);
extraLen = get2LE(ptr + kCDEExtraLen);
commentLen = get2LE(ptr + kCDECommentLen);
/* add the CDE filename to the hash table */
hash = computeHash((const char*)ptr + kCDELen, fileNameLen);
addToHash(pArchive, (const char*)ptr + kCDELen, fileNameLen, hash);
ptr += kCDELen + fileNameLen + extraLen + commentLen;
if ((size_t)(ptr - cdPtr) > cdLength) {
LOGW("Zip: bad CD advance (%d vs %zd) at entry %d\n",
(int) (ptr - cdPtr), cdLength, i);
goto bail;
}
}
LOGV("+++ zip good scan %d entries\n", numEntries);
result = 0;
bail:
return result;
}
/*
* Find the zip Central Directory and memory-map it.
*
* On success, returns 0 after populating fields from the EOCD area:
* mDirectoryOffset
* mDirectoryMap
* mNumEntries
*/
static int mapCentralDirectory(int fd, const char* debugFileName,
ZipArchive* pArchive)
{
u1* scanBuf = NULL;
int result = -1;
/*
* Get and test file length.
*/
off_t fileLength = lseek(fd, 0, SEEK_END);
if (fileLength < kEOCDLen) {
LOGV("Zip: length %ld is too small to be zip\n", (long) fileLength);
goto bail;
}
/*
* Perform the traditional EOCD snipe hunt.
*
* We're searching for the End of Central Directory magic number,
* which appears at the start of the EOCD block. It's followed by
* 18 bytes of EOCD stuff and up to 64KB of archive comment. We
* need to read the last part of the file into a buffer, dig through
* it to find the magic number, parse some values out, and use those
* to determine the extent of the CD.
*
* We start by pulling in the last part of the file.
*/
size_t readAmount = kMaxEOCDSearch;
if (readAmount > (size_t) fileLength)
readAmount = fileLength;
off_t searchStart = fileLength - readAmount;
scanBuf = (u1*) malloc(readAmount);
if (lseek(fd, searchStart, SEEK_SET) != searchStart) {
LOGW("Zip: seek %ld failed: %s\n", (long) searchStart, strerror(errno));
goto bail;
}
ssize_t actual = TEMP_FAILURE_RETRY(read(fd, scanBuf, readAmount));
if (actual != (ssize_t) readAmount) {
LOGW("Zip: read %zd failed: %s\n", readAmount, strerror(errno));
goto bail;
}
/*
* Scan backward for the EOCD magic. In an archive without a trailing
* comment, we'll find it on the first try. (We may want to consider
* doing an initial minimal read; if we don't find it, retry with a
* second read as above.)
*/
int i;
for (i = readAmount - kEOCDLen; i >= 0; i--) {
if (scanBuf[i] == 0x50 && get4LE(&scanBuf[i]) == kEOCDSignature) {
LOGV("+++ Found EOCD at buf+%d\n", i);
break;
}
}
if (i < 0) {
LOGD("Zip: EOCD not found, %s is not zip\n", debugFileName);
goto bail;
}
off_t eocdOffset = searchStart + i;
const u1* eocdPtr = scanBuf + i;
assert(eocdOffset < fileLength);
/*
* Grab the CD offset and size, and the number of entries in the
* archive. Verify that they look reasonable.
*/
u4 numEntries = get2LE(eocdPtr + kEOCDNumEntries);
u4 dirSize = get4LE(eocdPtr + kEOCDSize);
u4 dirOffset = get4LE(eocdPtr + kEOCDFileOffset);
if ((long long) dirOffset + (long long) dirSize > (long long) eocdOffset) {
LOGW("Zip: bad offsets (dir %ld, size %u, eocd %ld)\n",
(long) dirOffset, dirSize, (long) eocdOffset);
goto bail;
}
if (numEntries == 0) {
LOGW("Zip: empty archive?\n");
goto bail;
}
LOGV("+++ numEntries=%d dirSize=%d dirOffset=%d\n",
numEntries, dirSize, dirOffset);
/*
* It all looks good. Create a mapping for the CD, and set the fields
* in pArchive.
*/
if (sysMapFileSegmentInShmem(fd, dirOffset, dirSize,
&pArchive->mDirectoryMap) != 0)
{
LOGW("Zip: cd map failed\n");
goto bail;
}
pArchive->mNumEntries = numEntries;
pArchive->mDirectoryOffset = dirOffset;
result = 0;
bail:
free(scanBuf);
return result;
}
/*
* Get the useful fields from the zip entry.
*
* Returns "false" if the offsets to the fields or the contents of the fields
* appear to be bogus.
*/
bool dexZipGetEntryInfo(const ZipArchive* pArchive, ZipEntry entry,
int* pMethod, long* pUncompLen, long* pCompLen, off_t* pOffset,
long* pModWhen, long* pCrc32)
{
int ent = entryToIndex(pArchive, entry);
if (ent < 0)
return false;
/*
* Recover the start of the central directory entry from the filename
* pointer.
*/
const unsigned char* basePtr = (const unsigned char*)
pArchive->mMap.addr;
const unsigned char* ptr = (const unsigned char*)
pArchive->mHashTable[ent].name;
size_t zipLength =
pArchive->mMap.length;
ptr -= kCDELen;
int method = get2LE(ptr + kCDEMethod);
if (pMethod != NULL)
*pMethod = method;
if (pModWhen != NULL)
*pModWhen = get4LE(ptr + kCDEModWhen);
if (pCrc32 != NULL)
*pCrc32 = get4LE(ptr + kCDECRC);
/*
* We need to make sure that the lengths are not so large that somebody
* trying to map the compressed or uncompressed data runs off the end
* of the mapped region.
*/
unsigned long localHdrOffset = get4LE(ptr + kCDELocalOffset);
if (localHdrOffset + kLFHLen >= zipLength) {
LOGE("ERROR: bad local hdr offset in zip\n");
return false;
}
const unsigned char* localHdr = basePtr + localHdrOffset;
off_t dataOffset = localHdrOffset + kLFHLen
+ get2LE(localHdr + kLFHNameLen) + get2LE(localHdr + kLFHExtraLen);
if ((unsigned long) dataOffset >= zipLength) {
LOGE("ERROR: bad data offset in zip\n");
return false;
}
if (pCompLen != NULL) {
*pCompLen = get4LE(ptr + kCDECompLen);
if (*pCompLen < 0 || (size_t)(dataOffset + *pCompLen) >= zipLength) {
LOGE("ERROR: bad compressed length in zip\n");
return false;
}
}
if (pUncompLen != NULL) {
*pUncompLen = get4LE(ptr + kCDEUncompLen);
if (*pUncompLen < 0) {
LOGE("ERROR: negative uncompressed length in zip\n");
return false;
}
if (method == kCompressStored &&
(size_t)(dataOffset + *pUncompLen) >= zipLength)
{
LOGE("ERROR: bad uncompressed length in zip\n");
return false;
}
}
if (pOffset != NULL) {
*pOffset = dataOffset;
}
return true;
}
/*
* Parse the Zip archive, verifying its contents and initializing internal
* data structures.
*/
static bool parseZipArchive(ZipArchive* pArchive, const MemMapping* pMap)
{
#define CHECK_OFFSET(_off) { \
if ((unsigned int) (_off) >= maxOffset) { \
LOGE("ERROR: bad offset %u (max %d): %s\n", \
(unsigned int) (_off), maxOffset, #_off); \
goto bail; \
} \
}
bool result = false;
const unsigned char* basePtr = (const unsigned char*)pMap->addr;
const unsigned char* ptr;
size_t length = pMap->length;
unsigned int i, numEntries, cdOffset;
unsigned int val;
/*
* The first 4 bytes of the file will either be the local header
* signature for the first file (kLFHSignature) or, if the archive doesn't
* have any files in it, the end-of-central-directory signature
* (kEOCDSignature).
*/
val = get4LE(basePtr);
if (val == kEOCDSignature) {
LOGI("Found Zip archive, but it looks empty\n");
goto bail;
} else if (val != kLFHSignature) {
LOGV("Not a Zip archive (found 0x%08x)\n", val);
goto bail;
}
/*
* Find the EOCD. We'll find it immediately unless they have a file
* comment.
*/
ptr = basePtr + length - kEOCDLen;
while (ptr >= basePtr) {
if (*ptr == (kEOCDSignature & 0xff) && get4LE(ptr) == kEOCDSignature)
break;
ptr--;
}
if (ptr < basePtr) {
LOGI("Could not find end-of-central-directory in Zip\n");
goto bail;
}
/*
* There are two interesting items in the EOCD block: the number of
* entries in the file, and the file offset of the start of the
* central directory.
*
* (There's actually a count of the #of entries in this file, and for
* all files which comprise a spanned archive, but for our purposes
* we're only interested in the current file. Besides, we expect the
* two to be equivalent for our stuff.)
*/
numEntries = get2LE(ptr + kEOCDNumEntries);
cdOffset = get4LE(ptr + kEOCDFileOffset);
/* valid offsets are [0,EOCD] */
unsigned int maxOffset;
maxOffset = (ptr - basePtr) +1;
LOGV("+++ numEntries=%d cdOffset=%d\n", numEntries, cdOffset);
if (numEntries == 0 || cdOffset >= length) {
LOGW("Invalid entries=%d offset=%d (len=%zd)\n",
numEntries, cdOffset, length);
goto bail;
}
/*
* Create hash table. We have a minimum 75% load factor, possibly as
* low as 50% after we round off to a power of 2. There must be at
* least one unused entry to avoid an infinite loop during creation.
*/
pArchive->mNumEntries = numEntries;
pArchive->mHashTableSize = dexRoundUpPower2(1 + (numEntries * 4) / 3);
pArchive->mHashTable = (ZipHashEntry*)
calloc(pArchive->mHashTableSize, sizeof(ZipHashEntry));
/*
* Walk through the central directory, adding entries to the hash
* table.
*/
ptr = basePtr + cdOffset;
for (i = 0; i < numEntries; i++) {
unsigned int fileNameLen, extraLen, commentLen, localHdrOffset;
const unsigned char* localHdr;
unsigned int hash;
if (get4LE(ptr) != kCDESignature) {
LOGW("Missed a central dir sig (at %d)\n", i);
goto bail;
}
if (ptr + kCDELen > basePtr + length) {
LOGW("Ran off the end (at %d)\n", i);
goto bail;
}
localHdrOffset = get4LE(ptr + kCDELocalOffset);
CHECK_OFFSET(localHdrOffset);
fileNameLen = get2LE(ptr + kCDENameLen);
extraLen = get2LE(ptr + kCDEExtraLen);
commentLen = get2LE(ptr + kCDECommentLen);
//LOGV("+++ %d: localHdr=%d fnl=%d el=%d cl=%d\n",
// i, localHdrOffset, fileNameLen, extraLen, commentLen);
//LOGV(" '%.*s'\n", fileNameLen, ptr + kCDELen);
/* add the CDE filename to the hash table */
hash = computeHash((const char*)ptr + kCDELen, fileNameLen);
addToHash(pArchive, (const char*)ptr + kCDELen, fileNameLen, hash);
localHdr = basePtr + localHdrOffset;
if (get4LE(localHdr) != kLFHSignature) {
LOGW("Bad offset to local header: %d (at %d)\n",
localHdrOffset, i);
goto bail;
}
ptr += kCDELen + fileNameLen + extraLen + commentLen;
CHECK_OFFSET(ptr - basePtr);
}
result = true;
bail:
return result;
#undef CHECK_OFFSET
}
static int mapCentralDirectory0(int fd, const char* debugFileName,
ZipArchive* pArchive, off_t fileLength, size_t readAmount, u1* scanBuf)
{
off_t searchStart = fileLength - readAmount;
if (lseek(fd, searchStart, SEEK_SET) != searchStart) {
LOGW("Zip: seek %ld failed: %s", (long) searchStart, strerror(errno));
return -1;
}
ssize_t actual = TEMP_FAILURE_RETRY(read(fd, scanBuf, readAmount));
if (actual != (ssize_t) readAmount) {
LOGW("Zip: read %zd failed: %s", readAmount, strerror(errno));
return -1;
}
/*
* Scan backward for the EOCD magic. In an archive without a trailing
* comment, we'll find it on the first try. (We may want to consider
* doing an initial minimal read; if we don't find it, retry with a
* second read as above.)
*/
int i;
for (i = readAmount - kEOCDLen; i >= 0; i--) {
if (scanBuf[i] == 0x50 && get4LE(&scanBuf[i]) == kEOCDSignature) {
LOGV("+++ Found EOCD at buf+%d", i);
break;
}
}
if (i < 0) {
LOGD("Zip: EOCD not found, %s is not zip", debugFileName);
return -1;
}
off_t eocdOffset = searchStart + i;
const u1* eocdPtr = scanBuf + i;
assert(eocdOffset < fileLength);
/*
* Grab the CD offset and size, and the number of entries in the
* archive. Verify that they look reasonable.
*/
u4 numEntries = get2LE(eocdPtr + kEOCDNumEntries);
u4 dirSize = get4LE(eocdPtr + kEOCDSize);
u4 dirOffset = get4LE(eocdPtr + kEOCDFileOffset);
if ((long long) dirOffset + (long long) dirSize > (long long) eocdOffset) {
LOGW("Zip: bad offsets (dir %ld, size %u, eocd %ld)",
(long) dirOffset, dirSize, (long) eocdOffset);
return -1;
}
if (numEntries == 0) {
LOGW("Zip: empty archive?");
return -1;
}
LOGV("+++ numEntries=%d dirSize=%d dirOffset=%d",
numEntries, dirSize, dirOffset);
/*
* It all looks good. Create a mapping for the CD, and set the fields
* in pArchive.
*/
if (sysMapFileSegmentInShmem(fd, dirOffset, dirSize,
&pArchive->mDirectoryMap) != 0)
{
LOGW("Zip: cd map failed");
return -1;
}
pArchive->mNumEntries = numEntries;
pArchive->mDirectoryOffset = dirOffset;
return 0;
}
int main(int argc, char** argv) {
// get file size
if( argc != 2) {
printf("usage: zip [zipfilename]\n");
return -1;
}
struct stat zipstat;
int ret = stat(argv[1], &zipstat);
if (ret != 0) {
printf("stat file(%s) failed, %s\n", argv[1], strerror(errno));
return -1;
}
long zipFileLength = zipstat.st_size;
// get EOCD
int fd = open(argv[1], O_RDONLY);
if (fd == -1) {
printf("can not open %s\n", argv[1]);
return -1;
}
unsigned char eocdBuffer[ENDHDR];
lseek(fd, zipFileLength - ENDHDR, SEEK_SET);
read(fd, eocdBuffer, ENDHDR);
unsigned int entrynum = get2LE(eocdBuffer + ENDSUB);
unsigned int entryoffset = get4LE(eocdBuffer + ENDOFF);
// search central directory area
lseek(fd, entryoffset, SEEK_SET);
int i = 0;
unsigned char cdBuffer[CENHDR];
uint32_t fileNameLen = 0;
uint32_t extraLen = 0;
uint32_t fileCommentLen = 0;
uint32_t u32offset = entryoffset;
char nameBuffer[PATH_MAX];
for(i = 0; i < entrynum; i++) {
printf("CD info offset: 0x%x\n", u32offset);
read(fd, cdBuffer, CENHDR);
uint32_t u32sig = get4LE(cdBuffer);
if (u32sig != 0x02014b50) {
printf("central directory sig error: 0x%x, expert 0x02014b50\n", u32sig);
close(fd);
return -1;
}
fileNameLen = get2LE(cdBuffer + CENNAM);
extraLen = get2LE(cdBuffer + CENEXT);
fileCommentLen = get2LE(cdBuffer + CENCOM);
printf("fileNameLen: %d, extraLen: %d, fileCommentLen: %d\n", fileNameLen, extraLen, fileCommentLen);
if (fileNameLen > PATH_MAX) {
printf("file name length(0x%x) should not larger than PATH_MAX\n", fileNameLen);
close(fd);
return -1;
}
read(fd, nameBuffer, fileNameLen);
nameBuffer[fileNameLen] = '\0';
printf("num %d file name: %s\n", i, nameBuffer);
// seek next central directory
u32offset += CENHDR + fileNameLen + extraLen + fileCommentLen;
lseek(fd, u32offset, SEEK_SET);
}
close(fd);
return 0;
}
/*
* Parses the Zip archive's Central Directory. Allocates and populates the
* hash table.
*
* Returns 0 on success.
*/
static int parseZipArchive(ZipArchive* pArchive)
{
int result = -1;
const u1* cdPtr = (const u1*)pArchive->mDirectoryMap.addr;
size_t cdLength = pArchive->mDirectoryMap.length;
int numEntries = pArchive->mNumEntries;
/*
* Create hash table. We have a minimum 75% load factor, possibly as
* low as 50% after we round off to a power of 2. There must be at
* least one unused entry to avoid an infinite loop during creation.
*/
pArchive->mHashTableSize = dexRoundUpPower2(1 + (numEntries * 4) / 3);
pArchive->mHashTable = (ZipHashEntry*)
calloc(pArchive->mHashTableSize, sizeof(ZipHashEntry));
/*
* Walk through the central directory, adding entries to the hash
* table and verifying values.
*/
const u1* ptr = cdPtr;
int i;
for (i = 0; i < numEntries; i++) {
if (get4LE(ptr) != kCDESignature) {
ALOGW("Zip: missed a central dir sig (at %d)", i);
goto bail;
}
if (ptr + kCDELen > cdPtr + cdLength) {
ALOGW("Zip: ran off the end (at %d)", i);
goto bail;
}
long localHdrOffset = (long) get4LE(ptr + kCDELocalOffset);
if (localHdrOffset >= pArchive->mDirectoryOffset) {
ALOGW("Zip: bad LFH offset %ld at entry %d", localHdrOffset, i);
goto bail;
}
unsigned int gpbf = get2LE(ptr + kCDEGPBFlags);
if ((gpbf & kGPFUnsupportedMask) != 0) {
ALOGW("Invalid General Purpose Bit Flag: %d", gpbf);
goto bail;
}
unsigned int nameLen, extraLen, commentLen, hash;
nameLen = get2LE(ptr + kCDENameLen);
extraLen = get2LE(ptr + kCDEExtraLen);
commentLen = get2LE(ptr + kCDECommentLen);
const char *name = (const char *) ptr + kCDELen;
/* Check name for NULL characters */
if (memchr(name, 0, nameLen) != NULL) {
ALOGW("Filename contains NUL byte");
goto bail;
}
/* add the CDE filename to the hash table */
hash = computeHash(name, nameLen);
addToHash(pArchive, name, nameLen, hash);
/* We don't care about the comment or extra data. */
ptr += kCDELen + nameLen + extraLen + commentLen;
if ((size_t)(ptr - cdPtr) > cdLength) {
ALOGW("Zip: bad CD advance (%d vs %zd) at entry %d",
(int) (ptr - cdPtr), cdLength, i);
goto bail;
}
}
ALOGV("+++ zip good scan %d entries", numEntries);
result = 0;
bail:
return result;
}
static int mapCentralDirectory0(int fd, const char* debugFileName,
ZipArchive* pArchive, off64_t fileLength, size_t readAmount, u1* scanBuf)
{
/*
* Make sure this is a Zip archive.
*/
if (lseek64(pArchive->mFd, 0, SEEK_SET) != 0) {
ALOGW("seek to start failed: %s", strerror(errno));
return false;
}
ssize_t actual = TEMP_FAILURE_RETRY(read(pArchive->mFd, scanBuf, sizeof(int32_t)));
if (actual != (ssize_t) sizeof(int32_t)) {
ALOGI("couldn't read first signature from zip archive: %s", strerror(errno));
return false;
}
unsigned int header = get4LE(scanBuf);
if (header != kLFHSignature) {
ALOGV("Not a Zip archive (found 0x%08x)\n", header);
return false;
}
/*
* Perform the traditional EOCD snipe hunt.
*
* We're searching for the End of Central Directory magic number,
* which appears at the start of the EOCD block. It's followed by
* 18 bytes of EOCD stuff and up to 64KB of archive comment. We
* need to read the last part of the file into a buffer, dig through
* it to find the magic number, parse some values out, and use those
* to determine the extent of the CD.
*
* We start by pulling in the last part of the file.
*/
off64_t searchStart = fileLength - readAmount;
if (lseek64(pArchive->mFd, searchStart, SEEK_SET) != searchStart) {
ALOGW("seek %ld failed: %s\n", (long) searchStart, strerror(errno));
return false;
}
actual = TEMP_FAILURE_RETRY(read(pArchive->mFd, scanBuf, readAmount));
if (actual != (ssize_t) readAmount) {
ALOGW("Zip: read %zd, expected %zd. Failed: %s\n",
actual, readAmount, strerror(errno));
return false;
}
/*
* Scan backward for the EOCD magic. In an archive without a trailing
* comment, we'll find it on the first try. (We may want to consider
* doing an initial minimal read; if we don't find it, retry with a
* second read as above.)
*/
int i;
for (i = readAmount - kEOCDLen; i >= 0; i--) {
if (scanBuf[i] == 0x50 && get4LE(&scanBuf[i]) == kEOCDSignature) {
ALOGV("+++ Found EOCD at buf+%d", i);
break;
}
}
if (i < 0) {
ALOGD("Zip: EOCD not found, %s is not zip", debugFileName);
return -1;
}
off64_t eocdOffset = searchStart + i;
const u1* eocdPtr = scanBuf + i;
assert(eocdOffset < fileLength);
/*
* Grab the CD offset and size, and the number of entries in the
* archive. Verify that they look reasonable.
*/
u4 diskNumber = get2LE(eocdPtr + kEOCDDiskNumber);
u4 diskWithCentralDir = get2LE(eocdPtr + kEOCDDiskNumberForCD);
u4 numEntries = get2LE(eocdPtr + kEOCDNumEntries);
u4 totalNumEntries = get2LE(eocdPtr + kEOCDTotalNumEntries);
u4 centralDirSize = get4LE(eocdPtr + kEOCDSize);
u4 centralDirOffset = get4LE(eocdPtr + kEOCDFileOffset);
u4 commentSize = get2LE(eocdPtr + kEOCDCommentSize);
// Verify that they look reasonable.
if ((long long) centralDirOffset + (long long) centralDirSize > (long long) eocdOffset) {
ALOGW("bad offsets (dir %ld, size %u, eocd %ld)\n",
(long) centralDirOffset, centralDirSize, (long) eocdOffset);
return false;
}
if (numEntries == 0) {
ALOGW("empty archive?\n");
return false;
} else if (numEntries != totalNumEntries || diskNumber != 0 || diskWithCentralDir != 0) {
ALOGW("spanned archives not supported");
return false;
}
// Check to see if comment is a sane size
if (((size_t) commentSize > (fileLength - kEOCDLen))
|| (eocdOffset > (fileLength - kEOCDLen) - commentSize)) {
ALOGW("comment size runs off end of file");
return false;
}
ALOGV("+++ numEntries=%d dirSize=%d dirOffset=%d\n",
numEntries, centralDirSize, centralDirOffset);
/*
* It all looks good. Create a mapping for the CD, and set the fields
* in pArchive.
*/
if (sysMapFileSegmentInShmem(fd, centralDirOffset, centralDirSize,
&pArchive->mDirectoryMap) != 0)
{
ALOGW("Zip: cd map failed");
return -1;
}
pArchive->mNumEntries = numEntries;
pArchive->mDirectoryOffset = centralDirOffset;
return 0;
}
/*
* Dump a single instruction.
*/
void dumpInstruction(DexFile* pDexFile, const DexCode* pCode, int insnIdx,
int insnWidth, const DecodedInstruction* pDecInsn)
{
static const float gSpecialTab[16] = {
-2.0f, -1.0f, -0.5f, -0.25f, -0.1f, 0.1f, 0.25f, 0.5f,
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 10.0f, 100.0f, 1000.0f
};
const u2* insns = pCode->insns;
int i;
printf("%06x:", ((u1*)insns - pDexFile->baseAddr) + insnIdx*2);
for (i = 0; i < 8; i++) {
if (i < insnWidth) {
if (i == 7) {
printf(" ... ");
} else {
/* print 16-bit value in little-endian order */
const u1* bytePtr = (const u1*) &insns[insnIdx+i];
printf(" %02x%02x", bytePtr[0], bytePtr[1]);
}
} else {
fputs(" ", stdout);
}
}
if (pDecInsn->opCode == OP_NOP) {
u2 instr = get2LE((const u1*) &insns[insnIdx]);
if (instr == kPackedSwitchSignature) {
printf("|%04x: packed-switch-data (%d units)",
insnIdx, insnWidth);
} else if (instr == kSparseSwitchSignature) {
printf("|%04x: sparse-switch-data (%d units)",
insnIdx, insnWidth);
} else if (instr == kArrayDataSignature) {
printf("|%04x: array-data (%d units)",
insnIdx, insnWidth);
} else {
printf("|%04x: nop // spacer", insnIdx);
}
} else {
printf("|%04x: %s", insnIdx, getOpcodeName(pDecInsn->opCode));
}
switch (dexGetInstrFormat(gInstrFormat, pDecInsn->opCode)) {
case kFmt10x: // op
break;
case kFmt12x: // op vA, vB
printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
break;
case kFmt11n: // op vA, #+B
printf(" v%d, #int %d // #%x",
pDecInsn->vA, (s4)pDecInsn->vB, (u1)pDecInsn->vB);
break;
case kFmt11x: // op vAA
printf(" v%d", pDecInsn->vA);
break;
case kFmt10t: // op +AA
case kFmt20t: // op +AAAA
{
s4 targ = (s4) pDecInsn->vA;
printf(" %04x // %c%04x",
insnIdx + targ,
(targ < 0) ? '-' : '+',
(targ < 0) ? -targ : targ);
}
break;
case kFmt22x: // op vAA, vBBBB
printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
break;
case kFmt21t: // op vAA, +BBBB
{
s4 targ = (s4) pDecInsn->vB;
printf(" v%d, %04x // %c%04x", pDecInsn->vA,
insnIdx + targ,
(targ < 0) ? '-' : '+',
(targ < 0) ? -targ : targ);
}
break;
case kFmt21s: // op vAA, #+BBBB
printf(" v%d, #int %d // #%x",
pDecInsn->vA, (s4)pDecInsn->vB, (u2)pDecInsn->vB);
break;
case kFmt21h: // op vAA, #+BBBB0000[00000000]
// The printed format varies a bit based on the actual opcode.
if (pDecInsn->opCode == OP_CONST_HIGH16) {
s4 value = pDecInsn->vB << 16;
printf(" v%d, #int %d // #%x",
pDecInsn->vA, value, (u2)pDecInsn->vB);
} else {
s8 value = ((s8) pDecInsn->vB) << 48;
printf(" v%d, #long %lld // #%x",
pDecInsn->vA, value, (u2)pDecInsn->vB);
}
break;
case kFmt21c: // op vAA, thing@BBBB
if (pDecInsn->opCode == OP_CONST_STRING) {
printf(" v%d, \"%s\" // string@%04x", pDecInsn->vA,
dexStringById(pDexFile, pDecInsn->vB), pDecInsn->vB);
} else if (pDecInsn->opCode == OP_CHECK_CAST ||
pDecInsn->opCode == OP_NEW_INSTANCE ||
pDecInsn->opCode == OP_CONST_CLASS)
{
printf(" v%d, %s // class@%04x", pDecInsn->vA,
getClassDescriptor(pDexFile, pDecInsn->vB), pDecInsn->vB);
} else /* OP_SGET* */ {
FieldMethodInfo fieldInfo;
if (getFieldInfo(pDexFile, pDecInsn->vB, &fieldInfo)) {
printf(" v%d, %s.%s:%s // field@%04x", pDecInsn->vA,
fieldInfo.classDescriptor, fieldInfo.name,
fieldInfo.signature, pDecInsn->vB);
} else {
printf(" v%d, ??? // field@%04x", pDecInsn->vA, pDecInsn->vB);
}
}
break;
case kFmt23x: // op vAA, vBB, vCC
printf(" v%d, v%d, v%d", pDecInsn->vA, pDecInsn->vB, pDecInsn->vC);
break;
case kFmt22b: // op vAA, vBB, #+CC
printf(" v%d, v%d, #int %d // #%02x",
pDecInsn->vA, pDecInsn->vB, (s4)pDecInsn->vC, (u1)pDecInsn->vC);
break;
case kFmt22t: // op vA, vB, +CCCC
{
s4 targ = (s4) pDecInsn->vC;
printf(" v%d, v%d, %04x // %c%04x", pDecInsn->vA, pDecInsn->vB,
insnIdx + targ,
(targ < 0) ? '-' : '+',
(targ < 0) ? -targ : targ);
}
break;
case kFmt22s: // op vA, vB, #+CCCC
printf(" v%d, v%d, #int %d // #%04x",
pDecInsn->vA, pDecInsn->vB, (s4)pDecInsn->vC, (u2)pDecInsn->vC);
break;
case kFmt22c: // op vA, vB, thing@CCCC
if (pDecInsn->opCode >= OP_IGET && pDecInsn->opCode <= OP_IPUT_SHORT) {
FieldMethodInfo fieldInfo;
if (getFieldInfo(pDexFile, pDecInsn->vC, &fieldInfo)) {
printf(" v%d, v%d, %s.%s:%s // field@%04x", pDecInsn->vA,
pDecInsn->vB, fieldInfo.classDescriptor, fieldInfo.name,
fieldInfo.signature, pDecInsn->vC);
} else {
printf(" v%d, v%d, ??? // field@%04x", pDecInsn->vA,
pDecInsn->vB, pDecInsn->vC);
}
} else {
printf(" v%d, v%d, %s // class@%04x",
pDecInsn->vA, pDecInsn->vB,
getClassDescriptor(pDexFile, pDecInsn->vC), pDecInsn->vC);
}
break;
case kFmt22cs: // [opt] op vA, vB, field offset CCCC
printf(" v%d, v%d, [obj+%04x]",
pDecInsn->vA, pDecInsn->vB, pDecInsn->vC);
break;
case kFmt30t:
printf(" #%08x", pDecInsn->vA);
break;
case kFmt31i: // op vAA, #+BBBBBBBB
{
/* this is often, but not always, a float */
union {
float f;
u4 i;
} conv;
conv.i = pDecInsn->vB;
printf(" v%d, #float %f // #%08x",
pDecInsn->vA, conv.f, pDecInsn->vB);
}
break;
case kFmt31c: // op vAA, thing@BBBBBBBB
printf(" v%d, \"%s\" // string@%08x", pDecInsn->vA,
dexStringById(pDexFile, pDecInsn->vB), pDecInsn->vB);
break;
case kFmt31t: // op vAA, offset +BBBBBBBB
printf(" v%d, %08x // +%08x",
pDecInsn->vA, insnIdx + pDecInsn->vB, pDecInsn->vB);
break;
case kFmt32x: // op vAAAA, vBBBB
printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
break;
case kFmt35c: // op vB, {vD, vE, vF, vG, vA}, thing@CCCC
{
/* NOTE: decoding of 35c doesn't quite match spec */
fputs(" {", stdout);
for (i = 0; i < (int) pDecInsn->vA; i++) {
if (i == 0)
printf("v%d", pDecInsn->arg[i]);
else
printf(", v%d", pDecInsn->arg[i]);
}
if (pDecInsn->opCode == OP_FILLED_NEW_ARRAY) {
printf("}, %s // class@%04x",
getClassDescriptor(pDexFile, pDecInsn->vB), pDecInsn->vB);
} else {
FieldMethodInfo methInfo;
if (getMethodInfo(pDexFile, pDecInsn->vB, &methInfo)) {
printf("}, %s.%s:%s // method@%04x",
methInfo.classDescriptor, methInfo.name,
methInfo.signature, pDecInsn->vB);
} else {
printf("}, ??? // method@%04x", pDecInsn->vB);
}
}
}
break;
case kFmt35ms: // [opt] invoke-virtual+super
case kFmt35fs: // [opt] invoke-interface
{
fputs(" {", stdout);
for (i = 0; i < (int) pDecInsn->vA; i++) {
if (i == 0)
printf("v%d", pDecInsn->arg[i]);
else
printf(", v%d", pDecInsn->arg[i]);
}
printf("}, [%04x] // vtable #%04x", pDecInsn->vB, pDecInsn->vB);
}
break;
case kFmt3rc: // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB
{
/*
* This doesn't match the "dx" output when some of the args are
* 64-bit values -- dx only shows the first register.
*/
fputs(" {", stdout);
for (i = 0; i < (int) pDecInsn->vA; i++) {
if (i == 0)
printf("v%d", pDecInsn->vC + i);
else
printf(", v%d", pDecInsn->vC + i);
}
if (pDecInsn->opCode == OP_FILLED_NEW_ARRAY_RANGE) {
printf("}, %s // class@%04x",
getClassDescriptor(pDexFile, pDecInsn->vB), pDecInsn->vB);
} else {
FieldMethodInfo methInfo;
if (getMethodInfo(pDexFile, pDecInsn->vB, &methInfo)) {
printf("}, %s.%s:%s // method@%04x",
methInfo.classDescriptor, methInfo.name,
methInfo.signature, pDecInsn->vB);
} else {
printf("}, ??? // method@%04x", pDecInsn->vB);
}
}
}
break;
case kFmt3rms: // [opt] invoke-virtual+super/range
case kFmt3rfs: // [opt] invoke-interface/range
{
/*
* This doesn't match the "dx" output when some of the args are
* 64-bit values -- dx only shows the first register.
*/
fputs(" {", stdout);
for (i = 0; i < (int) pDecInsn->vA; i++) {
if (i == 0)
printf("v%d", pDecInsn->vC + i);
else
printf(", v%d", pDecInsn->vC + i);
}
printf("}, [%04x] // vtable #%04x", pDecInsn->vB, pDecInsn->vB);
}
break;
case kFmt3inline: // [opt] inline invoke
{
#if 0
const InlineOperation* inlineOpsTable = dvmGetInlineOpsTable();
u4 tableLen = dvmGetInlineOpsTableLength();
#endif
fputs(" {", stdout);
for (i = 0; i < (int) pDecInsn->vA; i++) {
if (i == 0)
printf("v%d", pDecInsn->arg[i]);
else
printf(", v%d", pDecInsn->arg[i]);
}
#if 0
if (pDecInsn->vB < tableLen) {
printf("}, %s.%s:%s // inline #%04x",
inlineOpsTable[pDecInsn->vB].classDescriptor,
inlineOpsTable[pDecInsn->vB].methodName,
inlineOpsTable[pDecInsn->vB].methodSignature,
pDecInsn->vB);
} else {
#endif
printf("}, [%04x] // inline #%04x", pDecInsn->vB, pDecInsn->vB);
#if 0
}
#endif
}
break;
case kFmt51l: // op vAA, #+BBBBBBBBBBBBBBBB
{
/* this is often, but not always, a double */
union {
double d;
u8 j;
} conv;
conv.j = pDecInsn->vB_wide;
printf(" v%d, #double %f // #%016llx",
pDecInsn->vA, conv.d, pDecInsn->vB_wide);
}
break;
case kFmtUnknown:
break;
default:
printf(" ???");
break;
}
putchar('\n');
}
