Merge changes I25acff1d,Iae67e62f (ec3994f2) · Commits · e / os / android_frameworks_native

include/androidfw/ZipFileRO.h

+40 −132

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@
		#include <unistd.h>
		#include <time.h>

		typedef void* ZipArchiveHandle;

		namespace android {

		/*
		@@ -51,18 +53,13 @@ typedef void* ZipEntryRO;
		/*
		* Open a Zip archive for reading.
		*
		* We want "open" and "find entry by name" to be fast operations, and we
		* want to use as little memory as possible. We memory-map the file,
		* and load a hash table with pointers to the filenames (which aren't
		* null-terminated). The other fields are at a fixed offset from the
		* filename, so we don't need to extract those (but we do need to byte-read
		* and endian-swap them every time we want them).
		* Implemented as a thin wrapper over system/core/libziparchive.
		*
		* "open" and "find entry by name" are fast operations and use as little
		* memory as possible.
		*
		* To speed comparisons when doing a lookup by name, we could make the mapping
		* "private" (copy-on-write) and null-terminate the filenames after verifying
		* the record structure. However, this requires a private mapping of
		* every page that the Central Directory touches. Easier to tuck a copy
		* of the string length into the hash table entry.
		* We also support fast iteration over all entries in the file (with a
		* stable, but unspecified iteration order).
		*
		* NOTE: If this is used on file descriptors inherited from a fork() operation,
		* you must be on a platform that implements pread() to guarantee correctness
		@@ -70,48 +67,44 @@ typedef void* ZipEntryRO;
		*/
		class ZipFileRO {
		public:
		ZipFileRO()
		: mFd(-1), mFileName(NULL), mFileLength(-1),
		mDirectoryMap(NULL),
		mNumEntries(-1), mDirectoryOffset(-1),
		mHashTableSize(-1), mHashTable(NULL)
		{}

		~ZipFileRO();
		/* Zip compression methods we support */
		enum {
		kCompressStored = 0, // no compression
		kCompressDeflated = 8, // standard deflate
		};

		/*
		* Open an archive.
		*/
		status_t open(const char* zipFileName);
		static ZipFileRO* open(const char* zipFileName);

		/*
		* Find an entry, by name. Returns the entry identifier, or NULL if
		* not found.
		*
		* If two entries have the same name, one will be chosen at semi-random.
		*/
		ZipEntryRO findEntryByName(const char* fileName) const;
		ZipEntryRO findEntryByName(const char* entryName) const;


		/*
		* Return the #of entries in the Zip archive.
		* Start iterating over the list of entries in the zip file. Requires
		* a matching call to endIteration with the same cookie.
		*/
		int getNumEntries(void) const {
		return mNumEntries;
		}
		bool startIteration(void** cookie);

		/**
		* Return the next entry in iteration order, or NULL if there are no more
		* entries in this archive.
		*/
		ZipEntryRO nextEntry(void* cookie);

		void endIteration(void* cookie);

		void releaseEntry(ZipEntryRO entry) const;

		/*
		* Return the Nth entry. Zip file entries are not stored in sorted
		* order, and updated entries may appear at the end, so anyone walking
		* the archive needs to avoid making ordering assumptions. We take
		* that further by returning the Nth non-empty entry in the hash table
		* rather than the Nth entry in the archive.
		*
		* Valid values are [0..numEntries).
		*
		* [This is currently O(n). If it needs to be fast we can allocate an
		* additional data structure or provide an iterator interface.]
		* Return the #of entries in the Zip archive.
		*/
		ZipEntryRO findEntryByIndex(int idx) const;
		int getNumEntries();

		/*
		* Copy the filename into the supplied buffer. Returns 0 on success,
		@@ -149,112 +142,27 @@ public:
		*
		* Returns "true" on success.
		*/
		bool uncompressEntry(ZipEntryRO entry, void* buffer) const;
		bool uncompressEntry(ZipEntryRO entry, void* buffer, size_t size) const;

		/*
		* Uncompress the data to an open file descriptor.
		*/
		bool uncompressEntry(ZipEntryRO entry, int fd) const;

		/* Zip compression methods we support */
		enum {
		kCompressStored = 0, // no compression
		kCompressDeflated = 8, // standard deflate
		};

		/*
		* Utility function: uncompress deflated data, buffer to buffer.
		*/
		static bool inflateBuffer(void* outBuf, const void* inBuf,
		size_t uncompLen, size_t compLen);

		/*
		* Utility function: uncompress deflated data, buffer to fd.
		*/
		static bool inflateBuffer(int fd, const void* inBuf,
		size_t uncompLen, size_t compLen);

		/*
		* Utility function to convert ZIP's time format to a timespec struct.
		*/
		static inline void zipTimeToTimespec(long when, struct tm* timespec) {
		const long date = when >> 16;
		timespec->tm_year = ((date >> 9) & 0x7F) + 80; // Zip is years since 1980
		timespec->tm_mon = (date >> 5) & 0x0F;
		timespec->tm_mday = date & 0x1F;

		timespec->tm_hour = (when >> 11) & 0x1F;
		timespec->tm_min = (when >> 5) & 0x3F;
		timespec->tm_sec = (when & 0x1F) << 1;
		}

		/*
		* Some basic functions for raw data manipulation. "LE" means
		* Little Endian.
		*/
		static inline unsigned short get2LE(const unsigned char* buf) {
		return buf[0] \| (buf[1] << 8);
		}
		static inline unsigned long get4LE(const unsigned char* buf) {
		return buf[0] \| (buf[1] << 8) \| (buf[2] << 16) \| (buf[3] << 24);
		}
		~ZipFileRO();

		private:
		/* these are private and not defined */
		ZipFileRO(const ZipFileRO& src);
		ZipFileRO& operator=(const ZipFileRO& src);

		/* locate and parse the central directory */
		bool mapCentralDirectory(void);

		/* parse the archive, prepping internal structures */
		bool parseZipArchive(void);

		/* add a new entry to the hash table */
		void addToHash(const char* str, int strLen, unsigned int hash);

		/* compute string hash code */
		static unsigned int computeHash(const char* str, int len);

		/* convert a ZipEntryRO back to a hash table index */
		int entryToIndex(const ZipEntryRO entry) const;

		/*
		* One entry in the hash table.
		*/
		typedef struct HashEntry {
		const char* name;
		unsigned short nameLen;
		//unsigned int hash;
		} HashEntry;

		/* open Zip archive */
		int mFd;

		/* Lock for handling the file descriptor (seeks, etc) */
		mutable Mutex mFdLock;
		ZipFileRO(ZipArchiveHandle handle, char* fileName) : mHandle(handle),
		mFileName(fileName)
		{
		}

		/* zip file name */
		const ZipArchiveHandle mHandle;
		char* mFileName;

		/* length of file */
		size_t mFileLength;

		/* mapped file */
		FileMap* mDirectoryMap;

		/* number of entries in the Zip archive */
		int mNumEntries;

		/* CD directory offset in the Zip archive */
		off64_t mDirectoryOffset;

		/*
		* We know how many entries are in the Zip archive, so we have a
		* fixed-size hash table. We probe for an empty slot.
		*/
		int mHashTableSize;
		HashEntry* mHashTable;
		};

		}; // namespace android

include/androidfw/ZipUtils.h

+17 −1

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#define __LIBS_ZIPUTILS_H

		#include <stdio.h>
		#include <time.h>

		namespace android {

		@@ -33,9 +34,11 @@ public:
		* General utility function for uncompressing "deflate" data from a file
		* to a buffer.
		*/
		static bool inflateToBuffer(FILE* fp, void* buf, long uncompressedLen,
		long compressedLen);
		static bool inflateToBuffer(int fd, void* buf, long uncompressedLen,
		long compressedLen);
		static bool inflateToBuffer(FILE* fp, void* buf, long uncompressedLen,
		static bool inflateToBuffer(void in, void buf, long uncompressedLen,
		long compressedLen);

		/*
		@@ -57,6 +60,19 @@ public:
		static bool examineGzip(FILE* fp, int* pCompressionMethod,
		long* pUncompressedLen, long* pCompressedLen, unsigned long* pCRC32);

		/*
		* Utility function to convert ZIP's time format to a timespec struct.
		*/
		static inline void zipTimeToTimespec(long when, struct tm* timespec) {
		const long date = when >> 16;
		timespec->tm_year = ((date >> 9) & 0x7F) + 80; // Zip is years since 1980
		timespec->tm_mon = (date >> 5) & 0x0F;
		timespec->tm_mday = date & 0x1F;

		timespec->tm_hour = (when >> 11) & 0x1F;
		timespec->tm_min = (when >> 5) & 0x3F;
		timespec->tm_sec = (when & 0x1F) << 1;
		}
		private:
		ZipUtils() {}
		~ZipUtils() {}

libs/androidfw/Android.mk

+5 −2

Original line number	Diff line number	Diff line
		@@ -53,7 +53,7 @@ LOCAL_CFLAGS += -DSTATIC_ANDROIDFW_FOR_TOOLS
		LOCAL_C_INCLUDES := \
		external/zlib

		LOCAL_STATIC_LIBRARIES := liblog
		LOCAL_STATIC_LIBRARIES := liblog libziparchive-host libutils

		include $(BUILD_HOST_STATIC_LIBRARY)

		@@ -72,9 +72,12 @@ LOCAL_SHARED_LIBRARIES := \
		libutils \
		libz

		LOCAL_STATIC_LIBRARIES := libziparchive

		LOCAL_C_INCLUDES := \
		external/icu4c/common \
		external/zlib
		external/zlib \
		system/core/include

		LOCAL_MODULE:= libandroidfw

libs/androidfw/Asset.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -843,7 +843,7 @@ void _CompressedAsset::close(void)
		* The first time this is called, we expand the compressed data into a
		* buffer.
		*/
		const void* _CompressedAsset::getBuffer(bool wordAligned)
		const void* _CompressedAsset::getBuffer(bool)
		{
		unsigned char* buf = NULL;

		@@ -860,7 +860,7 @@ const void* _CompressedAsset::getBuffer(bool wordAligned)
		}

		if (mMap != NULL) {
		if (!ZipFileRO::inflateBuffer(buf, mMap->getDataPtr(),
		if (!ZipUtils::inflateToBuffer(mMap->getDataPtr(), buf,
		mUncompressedLen, mCompressedLen))
		goto bail;
		} else {

libs/androidfw/AssetManager.cpp

+23 −21

Original line number	Diff line number	Diff line
		@@ -305,10 +305,11 @@ bool AssetManager::getZipEntryCrcLocked(const String8& zipPath, const char* entr
		if (entry == NULL) {
		return false;
		}
		if (!zip->getEntryInfo(entry, NULL, NULL, NULL, NULL, NULL, (long*)pCrc)) {
		return false;
		}
		return true;

		const bool gotInfo = zip->getEntryInfo(entry, NULL, NULL, NULL, NULL, NULL, (long*)pCrc);
		zip->releaseEntry(entry);

		return gotInfo;
		}

		bool AssetManager::createIdmapFileLocked(const String8& originalPath, const String8& overlayPath,
		@@ -821,16 +822,14 @@ Asset* AssetManager::openNonAssetInPathLocked(const char* fileName, AccessMode m
		String8 path(fileName);

		/* check the appropriate Zip file */
		ZipFileRO* pZip;
		ZipEntryRO entry;

		pZip = getZipFileLocked(ap);
		ZipFileRO* pZip = getZipFileLocked(ap);
		if (pZip != NULL) {
		//printf("GOT zip, checking NA '%s'\n", (const char*) path);
		entry = pZip->findEntryByName(path.string());
		ZipEntryRO entry = pZip->findEntryByName(path.string());
		if (entry != NULL) {
		//printf("FOUND NA in Zip file for %s\n", appName ? appName : kAppCommon);
		pAsset = openAssetFromZipLocked(pZip, entry, mode, path);
		pZip->releaseEntry(entry);
		}
		}

		@@ -975,17 +974,15 @@ Asset* AssetManager::openInLocaleVendorLocked(const char* fileName, AccessMode m
		path.appendPath(fileName);

		/* check the appropriate Zip file */
		ZipFileRO* pZip;
		ZipEntryRO entry;

		pZip = getZipFileLocked(ap);
		ZipFileRO* pZip = getZipFileLocked(ap);
		if (pZip != NULL) {
		//printf("GOT zip, checking '%s'\n", (const char*) path);
		entry = pZip->findEntryByName(path.string());
		ZipEntryRO entry = pZip->findEntryByName(path.string());
		if (entry != NULL) {
		//printf("FOUND in Zip file for %s/%s-%s\n",
		// appName, locale, vendor);
		pAsset = openAssetFromZipLocked(pZip, entry, mode, path);
		pZip->releaseEntry(entry);
		}
		}

		@@ -1487,11 +1484,16 @@ bool AssetManager::scanAndMergeZipLocked(SortedVector<AssetDir::FileInfo>* pMerg
		* semantics.
		*/
		int dirNameLen = dirName.length();
		for (int i = 0; i < pZip->getNumEntries(); i++) {
		void *iterationCookie;
		if (!pZip->startIteration(&iterationCookie)) {
		ALOGW("ZipFileRO::startIteration returned false");
		return false;
		}

		ZipEntryRO entry;
		while ((entry = pZip->nextEntry(iterationCookie)) != NULL) {
		char nameBuf[256];

		entry = pZip->findEntryByIndex(i);
		if (pZip->getEntryFileName(entry, nameBuf, sizeof(nameBuf)) != 0) {
		// TODO: fix this if we expect to have long names
		ALOGE("ARGH: name too long?\n");
		@@ -1541,6 +1543,8 @@ bool AssetManager::scanAndMergeZipLocked(SortedVector<AssetDir::FileInfo>* pMerg
		}
		}

		pZip->endIteration(iterationCookie);

		/*
		* Add the set of unique directories.
		*/
		@@ -1814,12 +1818,10 @@ AssetManager::SharedZip::SharedZip(const String8& path, time_t modWhen)
		mResourceTableAsset(NULL), mResourceTable(NULL)
		{
		//ALOGI("Creating SharedZip %p %s\n", this, (const char*)mPath);
		mZipFile = new ZipFileRO;
		ALOGV("+++ opening zip '%s'\n", mPath.string());
		if (mZipFile->open(mPath.string()) != NO_ERROR) {
		mZipFile = ZipFileRO::open(mPath.string());
		if (mZipFile == NULL) {
		ALOGD("failed to open Zip archive '%s'\n", mPath.string());
		delete mZipFile;
		mZipFile = NULL;
		}
		}