1 /* 2 * Copyright (C) 2010 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 //#define LOG_NDEBUG 0 18 #define LOG_TAG "szipinf" 19 #include <utils/Log.h> 20 21 #include <androidfw/StreamingZipInflater.h> 22 #include <utils/FileMap.h> 23 #include <string.h> 24 #include <stddef.h> 25 #include <assert.h> 26 #include <unistd.h> 27 #include <errno.h> 28 29 /* 30 * TEMP_FAILURE_RETRY is defined by some, but not all, versions of 31 * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's 32 * not already defined, then define it here. 33 */ 34 #ifndef TEMP_FAILURE_RETRY 35 /* Used to retry syscalls that can return EINTR. */ 36 #define TEMP_FAILURE_RETRY(exp) ({ \ 37 typeof (exp) _rc; \ 38 do { \ 39 _rc = (exp); \ 40 } while (_rc == -1 && errno == EINTR); \ 41 _rc; }) 42 #endif 43 44 static const bool kIsDebug = false; 45 46 static inline size_t min_of(size_t a, size_t b) { return (a < b) ? a : b; } 47 48 using namespace android; 49 50 /* 51 * Streaming access to compressed asset data in an open fd 52 */ 53 StreamingZipInflater::StreamingZipInflater(int fd, off64_t compDataStart, 54 size_t uncompSize, size_t compSize) { 55 mFd = fd; 56 mDataMap = NULL; 57 mInFileStart = compDataStart; 58 mOutTotalSize = uncompSize; 59 mInTotalSize = compSize; 60 61 mInBufSize = StreamingZipInflater::INPUT_CHUNK_SIZE; 62 mInBuf = new uint8_t[mInBufSize]; 63 64 mOutBufSize = StreamingZipInflater::OUTPUT_CHUNK_SIZE; 65 mOutBuf = new uint8_t[mOutBufSize]; 66 67 initInflateState(); 68 } 69 70 /* 71 * Streaming access to compressed data held in an mmapped region of memory 72 */ 73 StreamingZipInflater::StreamingZipInflater(FileMap* dataMap, size_t uncompSize) { 74 mFd = -1; 75 mDataMap = dataMap; 76 mOutTotalSize = uncompSize; 77 mInTotalSize = dataMap->getDataLength(); 78 79 mInBuf = (uint8_t*) dataMap->getDataPtr(); 80 mInBufSize = mInTotalSize; 81 82 mOutBufSize = StreamingZipInflater::OUTPUT_CHUNK_SIZE; 83 mOutBuf = new uint8_t[mOutBufSize]; 84 85 initInflateState(); 86 } 87 88 StreamingZipInflater::~StreamingZipInflater() { 89 // tear down the in-flight zip state just in case 90 ::inflateEnd(&mInflateState); 91 92 if (mDataMap == NULL) { 93 delete [] mInBuf; 94 } 95 delete [] mOutBuf; 96 } 97 98 void StreamingZipInflater::initInflateState() { 99 ALOGV("Initializing inflate state"); 100 101 memset(&mInflateState, 0, sizeof(mInflateState)); 102 mInflateState.zalloc = Z_NULL; 103 mInflateState.zfree = Z_NULL; 104 mInflateState.opaque = Z_NULL; 105 mInflateState.next_in = (Bytef*)mInBuf; 106 mInflateState.next_out = (Bytef*) mOutBuf; 107 mInflateState.avail_out = mOutBufSize; 108 mInflateState.data_type = Z_UNKNOWN; 109 110 mOutLastDecoded = mOutDeliverable = mOutCurPosition = 0; 111 mInNextChunkOffset = 0; 112 mStreamNeedsInit = true; 113 114 if (mDataMap == NULL) { 115 ::lseek(mFd, mInFileStart, SEEK_SET); 116 mInflateState.avail_in = 0; // set when a chunk is read in 117 } else { 118 mInflateState.avail_in = mInBufSize; 119 } 120 } 121 122 /* 123 * Basic approach: 124 * 125 * 1. If we have undelivered uncompressed data, send it. At this point 126 * either we've satisfied the request, or we've exhausted the available 127 * output data in mOutBuf. 128 * 129 * 2. While we haven't sent enough data to satisfy the request: 130 * 0. if the request is for more data than exists, bail. 131 * a. if there is no input data to decode, read some into the input buffer 132 * and readjust the z_stream input pointers 133 * b. point the output to the start of the output buffer and decode what we can 134 * c. deliver whatever output data we can 135 */ 136 ssize_t StreamingZipInflater::read(void* outBuf, size_t count) { 137 uint8_t* dest = (uint8_t*) outBuf; 138 size_t bytesRead = 0; 139 size_t toRead = min_of(count, size_t(mOutTotalSize - mOutCurPosition)); 140 while (toRead > 0) { 141 // First, write from whatever we already have decoded and ready to go 142 size_t deliverable = min_of(toRead, mOutLastDecoded - mOutDeliverable); 143 if (deliverable > 0) { 144 if (outBuf != NULL) memcpy(dest, mOutBuf + mOutDeliverable, deliverable); 145 mOutDeliverable += deliverable; 146 mOutCurPosition += deliverable; 147 dest += deliverable; 148 bytesRead += deliverable; 149 toRead -= deliverable; 150 } 151 152 // need more data? time to decode some. 153 if (toRead > 0) { 154 // if we don't have any data to decode, read some in. If we're working 155 // from mmapped data this won't happen, because the clipping to total size 156 // will prevent reading off the end of the mapped input chunk. 157 if ((mInflateState.avail_in == 0) && (mDataMap == NULL)) { 158 int err = readNextChunk(); 159 if (err < 0) { 160 ALOGE("Unable to access asset data: %d", err); 161 if (!mStreamNeedsInit) { 162 ::inflateEnd(&mInflateState); 163 initInflateState(); 164 } 165 return -1; 166 } 167 } 168 // we know we've drained whatever is in the out buffer now, so just 169 // start from scratch there, reading all the input we have at present. 170 mInflateState.next_out = (Bytef*) mOutBuf; 171 mInflateState.avail_out = mOutBufSize; 172 173 /* 174 ALOGV("Inflating to outbuf: avail_in=%u avail_out=%u next_in=%p next_out=%p", 175 mInflateState.avail_in, mInflateState.avail_out, 176 mInflateState.next_in, mInflateState.next_out); 177 */ 178 int result = Z_OK; 179 if (mStreamNeedsInit) { 180 ALOGV("Initializing zlib to inflate"); 181 result = inflateInit2(&mInflateState, -MAX_WBITS); 182 mStreamNeedsInit = false; 183 } 184 if (result == Z_OK) result = ::inflate(&mInflateState, Z_SYNC_FLUSH); 185 if (result < 0) { 186 // Whoops, inflation failed 187 ALOGE("Error inflating asset: %d", result); 188 ::inflateEnd(&mInflateState); 189 initInflateState(); 190 return -1; 191 } else { 192 if (result == Z_STREAM_END) { 193 // we know we have to have reached the target size here and will 194 // not try to read any further, so just wind things up. 195 ::inflateEnd(&mInflateState); 196 } 197 198 // Note how much data we got, and off we go 199 mOutDeliverable = 0; 200 mOutLastDecoded = mOutBufSize - mInflateState.avail_out; 201 } 202 } 203 } 204 return bytesRead; 205 } 206 207 int StreamingZipInflater::readNextChunk() { 208 assert(mDataMap == NULL); 209 210 if (mInNextChunkOffset < mInTotalSize) { 211 size_t toRead = min_of(mInBufSize, mInTotalSize - mInNextChunkOffset); 212 if (toRead > 0) { 213 ssize_t didRead = TEMP_FAILURE_RETRY(::read(mFd, mInBuf, toRead)); 214 if (kIsDebug) { 215 ALOGV("Reading input chunk, size %08zx didread %08zx", toRead, didRead); 216 } 217 if (didRead < 0) { 218 ALOGE("Error reading asset data: %s", strerror(errno)); 219 return didRead; 220 } else { 221 mInNextChunkOffset += didRead; 222 mInflateState.next_in = (Bytef*) mInBuf; 223 mInflateState.avail_in = didRead; 224 } 225 } 226 } 227 return 0; 228 } 229 230 // seeking backwards requires uncompressing fom the beginning, so is very 231 // expensive. seeking forwards only requires uncompressing from the current 232 // position to the destination. 233 off64_t StreamingZipInflater::seekAbsolute(off64_t absoluteInputPosition) { 234 if (absoluteInputPosition < mOutCurPosition) { 235 // rewind and reprocess the data from the beginning 236 if (!mStreamNeedsInit) { 237 ::inflateEnd(&mInflateState); 238 } 239 initInflateState(); 240 read(NULL, absoluteInputPosition); 241 } else if (absoluteInputPosition > mOutCurPosition) { 242 read(NULL, absoluteInputPosition - mOutCurPosition); 243 } 244 // else if the target position *is* our current position, do nothing 245 return absoluteInputPosition; 246 } 247
