libs/androidfw/StreamingZipInflater.cpp

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