1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // 18 // Read-only access to Zip archives, with minimal heap allocation. 19 // 20 #define LOG_TAG "zipro" 21 //#define LOG_NDEBUG 0 22 #include <androidfw/ZipFileRO.h> 23 #include <utils/Log.h> 24 #include <utils/Compat.h> 25 #include <utils/misc.h> 26 #include <utils/threads.h> 27 #include <ziparchive/zip_archive.h> 28 29 #include <zlib.h> 30 31 #include <string.h> 32 #include <fcntl.h> 33 #include <errno.h> 34 #include <assert.h> 35 #include <unistd.h> 36 37 using namespace android; 38 39 class _ZipEntryRO { 40 public: 41 ZipEntry entry; 42 ZipString name; 43 void *cookie; 44 45 _ZipEntryRO() : cookie(NULL) {} 46 47 ~_ZipEntryRO() { 48 EndIteration(cookie); 49 } 50 51 private: 52 _ZipEntryRO(const _ZipEntryRO& other); 53 _ZipEntryRO& operator=(const _ZipEntryRO& other); 54 }; 55 56 ZipFileRO::~ZipFileRO() { 57 CloseArchive(mHandle); 58 free(mFileName); 59 } 60 61 /* 62 * Open the specified file read-only. We memory-map the entire thing and 63 * close the file before returning. 64 */ 65 /* static */ ZipFileRO* ZipFileRO::open(const char* zipFileName) 66 { 67 ZipArchiveHandle handle; 68 const int32_t error = OpenArchive(zipFileName, &handle); 69 if (error) { 70 ALOGW("Error opening archive %s: %s", zipFileName, ErrorCodeString(error)); 71 CloseArchive(handle); 72 return NULL; 73 } 74 75 return new ZipFileRO(handle, strdup(zipFileName)); 76 } 77 78 79 ZipEntryRO ZipFileRO::findEntryByName(const char* entryName) const 80 { 81 _ZipEntryRO* data = new _ZipEntryRO; 82 83 data->name = ZipString(entryName); 84 85 const int32_t error = FindEntry(mHandle, data->name, &(data->entry)); 86 if (error) { 87 delete data; 88 return NULL; 89 } 90 91 return (ZipEntryRO) data; 92 } 93 94 /* 95 * Get the useful fields from the zip entry. 96 * 97 * Returns "false" if the offsets to the fields or the contents of the fields 98 * appear to be bogus. 99 */ 100 bool ZipFileRO::getEntryInfo(ZipEntryRO entry, uint16_t* pMethod, 101 uint32_t* pUncompLen, uint32_t* pCompLen, off64_t* pOffset, 102 uint32_t* pModWhen, uint32_t* pCrc32) const 103 { 104 const _ZipEntryRO* zipEntry = reinterpret_cast<_ZipEntryRO*>(entry); 105 const ZipEntry& ze = zipEntry->entry; 106 107 if (pMethod != NULL) { 108 *pMethod = ze.method; 109 } 110 if (pUncompLen != NULL) { 111 *pUncompLen = ze.uncompressed_length; 112 } 113 if (pCompLen != NULL) { 114 *pCompLen = ze.compressed_length; 115 } 116 if (pOffset != NULL) { 117 *pOffset = ze.offset; 118 } 119 if (pModWhen != NULL) { 120 *pModWhen = ze.mod_time; 121 } 122 if (pCrc32 != NULL) { 123 *pCrc32 = ze.crc32; 124 } 125 126 return true; 127 } 128 129 bool ZipFileRO::startIteration(void** cookie) { 130 return startIteration(cookie, NULL, NULL); 131 } 132 133 bool ZipFileRO::startIteration(void** cookie, const char* prefix, const char* suffix) 134 { 135 _ZipEntryRO* ze = new _ZipEntryRO; 136 ZipString pe(prefix ? prefix : ""); 137 ZipString se(suffix ? suffix : ""); 138 int32_t error = StartIteration(mHandle, &(ze->cookie), 139 prefix ? &pe : NULL, 140 suffix ? &se : NULL); 141 if (error) { 142 ALOGW("Could not start iteration over %s: %s", mFileName, ErrorCodeString(error)); 143 delete ze; 144 return false; 145 } 146 147 *cookie = ze; 148 return true; 149 } 150 151 ZipEntryRO ZipFileRO::nextEntry(void* cookie) 152 { 153 _ZipEntryRO* ze = reinterpret_cast<_ZipEntryRO*>(cookie); 154 int32_t error = Next(ze->cookie, &(ze->entry), &(ze->name)); 155 if (error) { 156 if (error != -1) { 157 ALOGW("Error iteration over %s: %s", mFileName, ErrorCodeString(error)); 158 } 159 return NULL; 160 } 161 162 return &(ze->entry); 163 } 164 165 void ZipFileRO::endIteration(void* cookie) 166 { 167 delete reinterpret_cast<_ZipEntryRO*>(cookie); 168 } 169 170 void ZipFileRO::releaseEntry(ZipEntryRO entry) const 171 { 172 delete reinterpret_cast<_ZipEntryRO*>(entry); 173 } 174 175 /* 176 * Copy the entry's filename to the buffer. 177 */ 178 int ZipFileRO::getEntryFileName(ZipEntryRO entry, char* buffer, size_t bufLen) 179 const 180 { 181 const _ZipEntryRO* zipEntry = reinterpret_cast<_ZipEntryRO*>(entry); 182 const uint16_t requiredSize = zipEntry->name.name_length + 1; 183 184 if (bufLen < requiredSize) { 185 ALOGW("Buffer too short, requires %d bytes for entry name", requiredSize); 186 return requiredSize; 187 } 188 189 memcpy(buffer, zipEntry->name.name, requiredSize - 1); 190 buffer[requiredSize - 1] = '\0'; 191 192 return 0; 193 } 194 195 /* 196 * Create a new FileMap object that spans the data in "entry". 197 */ 198 FileMap* ZipFileRO::createEntryFileMap(ZipEntryRO entry) const 199 { 200 const _ZipEntryRO *zipEntry = reinterpret_cast<_ZipEntryRO*>(entry); 201 const ZipEntry& ze = zipEntry->entry; 202 int fd = GetFileDescriptor(mHandle); 203 size_t actualLen = 0; 204 205 if (ze.method == kCompressStored) { 206 actualLen = ze.uncompressed_length; 207 } else { 208 actualLen = ze.compressed_length; 209 } 210 211 FileMap* newMap = new FileMap(); 212 if (!newMap->create(mFileName, fd, ze.offset, actualLen, true)) { 213 delete newMap; 214 return NULL; 215 } 216 217 return newMap; 218 } 219 220 /* 221 * Uncompress an entry, in its entirety, into the provided output buffer. 222 * 223 * This doesn't verify the data's CRC, which might be useful for 224 * uncompressed data. The caller should be able to manage it. 225 */ 226 bool ZipFileRO::uncompressEntry(ZipEntryRO entry, void* buffer, size_t size) const 227 { 228 _ZipEntryRO *zipEntry = reinterpret_cast<_ZipEntryRO*>(entry); 229 const int32_t error = ExtractToMemory(mHandle, &(zipEntry->entry), 230 (uint8_t*) buffer, size); 231 if (error) { 232 ALOGW("ExtractToMemory failed with %s", ErrorCodeString(error)); 233 return false; 234 } 235 236 return true; 237 } 238 239 /* 240 * Uncompress an entry, in its entirety, to an open file descriptor. 241 * 242 * This doesn't verify the data's CRC, but probably should. 243 */ 244 bool ZipFileRO::uncompressEntry(ZipEntryRO entry, int fd) const 245 { 246 _ZipEntryRO *zipEntry = reinterpret_cast<_ZipEntryRO*>(entry); 247 const int32_t error = ExtractEntryToFile(mHandle, &(zipEntry->entry), fd); 248 if (error) { 249 ALOGW("ExtractToMemory failed with %s", ErrorCodeString(error)); 250 return false; 251 } 252 253 return true; 254 } 255
