ZipFile.cpp

   1 /*
   2  * Copyright (C) 2006 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 // Access to Zip archives.
  19 //
  20
  21 #define LOG_TAG "zip"
  22
  23 #include <utils/ZipUtils.h>
  24 #include <utils/Log.h>
  25
  26 #include "ZipFile.h"
  27
  28 #include <zlib.h>
  29 #define DEF_MEM_LEVEL 8                // normally in zutil.h?
  30
  31 #include <memory.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <assert.h>
  35
  36 using namespace android;
  37
  38 /*
  39  * Some environments require the "b", some choke on it.
  40  */
  41 #define FILE_OPEN_RO        "rb"
  42 #define FILE_OPEN_RW        "r+b"
  43 #define FILE_OPEN_RW_CREATE "w+b"
  44
  45 /* should live somewhere else? */
  46 static status_t errnoToStatus(int err)
  47 {
  48     if (err == ENOENT)
  49         return NAME_NOT_FOUND;
  50     else if (err == EACCES)
  51         return PERMISSION_DENIED;
  52     else
  53         return UNKNOWN_ERROR;
  54 }
  55
  56 /*
  57  * Open a file and parse its guts.
  58  */
  59 status_t ZipFile::open(const char* zipFileName, int flags)
  60 {
  61     bool newArchive = false;
  62
  63     assert(mZipFp == NULL);     // no reopen
  64
  65     if ((flags & kOpenTruncate))
  66         flags |= kOpenCreate;           // trunc implies create
  67
  68     if ((flags & kOpenReadOnly) && (flags & kOpenReadWrite))
  69         return INVALID_OPERATION;       // not both
  70     if (!((flags & kOpenReadOnly) || (flags & kOpenReadWrite)))
  71         return INVALID_OPERATION;       // not neither
  72     if ((flags & kOpenCreate) && !(flags & kOpenReadWrite))
  73         return INVALID_OPERATION;       // create requires write
  74
  75     if (flags & kOpenTruncate) {
  76         newArchive = true;
  77     } else {
  78         newArchive = (access(zipFileName, F_OK) != 0);
  79         if (!(flags & kOpenCreate) && newArchive) {
  80             /* not creating, must already exist */
  81             LOGD("File %s does not exist", zipFileName);
  82             return NAME_NOT_FOUND;
  83         }
  84     }
  85
  86     /* open the file */
  87     const char* openflags;
  88     if (flags & kOpenReadWrite) {
  89         if (newArchive)
  90             openflags = FILE_OPEN_RW_CREATE;
  91         else
  92             openflags = FILE_OPEN_RW;
  93     } else {
  94         openflags = FILE_OPEN_RO;
  95     }
  96     mZipFp = fopen(zipFileName, openflags);
  97     if (mZipFp == NULL) {
  98         int err = errno;
  99         LOGD("fopen failed: %d\n", err);
 100         return errnoToStatus(err);
 101     }
 102
 103     status_t result;
 104     if (!newArchive) {
 105         /*
 106          * Load the central directory.  If that fails, then this probably
 107          * isn't a Zip archive.
 108          */
 109         result = readCentralDir();
 110     } else {
 111         /*
 112          * Newly-created.  The EndOfCentralDir constructor actually
 113          * sets everything to be the way we want it (all zeroes).  We
 114          * set mNeedCDRewrite so that we create *something* if the
 115          * caller doesn't add any files.  (We could also just unlink
 116          * the file if it's brand new and nothing was added, but that's
 117          * probably doing more than we really should -- the user might
 118          * have a need for empty zip files.)
 119          */
 120         mNeedCDRewrite = true;
 121         result = NO_ERROR;
 122     }
 123
 124     if (flags & kOpenReadOnly)
 125         mReadOnly = true;
 126     else
 127         assert(!mReadOnly);
 128
 129     return result;
 130 }
 131
 132 /*
 133  * Return the Nth entry in the archive.
 134  */
 135 ZipEntry* ZipFile::getEntryByIndex(int idx) const
 136 {
 137     if (idx < 0 || idx >= (int) mEntries.size())
 138         return NULL;
 139
 140     return mEntries[idx];
 141 }
 142
 143 /*
 144  * Find an entry by name.
 145  */
 146 ZipEntry* ZipFile::getEntryByName(const char* fileName) const
 147 {
 148     /*
 149      * Do a stupid linear string-compare search.
 150      *
 151      * There are various ways to speed this up, especially since it's rare
 152      * to intermingle changes to the archive with "get by name" calls.  We
 153      * don't want to sort the mEntries vector itself, however, because
 154      * it's used to recreate the Central Directory.
 155      *
 156      * (Hash table works, parallel list of pointers in sorted order is good.)
 157      */
 158     int idx;
 159
 160     for (idx = mEntries.size()-1; idx >= 0; idx--) {
 161         ZipEntry* pEntry = mEntries[idx];
 162         if (!pEntry->getDeleted() &&
 163             strcmp(fileName, pEntry->getFileName()) == 0)
 164         {
 165             return pEntry;
 166         }
 167     }
 168
 169     return NULL;
 170 }
 171
 172 /*
 173  * Empty the mEntries vector.
 174  */
 175 void ZipFile::discardEntries(void)
 176 {
 177     int count = mEntries.size();
 178
 179     while (--count >= 0)
 180         delete mEntries[count];
 181
 182     mEntries.clear();
 183 }
 184
 185
 186 /*
 187  * Find the central directory and read the contents.
 188  *
 189  * The fun thing about ZIP archives is that they may or may not be
 190  * readable from start to end.  In some cases, notably for archives
 191  * that were written to stdout, the only length information is in the
 192  * central directory at the end of the file.
 193  *
 194  * Of course, the central directory can be followed by a variable-length
 195  * comment field, so we have to scan through it backwards.  The comment
 196  * is at most 64K, plus we have 18 bytes for the end-of-central-dir stuff
 197  * itself, plus apparently sometimes people throw random junk on the end
 198  * just for the fun of it.
 199  *
 200  * This is all a little wobbly.  If the wrong value ends up in the EOCD
 201  * area, we're hosed.  This appears to be the way that everbody handles
 202  * it though, so we're in pretty good company if this fails.
 203  */
 204 status_t ZipFile::readCentralDir(void)
 205 {
 206     status_t result = NO_ERROR;
 207     unsigned char* buf = NULL;
 208     off_t fileLength, seekStart;
 209     long readAmount;
 210     int i;
 211
 212     fseek(mZipFp, 0, SEEK_END);
 213     fileLength = ftell(mZipFp);
 214     rewind(mZipFp);
 215
 216     /* too small to be a ZIP archive? */
 217     if (fileLength < EndOfCentralDir::kEOCDLen) {
 218         LOGD("Length is %ld -- too small\n", (long)fileLength);
 219         result = INVALID_OPERATION;
 220         goto bail;
 221     }
 222
 223     buf = new unsigned char[EndOfCentralDir::kMaxEOCDSearch];
 224     if (buf == NULL) {
 225         LOGD("Failure allocating %d bytes for EOCD search",
 226              EndOfCentralDir::kMaxEOCDSearch);
 227         result = NO_MEMORY;
 228         goto bail;
 229     }
 230
 231     if (fileLength > EndOfCentralDir::kMaxEOCDSearch) {
 232         seekStart = fileLength - EndOfCentralDir::kMaxEOCDSearch;
 233         readAmount = EndOfCentralDir::kMaxEOCDSearch;
 234     } else {
 235         seekStart = 0;
 236         readAmount = (long) fileLength;
 237     }
 238     if (fseek(mZipFp, seekStart, SEEK_SET) != 0) {
 239         LOGD("Failure seeking to end of zip at %ld", (long) seekStart);
 240         result = UNKNOWN_ERROR;
 241         goto bail;
 242     }
 243
 244     /* read the last part of the file into the buffer */
 245     if (fread(buf, 1, readAmount, mZipFp) != (size_t) readAmount) {
 246         LOGD("short file? wanted %ld\n", readAmount);
 247         result = UNKNOWN_ERROR;
 248         goto bail;
 249     }
 250
 251     /* find the end-of-central-dir magic */
 252     for (i = readAmount - 4; i >= 0; i--) {
 253         if (buf[i] == 0x50 &&
 254             ZipEntry::getLongLE(&buf[i]) == EndOfCentralDir::kSignature)
 255         {
 256             ALOGV("+++ Found EOCD at buf+%d\n", i);
 257             break;
 258         }
 259     }
 260     if (i < 0) {
 261         LOGD("EOCD not found, not Zip\n");
 262         result = INVALID_OPERATION;
 263         goto bail;
 264     }
 265
 266     /* extract eocd values */
 267     result = mEOCD.readBuf(buf + i, readAmount - i);
 268     if (result != NO_ERROR) {
 269         LOGD("Failure reading %ld bytes of EOCD values", readAmount - i);
 270         goto bail;
 271     }
 272     //mEOCD.dump();
 273
 274     if (mEOCD.mDiskNumber != 0 || mEOCD.mDiskWithCentralDir != 0 ||
 275         mEOCD.mNumEntries != mEOCD.mTotalNumEntries)
 276     {
 277         LOGD("Archive spanning not supported\n");
 278         result = INVALID_OPERATION;
 279         goto bail;
 280     }
 281
 282     /*
 283      * So far so good.  "mCentralDirSize" is the size in bytes of the
 284      * central directory, so we can just seek back that far to find it.
 285      * We can also seek forward mCentralDirOffset bytes from the
 286      * start of the file.
 287      *
 288      * We're not guaranteed to have the rest of the central dir in the
 289      * buffer, nor are we guaranteed that the central dir will have any
 290      * sort of convenient size.  We need to skip to the start of it and
 291      * read the header, then the other goodies.
 292      *
 293      * The only thing we really need right now is the file comment, which
 294      * we're hoping to preserve.
 295      */
 296     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) {
 297         LOGD("Failure seeking to central dir offset %ld\n",
 298              mEOCD.mCentralDirOffset);
 299         result = UNKNOWN_ERROR;
 300         goto bail;
 301     }
 302
 303     /*
 304      * Loop through and read the central dir entries.
 305      */
 306     ALOGV("Scanning %d entries...\n", mEOCD.mTotalNumEntries);
 307     int entry;
 308     for (entry = 0; entry < mEOCD.mTotalNumEntries; entry++) {
 309         ZipEntry* pEntry = new ZipEntry;
 310
 311         result = pEntry->initFromCDE(mZipFp);
 312         if (result != NO_ERROR) {
 313             LOGD("initFromCDE failed\n");
 314             delete pEntry;
 315             goto bail;
 316         }
 317
 318         mEntries.add(pEntry);
 319     }
 320
 321
 322     /*
 323      * If all went well, we should now be back at the EOCD.
 324      */
 325     {
 326         unsigned char checkBuf[4];
 327         if (fread(checkBuf, 1, 4, mZipFp) != 4) {
 328             LOGD("EOCD check read failed\n");
 329             result = INVALID_OPERATION;
 330             goto bail;
 331         }
 332         if (ZipEntry::getLongLE(checkBuf) != EndOfCentralDir::kSignature) {
 333             LOGD("EOCD read check failed\n");
 334             result = UNKNOWN_ERROR;
 335             goto bail;
 336         }
 337         ALOGV("+++ EOCD read check passed\n");
 338     }
 339
 340 bail:
 341     delete[] buf;
 342     return result;
 343 }
 344
 345
 346 /*
 347  * Add a new file to the archive.
 348  *
 349  * This requires creating and populating a ZipEntry structure, and copying
 350  * the data into the file at the appropriate position.  The "appropriate
 351  * position" is the current location of the central directory, which we
 352  * casually overwrite (we can put it back later).
 353  *
 354  * If we were concerned about safety, we would want to make all changes
 355  * in a temp file and then overwrite the original after everything was
 356  * safely written.  Not really a concern for us.
 357  */
 358 status_t ZipFile::addCommon(const char* fileName, const void* data, size_t size,
 359     const char* storageName, int sourceType, int compressionMethod,
 360     ZipEntry** ppEntry)
 361 {
 362     ZipEntry* pEntry = NULL;
 363     status_t result = NO_ERROR;
 364     long lfhPosn, startPosn, endPosn, uncompressedLen;
 365     FILE* inputFp = NULL;
 366     unsigned long crc;
 367     time_t modWhen;
 368
 369     if (mReadOnly)
 370         return INVALID_OPERATION;
 371
 372     assert(compressionMethod == ZipEntry::kCompressDeflated ||
 373            compressionMethod == ZipEntry::kCompressStored);
 374
 375     /* make sure we're in a reasonable state */
 376     assert(mZipFp != NULL);
 377     assert(mEntries.size() == mEOCD.mTotalNumEntries);
 378
 379     /* make sure it doesn't already exist */
 380     if (getEntryByName(storageName) != NULL)
 381         return ALREADY_EXISTS;
 382
 383     if (!data) {
 384         inputFp = fopen(fileName, FILE_OPEN_RO);
 385         if (inputFp == NULL)
 386             return errnoToStatus(errno);
 387     }
 388
 389     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) {
 390         result = UNKNOWN_ERROR;
 391         goto bail;
 392     }
 393
 394     pEntry = new ZipEntry;
 395     pEntry->initNew(storageName, NULL);
 396
 397     /*
 398      * From here on out, failures are more interesting.
 399      */
 400     mNeedCDRewrite = true;
 401
 402     /*
 403      * Write the LFH, even though it's still mostly blank.  We need it
 404      * as a place-holder.  In theory the LFH isn't necessary, but in
 405      * practice some utilities demand it.
 406      */
 407     lfhPosn = ftell(mZipFp);
 408     pEntry->mLFH.write(mZipFp);
 409     startPosn = ftell(mZipFp);
 410
 411     /*
 412      * Copy the data in, possibly compressing it as we go.
 413      */
 414     if (sourceType == ZipEntry::kCompressStored) {
 415         if (compressionMethod == ZipEntry::kCompressDeflated) {
 416             bool failed = false;
 417             result = compressFpToFp(mZipFp, inputFp, data, size, &crc);
 418             if (result != NO_ERROR) {
 419                 LOGD("compression failed, storing\n");
 420                 failed = true;
 421             } else {
 422                 /*
 423                  * Make sure it has compressed "enough".  This probably ought
 424                  * to be set through an API call, but I don't expect our
 425                  * criteria to change over time.
 426                  */
 427                 long src = inputFp ? ftell(inputFp) : size;
 428                 long dst = ftell(mZipFp) - startPosn;
 429                 if (dst + (dst / 10) > src) {
 430                     LOGD("insufficient compression (src=%ld dst=%ld), storing\n",
 431                         src, dst);
 432                     failed = true;
 433                 }
 434             }
 435
 436             if (failed) {
 437                 compressionMethod = ZipEntry::kCompressStored;
 438                 if (inputFp) rewind(inputFp);
 439                 fseek(mZipFp, startPosn, SEEK_SET);
 440                 /* fall through to kCompressStored case */
 441             }
 442         }
 443         /* handle "no compression" request, or failed compression from above */
 444         if (compressionMethod == ZipEntry::kCompressStored) {
 445             if (inputFp) {
 446                 result = copyFpToFp(mZipFp, inputFp, &crc);
 447             } else {
 448                 result = copyDataToFp(mZipFp, data, size, &crc);
 449             }
 450             if (result != NO_ERROR) {
 451                 // don't need to truncate; happens in CDE rewrite
 452                 LOGD("failed copying data in\n");
 453                 goto bail;
 454             }
 455         }
 456
 457         // currently seeked to end of file
 458         uncompressedLen = inputFp ? ftell(inputFp) : size;
 459     } else if (sourceType == ZipEntry::kCompressDeflated) {
 460         /* we should support uncompressed-from-compressed, but it's not
 461          * important right now */
 462         assert(compressionMethod == ZipEntry::kCompressDeflated);
 463
 464         bool scanResult;
 465         int method;
 466         long compressedLen;
 467
 468         scanResult = ZipUtils::examineGzip(inputFp, &method, &uncompressedLen,
 469                         &compressedLen, &crc);
 470         if (!scanResult || method != ZipEntry::kCompressDeflated) {
 471             LOGD("this isn't a deflated gzip file?");
 472             result = UNKNOWN_ERROR;
 473             goto bail;
 474         }
 475
 476         result = copyPartialFpToFp(mZipFp, inputFp, compressedLen, NULL);
 477         if (result != NO_ERROR) {
 478             LOGD("failed copying gzip data in\n");
 479             goto bail;
 480         }
 481     } else {
 482         assert(false);
 483         result = UNKNOWN_ERROR;
 484         goto bail;
 485     }
 486
 487     /*
 488      * We could write the "Data Descriptor", but there doesn't seem to
 489      * be any point since we're going to go back and write the LFH.
 490      *
 491      * Update file offsets.
 492      */
 493     endPosn = ftell(mZipFp);            // seeked to end of compressed data
 494
 495     /*
 496      * Success!  Fill out new values.
 497      */
 498     pEntry->setDataInfo(uncompressedLen, endPosn - startPosn, crc,
 499         compressionMethod);
 500     modWhen = getModTime(inputFp ? fileno(inputFp) : fileno(mZipFp));
 501     pEntry->setModWhen(modWhen);
 502     pEntry->setLFHOffset(lfhPosn);
 503     mEOCD.mNumEntries++;
 504     mEOCD.mTotalNumEntries++;
 505     mEOCD.mCentralDirSize = 0;      // mark invalid; set by flush()
 506     mEOCD.mCentralDirOffset = endPosn;
 507
 508     /*
 509      * Go back and write the LFH.
 510      */
 511     if (fseek(mZipFp, lfhPosn, SEEK_SET) != 0) {
 512         result = UNKNOWN_ERROR;
 513         goto bail;
 514     }
 515     pEntry->mLFH.write(mZipFp);
 516
 517     /*
 518      * Add pEntry to the list.
 519      */
 520     mEntries.add(pEntry);
 521     if (ppEntry != NULL)
 522         *ppEntry = pEntry;
 523     pEntry = NULL;
 524
 525 bail:
 526     if (inputFp != NULL)
 527         fclose(inputFp);
 528     delete pEntry;
 529     return result;
 530 }
 531
 532 /*
 533  * Add an entry by copying it from another zip file.  If "padding" is
 534  * nonzero, the specified number of bytes will be added to the "extra"
 535  * field in the header.
 536  *
 537  * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
 538  */
 539 status_t ZipFile::add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry,
 540     int padding, ZipEntry** ppEntry)
 541 {
 542     ZipEntry* pEntry = NULL;
 543     status_t result;
 544     long lfhPosn, endPosn;
 545
 546     if (mReadOnly)
 547         return INVALID_OPERATION;
 548
 549     /* make sure we're in a reasonable state */
 550     assert(mZipFp != NULL);
 551     assert(mEntries.size() == mEOCD.mTotalNumEntries);
 552
 553     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) {
 554         result = UNKNOWN_ERROR;
 555         goto bail;
 556     }
 557
 558     pEntry = new ZipEntry;
 559     if (pEntry == NULL) {
 560         result = NO_MEMORY;
 561         goto bail;
 562     }
 563
 564     result = pEntry->initFromExternal(pSourceZip, pSourceEntry);
 565     if (result != NO_ERROR)
 566         goto bail;
 567     if (padding != 0) {
 568         result = pEntry->addPadding(padding);
 569         if (result != NO_ERROR)
 570             goto bail;
 571     }
 572
 573     /*
 574      * From here on out, failures are more interesting.
 575      */
 576     mNeedCDRewrite = true;
 577
 578     /*
 579      * Write the LFH.  Since we're not recompressing the data, we already
 580      * have all of the fields filled out.
 581      */
 582     lfhPosn = ftell(mZipFp);
 583     pEntry->mLFH.write(mZipFp);
 584
 585     /*
 586      * Copy the data over.
 587      *
 588      * If the "has data descriptor" flag is set, we want to copy the DD
 589      * fields as well.  This is a fixed-size area immediately following
 590      * the data.
 591      */
 592     if (fseek(pSourceZip->mZipFp, pSourceEntry->getFileOffset(), SEEK_SET) != 0)
 593     {
 594         result = UNKNOWN_ERROR;
 595         goto bail;
 596     }
 597
 598     off_t copyLen;
 599     copyLen = pSourceEntry->getCompressedLen();
 600     if ((pSourceEntry->mLFH.mGPBitFlag & ZipEntry::kUsesDataDescr) != 0)
 601         copyLen += ZipEntry::kDataDescriptorLen;
 602
 603     if (copyPartialFpToFp(mZipFp, pSourceZip->mZipFp, copyLen, NULL)
 604         != NO_ERROR)
 605     {
 606         LOGW("copy of '%s' failed\n", pEntry->mCDE.mFileName);
 607         result = UNKNOWN_ERROR;
 608         goto bail;
 609     }
 610
 611     /*
 612      * Update file offsets.
 613      */
 614     endPosn = ftell(mZipFp);
 615
 616     /*
 617      * Success!  Fill out new values.
 618      */
 619     pEntry->setLFHOffset(lfhPosn);      // sets mCDE.mLocalHeaderRelOffset
 620     mEOCD.mNumEntries++;
 621     mEOCD.mTotalNumEntries++;
 622     mEOCD.mCentralDirSize = 0;      // mark invalid; set by flush()
 623     mEOCD.mCentralDirOffset = endPosn;
 624
 625     /*
 626      * Add pEntry to the list.
 627      */
 628     mEntries.add(pEntry);
 629     if (ppEntry != NULL)
 630         *ppEntry = pEntry;
 631     pEntry = NULL;
 632
 633     result = NO_ERROR;
 634
 635 bail:
 636     delete pEntry;
 637     return result;
 638 }
 639
 640 /*
 641  * Copy all of the bytes in "src" to "dst".
 642  *
 643  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
 644  * will be seeked immediately past the data.
 645  */
 646 status_t ZipFile::copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32)
 647 {
 648     unsigned char tmpBuf[32768];
 649     size_t count;
 650
 651     *pCRC32 = crc32(0L, Z_NULL, 0);
 652
 653     while (1) {
 654         count = fread(tmpBuf, 1, sizeof(tmpBuf), srcFp);
 655         if (ferror(srcFp) || ferror(dstFp))
 656             return errnoToStatus(errno);
 657         if (count == 0)
 658             break;
 659
 660         *pCRC32 = crc32(*pCRC32, tmpBuf, count);
 661
 662         if (fwrite(tmpBuf, 1, count, dstFp) != count) {
 663             LOGD("fwrite %d bytes failed\n", (int) count);
 664             return UNKNOWN_ERROR;
 665         }
 666     }
 667
 668     return NO_ERROR;
 669 }
 670
 671 /*
 672  * Copy all of the bytes in "src" to "dst".
 673  *
 674  * On exit, "dstFp" will be seeked immediately past the data.
 675  */
 676 status_t ZipFile::copyDataToFp(FILE* dstFp,
 677     const void* data, size_t size, unsigned long* pCRC32)
 678 {
 679     size_t count;
 680
 681     *pCRC32 = crc32(0L, Z_NULL, 0);
 682     if (size > 0) {
 683         *pCRC32 = crc32(*pCRC32, (const unsigned char*)data, size);
 684         if (fwrite(data, 1, size, dstFp) != size) {
 685             LOGD("fwrite %d bytes failed\n", (int) size);
 686             return UNKNOWN_ERROR;
 687         }
 688     }
 689
 690     return NO_ERROR;
 691 }
 692
 693 /*
 694  * Copy some of the bytes in "src" to "dst".
 695  *
 696  * If "pCRC32" is NULL, the CRC will not be computed.
 697  *
 698  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
 699  * will be seeked immediately past the data just written.
 700  */
 701 status_t ZipFile::copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length,
 702     unsigned long* pCRC32)
 703 {
 704     unsigned char tmpBuf[32768];
 705     size_t count;
 706
 707     if (pCRC32 != NULL)
 708         *pCRC32 = crc32(0L, Z_NULL, 0);
 709
 710     while (length) {
 711         long readSize;
 712
 713         readSize = sizeof(tmpBuf);
 714         if (readSize > length)
 715             readSize = length;
 716
 717         count = fread(tmpBuf, 1, readSize, srcFp);
 718         if ((long) count != readSize) {     // error or unexpected EOF
 719             LOGD("fread %d bytes failed\n", (int) readSize);
 720             return UNKNOWN_ERROR;
 721         }
 722
 723         if (pCRC32 != NULL)
 724             *pCRC32 = crc32(*pCRC32, tmpBuf, count);
 725
 726         if (fwrite(tmpBuf, 1, count, dstFp) != count) {
 727             LOGD("fwrite %d bytes failed\n", (int) count);
 728             return UNKNOWN_ERROR;
 729         }
 730
 731         length -= readSize;
 732     }
 733
 734     return NO_ERROR;
 735 }
 736
 737 /*
 738  * Compress all of the data in "srcFp" and write it to "dstFp".
 739  *
 740  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
 741  * will be seeked immediately past the compressed data.
 742  */
 743 status_t ZipFile::compressFpToFp(FILE* dstFp, FILE* srcFp,
 744     const void* data, size_t size, unsigned long* pCRC32)
 745 {
 746     status_t result = NO_ERROR;
 747     const size_t kBufSize = 32768;
 748     unsigned char* inBuf = NULL;
 749     unsigned char* outBuf = NULL;
 750     z_stream zstream;
 751     bool atEof = false;     // no feof() aviailable yet
 752     unsigned long crc;
 753     int zerr;
 754
 755     /*
 756      * Create an input buffer and an output buffer.
 757      */
 758     inBuf = new unsigned char[kBufSize];
 759     outBuf = new unsigned char[kBufSize];
 760     if (inBuf == NULL || outBuf == NULL) {
 761         result = NO_MEMORY;
 762         goto bail;
 763     }
 764
 765     /*
 766      * Initialize the zlib stream.
 767      */
 768     memset(&zstream, 0, sizeof(zstream));
 769     zstream.zalloc = Z_NULL;
 770     zstream.zfree = Z_NULL;
 771     zstream.opaque = Z_NULL;
 772     zstream.next_in = NULL;
 773     zstream.avail_in = 0;
 774     zstream.next_out = outBuf;
 775     zstream.avail_out = kBufSize;
 776     zstream.data_type = Z_UNKNOWN;
 777
 778     zerr = deflateInit2(&zstream, Z_BEST_COMPRESSION,
 779         Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
 780     if (zerr != Z_OK) {
 781         result = UNKNOWN_ERROR;
 782         if (zerr == Z_VERSION_ERROR) {
 783             LOGE("Installed zlib is not compatible with linked version (%s)\n",
 784                 ZLIB_VERSION);
 785         } else {
 786             LOGD("Call to deflateInit2 failed (zerr=%d)\n", zerr);
 787         }
 788         goto bail;
 789     }
 790
 791     crc = crc32(0L, Z_NULL, 0);
 792
 793     /*
 794      * Loop while we have data.
 795      */
 796     do {
 797         size_t getSize;
 798         int flush;
 799
 800         /* only read if the input buffer is empty */
 801         if (zstream.avail_in == 0 && !atEof) {
 802             ALOGV("+++ reading %d bytes\n", (int)kBufSize);
 803             if (data) {
 804                 getSize = size > kBufSize ? kBufSize : size;
 805                 memcpy(inBuf, data, getSize);
 806                 data = ((const char*)data) + getSize;
 807                 size -= getSize;
 808             } else {
 809                 getSize = fread(inBuf, 1, kBufSize, srcFp);
 810                 if (ferror(srcFp)) {
 811                     LOGD("deflate read failed (errno=%d)\n", errno);
 812                     goto z_bail;
 813                 }
 814             }
 815             if (getSize < kBufSize) {
 816                 ALOGV("+++  got %d bytes, EOF reached\n",
 817                     (int)getSize);
 818                 atEof = true;
 819             }
 820
 821             crc = crc32(crc, inBuf, getSize);
 822
 823             zstream.next_in = inBuf;
 824             zstream.avail_in = getSize;
 825         }
 826
 827         if (atEof)
 828             flush = Z_FINISH;       /* tell zlib that we're done */
 829         else
 830             flush = Z_NO_FLUSH;     /* more to come! */
 831
 832         zerr = deflate(&zstream, flush);
 833         if (zerr != Z_OK && zerr != Z_STREAM_END) {
 834             LOGD("zlib deflate call failed (zerr=%d)\n", zerr);
 835             result = UNKNOWN_ERROR;
 836             goto z_bail;
 837         }
 838
 839         /* write when we're full or when we're done */
 840         if (zstream.avail_out == 0 ||
 841             (zerr == Z_STREAM_END && zstream.avail_out != (uInt) kBufSize))
 842         {
 843             ALOGV("+++ writing %d bytes\n", (int) (zstream.next_out - outBuf));
 844             if (fwrite(outBuf, 1, zstream.next_out - outBuf, dstFp) !=
 845                 (size_t)(zstream.next_out - outBuf))
 846             {
 847                 LOGD("write %d failed in deflate\n",
 848                     (int) (zstream.next_out - outBuf));
 849                 goto z_bail;
 850             }
 851
 852             zstream.next_out = outBuf;
 853             zstream.avail_out = kBufSize;
 854         }
 855     } while (zerr == Z_OK);
 856
 857     assert(zerr == Z_STREAM_END);       /* other errors should've been caught */
 858
 859     *pCRC32 = crc;
 860
 861 z_bail:
 862     deflateEnd(&zstream);        /* free up any allocated structures */
 863
 864 bail:
 865     delete[] inBuf;
 866     delete[] outBuf;
 867
 868     return result;
 869 }
 870
 871 /*
 872  * Mark an entry as deleted.
 873  *
 874  * We will eventually need to crunch the file down, but if several files
 875  * are being removed (perhaps as part of an "update" process) we can make
 876  * things considerably faster by deferring the removal to "flush" time.
 877  */
 878 status_t ZipFile::remove(ZipEntry* pEntry)
 879 {
 880     /*
 881      * Should verify that pEntry is actually part of this archive, and
 882      * not some stray ZipEntry from a different file.
 883      */
 884
 885     /* mark entry as deleted, and mark archive as dirty */
 886     pEntry->setDeleted();
 887     mNeedCDRewrite = true;
 888     return NO_ERROR;
 889 }
 890
 891 /*
 892  * Flush any pending writes.
 893  *
 894  * In particular, this will crunch out deleted entries, and write the
 895  * Central Directory and EOCD if we have stomped on them.
 896  */
 897 status_t ZipFile::flush(void)
 898 {
 899     status_t result = NO_ERROR;
 900     long eocdPosn;
 901     int i, count;
 902
 903     if (mReadOnly)
 904         return INVALID_OPERATION;
 905     if (!mNeedCDRewrite)
 906         return NO_ERROR;
 907
 908     assert(mZipFp != NULL);
 909
 910     result = crunchArchive();
 911     if (result != NO_ERROR)
 912         return result;
 913
 914     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0)
 915         return UNKNOWN_ERROR;
 916
 917     count = mEntries.size();
 918     for (i = 0; i < count; i++) {
 919         ZipEntry* pEntry = mEntries[i];
 920         pEntry->mCDE.write(mZipFp);
 921     }
 922
 923     eocdPosn = ftell(mZipFp);
 924     mEOCD.mCentralDirSize = eocdPosn - mEOCD.mCentralDirOffset;
 925
 926     mEOCD.write(mZipFp);
 927
 928     /*
 929      * If we had some stuff bloat up during compression and get replaced
 930      * with plain files, or if we deleted some entries, there's a lot
 931      * of wasted space at the end of the file.  Remove it now.
 932      */
 933     if (ftruncate(fileno(mZipFp), ftell(mZipFp)) != 0) {
 934         LOGW("ftruncate failed %ld: %s\n", ftell(mZipFp), strerror(errno));
 935         // not fatal
 936     }
 937
 938     /* should we clear the "newly added" flag in all entries now? */
 939
 940     mNeedCDRewrite = false;
 941     return NO_ERROR;
 942 }
 943
 944 /*
 945  * Crunch deleted files out of an archive by shifting the later files down.
 946  *
 947  * Because we're not using a temp file, we do the operation inside the
 948  * current file.
 949  */
 950 status_t ZipFile::crunchArchive(void)
 951 {
 952     status_t result = NO_ERROR;
 953     int i, count;
 954     long delCount, adjust;
 955
 956 #if 0
 957     printf("CONTENTS:\n");
 958     for (i = 0; i < (int) mEntries.size(); i++) {
 959         printf(" %d: lfhOff=%ld del=%d\n",
 960             i, mEntries[i]->getLFHOffset(), mEntries[i]->getDeleted());
 961     }
 962     printf("  END is %ld\n", (long) mEOCD.mCentralDirOffset);
 963 #endif
 964
 965     /*
 966      * Roll through the set of files, shifting them as appropriate.  We
 967      * could probably get a slight performance improvement by sliding
 968      * multiple files down at once (because we could use larger reads
 969      * when operating on batches of small files), but it's not that useful.
 970      */
 971     count = mEntries.size();
 972     delCount = adjust = 0;
 973     for (i = 0; i < count; i++) {
 974         ZipEntry* pEntry = mEntries[i];
 975         long span;
 976
 977         if (pEntry->getLFHOffset() != 0) {
 978             long nextOffset;
 979
 980             /* Get the length of this entry by finding the offset
 981              * of the next entry.  Directory entries don't have
 982              * file offsets, so we need to find the next non-directory
 983              * entry.
 984              */
 985             nextOffset = 0;
 986             for (int ii = i+1; nextOffset == 0 && ii < count; ii++)
 987                 nextOffset = mEntries[ii]->getLFHOffset();
 988             if (nextOffset == 0)
 989                 nextOffset = mEOCD.mCentralDirOffset;
 990             span = nextOffset - pEntry->getLFHOffset();
 991
 992             assert(span >= ZipEntry::LocalFileHeader::kLFHLen);
 993         } else {
 994             /* This is a directory entry.  It doesn't have
 995              * any actual file contents, so there's no need to
 996              * move anything.
 997              */
 998             span = 0;
 999         }
1000
1001         //printf("+++ %d: off=%ld span=%ld del=%d [count=%d]\n",
1002         //    i, pEntry->getLFHOffset(), span, pEntry->getDeleted(), count);
1003
1004         if (pEntry->getDeleted()) {
1005             adjust += span;
1006             delCount++;
1007
1008             delete pEntry;
1009             mEntries.removeAt(i);
1010
1011             /* adjust loop control */
1012             count--;
1013             i--;
1014         } else if (span != 0 && adjust > 0) {
1015             /* shuffle this entry back */
1016             //printf("+++ Shuffling '%s' back %ld\n",
1017             //    pEntry->getFileName(), adjust);
1018             result = filemove(mZipFp, pEntry->getLFHOffset() - adjust,
1019                         pEntry->getLFHOffset(), span);
1020             if (result != NO_ERROR) {
1021                 /* this is why you use a temp file */
1022                 LOGE("error during crunch - archive is toast\n");
1023                 return result;
1024             }
1025
1026             pEntry->setLFHOffset(pEntry->getLFHOffset() - adjust);
1027         }
1028     }
1029
1030     /*
1031      * Fix EOCD info.  We have to wait until the end to do some of this
1032      * because we use mCentralDirOffset to determine "span" for the
1033      * last entry.
1034      */
1035     mEOCD.mCentralDirOffset -= adjust;
1036     mEOCD.mNumEntries -= delCount;
1037     mEOCD.mTotalNumEntries -= delCount;
1038     mEOCD.mCentralDirSize = 0;  // mark invalid; set by flush()
1039
1040     assert(mEOCD.mNumEntries == mEOCD.mTotalNumEntries);
1041     assert(mEOCD.mNumEntries == count);
1042
1043     return result;
1044 }
1045
1046 /*
1047  * Works like memmove(), but on pieces of a file.
1048  */
1049 status_t ZipFile::filemove(FILE* fp, off_t dst, off_t src, size_t n)
1050 {
1051     if (dst == src || n <= 0)
1052         return NO_ERROR;
1053
1054     unsigned char readBuf[32768];
1055
1056     if (dst < src) {
1057         /* shift stuff toward start of file; must read from start */
1058         while (n != 0) {
1059             size_t getSize = sizeof(readBuf);
1060             if (getSize > n)
1061                 getSize = n;
1062
1063             if (fseek(fp, (long) src, SEEK_SET) != 0) {
1064                 LOGD("filemove src seek %ld failed\n", (long) src);
1065                 return UNKNOWN_ERROR;
1066             }
1067
1068             if (fread(readBuf, 1, getSize, fp) != getSize) {
1069                 LOGD("filemove read %ld off=%ld failed\n",
1070                     (long) getSize, (long) src);
1071                 return UNKNOWN_ERROR;
1072             }
1073
1074             if (fseek(fp, (long) dst, SEEK_SET) != 0) {
1075                 LOGD("filemove dst seek %ld failed\n", (long) dst);
1076                 return UNKNOWN_ERROR;
1077             }
1078
1079             if (fwrite(readBuf, 1, getSize, fp) != getSize) {
1080                 LOGD("filemove write %ld off=%ld failed\n",
1081                     (long) getSize, (long) dst);
1082                 return UNKNOWN_ERROR;
1083             }
1084
1085             src += getSize;
1086             dst += getSize;
1087             n -= getSize;
1088         }
1089     } else {
1090         /* shift stuff toward end of file; must read from end */
1091         assert(false);      // write this someday, maybe
1092         return UNKNOWN_ERROR;
1093     }
1094
1095     return NO_ERROR;
1096 }
1097
1098
1099 /*
1100  * Get the modification time from a file descriptor.
1101  */
1102 time_t ZipFile::getModTime(int fd)
1103 {
1104     struct stat sb;
1105
1106     if (fstat(fd, &sb) < 0) {
1107         LOGD("HEY: fstat on fd %d failed\n", fd);
1108         return (time_t) -1;
1109     }
1110
1111     return sb.st_mtime;
1112 }
1113
1114
1115 #if 0       /* this is a bad idea */
1116 /*
1117  * Get a copy of the Zip file descriptor.
1118  *
1119  * We don't allow this if the file was opened read-write because we tend
1120  * to leave the file contents in an uncertain state between calls to
1121  * flush().  The duplicated file descriptor should only be valid for reads.
1122  */
1123 int ZipFile::getZipFd(void) const
1124 {
1125     if (!mReadOnly)
1126         return INVALID_OPERATION;
1127     assert(mZipFp != NULL);
1128
1129     int fd;
1130     fd = dup(fileno(mZipFp));
1131     if (fd < 0) {
1132         LOGD("didn't work, errno=%d\n", errno);
1133     }
1134
1135     return fd;
1136 }
1137 #endif
1138
1139
1140 #if 0
1141 /*
1142  * Expand data.
1143  */
1144 bool ZipFile::uncompress(const ZipEntry* pEntry, void* buf) const
1145 {
1146     return false;
1147 }
1148 #endif
1149
1150 // free the memory when you're done
1151 void* ZipFile::uncompress(const ZipEntry* entry)
1152 {
1153     size_t unlen = entry->getUncompressedLen();
1154     size_t clen = entry->getCompressedLen();
1155
1156     void* buf = malloc(unlen);
1157     if (buf == NULL) {
1158         return NULL;
1159     }
1160
1161     fseek(mZipFp, 0, SEEK_SET);
1162
1163     off_t offset = entry->getFileOffset();
1164     if (fseek(mZipFp, offset, SEEK_SET) != 0) {
1165         goto bail;
1166     }
1167
1168     switch (entry->getCompressionMethod())
1169     {
1170         case ZipEntry::kCompressStored: {
1171             ssize_t amt = fread(buf, 1, unlen, mZipFp);
1172             if (amt != (ssize_t)unlen) {
1173                 goto bail;
1174             }
1175 #if 0
1176             printf("data...\n");
1177             const unsigned char* p = (unsigned char*)buf;
1178             const unsigned char* end = p+unlen;
1179             for (int i=0; i<32 && p < end; i++) {
1180                 printf("0x%08x ", (int)(offset+(i*0x10)));
1181                 for (int j=0; j<0x10 && p < end; j++) {
1182                     printf(" %02x", *p);
1183                     p++;
1184                 }
1185                 printf("\n");
1186             }
1187 #endif
1188
1189             }
1190             break;
1191         case ZipEntry::kCompressDeflated: {
1192             if (!ZipUtils::inflateToBuffer(mZipFp, buf, unlen, clen)) {
1193                 goto bail;
1194             }
1195             }
1196             break;
1197         default:
1198             goto bail;
1199     }
1200     return buf;
1201
1202 bail:
1203     free(buf);
1204     return NULL;
1205 }
1206
1207
1208 /*
1209  * ===========================================================================
1210  *      ZipFile::EndOfCentralDir
1211  * ===========================================================================
1212  */
1213
1214 /*
1215  * Read the end-of-central-dir fields.
1216  *
1217  * "buf" should be positioned at the EOCD signature, and should contain
1218  * the entire EOCD area including the comment.
1219  */
1220 status_t ZipFile::EndOfCentralDir::readBuf(const unsigned char* buf, int len)
1221 {
1222     /* don't allow re-use */
1223     assert(mComment == NULL);
1224
1225     if (len < kEOCDLen) {
1226         /* looks like ZIP file got truncated */
1227         LOGD(" Zip EOCD: expected >= %d bytes, found %d\n",
1228             kEOCDLen, len);
1229         return INVALID_OPERATION;
1230     }
1231
1232     /* this should probably be an assert() */
1233     if (ZipEntry::getLongLE(&buf[0x00]) != kSignature)
1234         return UNKNOWN_ERROR;
1235
1236     mDiskNumber = ZipEntry::getShortLE(&buf[0x04]);
1237     mDiskWithCentralDir = ZipEntry::getShortLE(&buf[0x06]);
1238     mNumEntries = ZipEntry::getShortLE(&buf[0x08]);
1239     mTotalNumEntries = ZipEntry::getShortLE(&buf[0x0a]);
1240     mCentralDirSize = ZipEntry::getLongLE(&buf[0x0c]);
1241     mCentralDirOffset = ZipEntry::getLongLE(&buf[0x10]);
1242     mCommentLen = ZipEntry::getShortLE(&buf[0x14]);
1243
1244     // TODO: validate mCentralDirOffset
1245
1246     if (mCommentLen > 0) {
1247         if (kEOCDLen + mCommentLen > len) {
1248             LOGD("EOCD(%d) + comment(%d) exceeds len (%d)\n",
1249                 kEOCDLen, mCommentLen, len);
1250             return UNKNOWN_ERROR;
1251         }
1252         mComment = new unsigned char[mCommentLen];
1253         memcpy(mComment, buf + kEOCDLen, mCommentLen);
1254     }
1255
1256     return NO_ERROR;
1257 }
1258
1259 /*
1260  * Write an end-of-central-directory section.
1261  */
1262 status_t ZipFile::EndOfCentralDir::write(FILE* fp)
1263 {
1264     unsigned char buf[kEOCDLen];
1265
1266     ZipEntry::putLongLE(&buf[0x00], kSignature);
1267     ZipEntry::putShortLE(&buf[0x04], mDiskNumber);
1268     ZipEntry::putShortLE(&buf[0x06], mDiskWithCentralDir);
1269     ZipEntry::putShortLE(&buf[0x08], mNumEntries);
1270     ZipEntry::putShortLE(&buf[0x0a], mTotalNumEntries);
1271     ZipEntry::putLongLE(&buf[0x0c], mCentralDirSize);
1272     ZipEntry::putLongLE(&buf[0x10], mCentralDirOffset);
1273     ZipEntry::putShortLE(&buf[0x14], mCommentLen);
1274
1275     if (fwrite(buf, 1, kEOCDLen, fp) != kEOCDLen)
1276         return UNKNOWN_ERROR;
1277     if (mCommentLen > 0) {
1278         assert(mComment != NULL);
1279         if (fwrite(mComment, mCommentLen, 1, fp) != mCommentLen)
1280             return UNKNOWN_ERROR;
1281     }
1282
1283     return NO_ERROR;
1284 }
1285
1286 /*
1287  * Dump the contents of an EndOfCentralDir object.
1288  */
1289 void ZipFile::EndOfCentralDir::dump(void) const
1290 {
1291     LOGD(" EndOfCentralDir contents:\n");
1292     LOGD("  diskNum=%u diskWCD=%u numEnt=%u totalNumEnt=%u\n",
1293         mDiskNumber, mDiskWithCentralDir, mNumEntries, mTotalNumEntries);
1294     LOGD("  centDirSize=%lu centDirOff=%lu commentLen=%u\n",
1295         mCentralDirSize, mCentralDirOffset, mCommentLen);
1296 }
1297