ZipEntry.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 entries in a Zip archive.
  19 //
  20
  21 #define LOG_TAG "zip"
  22
  23 #include "ZipEntry.h"
  24 #include <utils/Log.h>
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <assert.h>
  29
  30 using namespace android;
  31
  32 /*
  33  * Initialize a new ZipEntry structure from a FILE* positioned at a
  34  * CentralDirectoryEntry.
  35  *
  36  * On exit, the file pointer will be at the start of the next CDE or
  37  * at the EOCD.
  38  */
  39 status_t ZipEntry::initFromCDE(FILE* fp)
  40 {
  41     status_t result;
  42     long posn;
  43     bool hasDD;
  44
  45     //LOGV("initFromCDE ---\n");
  46
  47     /* read the CDE */
  48     result = mCDE.read(fp);
  49     if (result != NO_ERROR) {
  50         LOGD("mCDE.read failed\n");
  51         return result;
  52     }
  53
  54     //mCDE.dump();
  55
  56     /* using the info in the CDE, go load up the LFH */
  57     posn = ftell(fp);
  58     if (fseek(fp, mCDE.mLocalHeaderRelOffset, SEEK_SET) != 0) {
  59         LOGD("local header seek failed (%ld)\n",
  60             mCDE.mLocalHeaderRelOffset);
  61         return UNKNOWN_ERROR;
  62     }
  63
  64     result = mLFH.read(fp);
  65     if (result != NO_ERROR) {
  66         LOGD("mLFH.read failed\n");
  67         return result;
  68     }
  69
  70     if (fseek(fp, posn, SEEK_SET) != 0)
  71         return UNKNOWN_ERROR;
  72
  73     //mLFH.dump();
  74
  75     /*
  76      * We *might* need to read the Data Descriptor at this point and
  77      * integrate it into the LFH.  If this bit is set, the CRC-32,
  78      * compressed size, and uncompressed size will be zero.  In practice
  79      * these seem to be rare.
  80      */
  81     hasDD = (mLFH.mGPBitFlag & kUsesDataDescr) != 0;
  82     if (hasDD) {
  83         // do something clever
  84         //LOGD("+++ has data descriptor\n");
  85     }
  86
  87     /*
  88      * Sanity-check the LFH.  Note that this will fail if the "kUsesDataDescr"
  89      * flag is set, because the LFH is incomplete.  (Not a problem, since we
  90      * prefer the CDE values.)
  91      */
  92     if (!hasDD && !compareHeaders()) {
  93         LOGW("warning: header mismatch\n");
  94         // keep going?
  95     }
  96
  97     /*
  98      * If the mVersionToExtract is greater than 20, we may have an
  99      * issue unpacking the record -- could be encrypted, compressed
 100      * with something we don't support, or use Zip64 extensions.  We
 101      * can defer worrying about that to when we're extracting data.
 102      */
 103
 104     return NO_ERROR;
 105 }
 106
 107 /*
 108  * Initialize a new entry.  Pass in the file name and an optional comment.
 109  *
 110  * Initializes the CDE and the LFH.
 111  */
 112 void ZipEntry::initNew(const char* fileName, const char* comment)
 113 {
 114     assert(fileName != NULL && *fileName != '\0');  // name required
 115
 116     /* most fields are properly initialized by constructor */
 117     mCDE.mVersionMadeBy = kDefaultMadeBy;
 118     mCDE.mVersionToExtract = kDefaultVersion;
 119     mCDE.mCompressionMethod = kCompressStored;
 120     mCDE.mFileNameLength = strlen(fileName);
 121     if (comment != NULL)
 122         mCDE.mFileCommentLength = strlen(comment);
 123     mCDE.mExternalAttrs = 0x81b60020;   // matches what WinZip does
 124
 125     if (mCDE.mFileNameLength > 0) {
 126         mCDE.mFileName = new unsigned char[mCDE.mFileNameLength+1];
 127         strcpy((char*) mCDE.mFileName, fileName);
 128     }
 129     if (mCDE.mFileCommentLength > 0) {
 130         /* TODO: stop assuming null-terminated ASCII here? */
 131         mCDE.mFileComment = new unsigned char[mCDE.mFileCommentLength+1];
 132         strcpy((char*) mCDE.mFileComment, comment);
 133     }
 134
 135     copyCDEtoLFH();
 136 }
 137
 138 /*
 139  * Initialize a new entry, starting with the ZipEntry from a different
 140  * archive.
 141  *
 142  * Initializes the CDE and the LFH.
 143  */
 144 status_t ZipEntry::initFromExternal(const ZipFile* pZipFile,
 145     const ZipEntry* pEntry)
 146 {
 147     /*
 148      * Copy everything in the CDE over, then fix up the hairy bits.
 149      */
 150     memcpy(&mCDE, &pEntry->mCDE, sizeof(mCDE));
 151
 152     if (mCDE.mFileNameLength > 0) {
 153         mCDE.mFileName = new unsigned char[mCDE.mFileNameLength+1];
 154         if (mCDE.mFileName == NULL)
 155             return NO_MEMORY;
 156         strcpy((char*) mCDE.mFileName, (char*)pEntry->mCDE.mFileName);
 157     }
 158     if (mCDE.mFileCommentLength > 0) {
 159         mCDE.mFileComment = new unsigned char[mCDE.mFileCommentLength+1];
 160         if (mCDE.mFileComment == NULL)
 161             return NO_MEMORY;
 162         strcpy((char*) mCDE.mFileComment, (char*)pEntry->mCDE.mFileComment);
 163     }
 164     if (mCDE.mExtraFieldLength > 0) {
 165         /* we null-terminate this, though it may not be a string */
 166         mCDE.mExtraField = new unsigned char[mCDE.mExtraFieldLength+1];
 167         if (mCDE.mExtraField == NULL)
 168             return NO_MEMORY;
 169         memcpy(mCDE.mExtraField, pEntry->mCDE.mExtraField,
 170             mCDE.mExtraFieldLength+1);
 171     }
 172
 173     /* construct the LFH from the CDE */
 174     copyCDEtoLFH();
 175
 176     /*
 177      * The LFH "extra" field is independent of the CDE "extra", so we
 178      * handle it here.
 179      */
 180     assert(mLFH.mExtraField == NULL);
 181     mLFH.mExtraFieldLength = pEntry->mLFH.mExtraFieldLength;
 182     if (mLFH.mExtraFieldLength > 0) {
 183         mLFH.mExtraField = new unsigned char[mLFH.mExtraFieldLength+1];
 184         if (mLFH.mExtraField == NULL)
 185             return NO_MEMORY;
 186         memcpy(mLFH.mExtraField, pEntry->mLFH.mExtraField,
 187             mLFH.mExtraFieldLength+1);
 188     }
 189
 190     return NO_ERROR;
 191 }
 192
 193 /*
 194  * Insert pad bytes in the LFH by tweaking the "extra" field.  This will
 195  * potentially confuse something that put "extra" data in here earlier,
 196  * but I can't find an actual problem.
 197  */
 198 status_t ZipEntry::addPadding(int padding)
 199 {
 200     if (padding <= 0)
 201         return INVALID_OPERATION;
 202
 203     //LOGI("HEY: adding %d pad bytes to existing %d in %s\n",
 204     //    padding, mLFH.mExtraFieldLength, mCDE.mFileName);
 205
 206     if (mLFH.mExtraFieldLength > 0) {
 207         /* extend existing field */
 208         unsigned char* newExtra;
 209
 210         newExtra = new unsigned char[mLFH.mExtraFieldLength + padding];
 211         if (newExtra == NULL)
 212             return NO_MEMORY;
 213         memset(newExtra + mLFH.mExtraFieldLength, 0, padding);
 214         memcpy(newExtra, mLFH.mExtraField, mLFH.mExtraFieldLength);
 215
 216         delete[] mLFH.mExtraField;
 217         mLFH.mExtraField = newExtra;
 218         mLFH.mExtraFieldLength += padding;
 219     } else {
 220         /* create new field */
 221         mLFH.mExtraField = new unsigned char[padding];
 222         memset(mLFH.mExtraField, 0, padding);
 223         mLFH.mExtraFieldLength = padding;
 224     }
 225
 226     return NO_ERROR;
 227 }
 228
 229 /*
 230  * Set the fields in the LFH equal to the corresponding fields in the CDE.
 231  *
 232  * This does not touch the LFH "extra" field.
 233  */
 234 void ZipEntry::copyCDEtoLFH(void)
 235 {
 236     mLFH.mVersionToExtract  = mCDE.mVersionToExtract;
 237     mLFH.mGPBitFlag         = mCDE.mGPBitFlag;
 238     mLFH.mCompressionMethod = mCDE.mCompressionMethod;
 239     mLFH.mLastModFileTime   = mCDE.mLastModFileTime;
 240     mLFH.mLastModFileDate   = mCDE.mLastModFileDate;
 241     mLFH.mCRC32             = mCDE.mCRC32;
 242     mLFH.mCompressedSize    = mCDE.mCompressedSize;
 243     mLFH.mUncompressedSize  = mCDE.mUncompressedSize;
 244     mLFH.mFileNameLength    = mCDE.mFileNameLength;
 245     // the "extra field" is independent
 246
 247     delete[] mLFH.mFileName;
 248     if (mLFH.mFileNameLength > 0) {
 249         mLFH.mFileName = new unsigned char[mLFH.mFileNameLength+1];
 250         strcpy((char*) mLFH.mFileName, (const char*) mCDE.mFileName);
 251     } else {
 252         mLFH.mFileName = NULL;
 253     }
 254 }
 255
 256 /*
 257  * Set some information about a file after we add it.
 258  */
 259 void ZipEntry::setDataInfo(long uncompLen, long compLen, unsigned long crc32,
 260     int compressionMethod)
 261 {
 262     mCDE.mCompressionMethod = compressionMethod;
 263     mCDE.mCRC32 = crc32;
 264     mCDE.mCompressedSize = compLen;
 265     mCDE.mUncompressedSize = uncompLen;
 266     mCDE.mCompressionMethod = compressionMethod;
 267     if (compressionMethod == kCompressDeflated) {
 268         mCDE.mGPBitFlag |= 0x0002;      // indicates maximum compression used
 269     }
 270     copyCDEtoLFH();
 271 }
 272
 273 /*
 274  * See if the data in mCDE and mLFH match up.  This is mostly useful for
 275  * debugging these classes, but it can be used to identify damaged
 276  * archives.
 277  *
 278  * Returns "false" if they differ.
 279  */
 280 bool ZipEntry::compareHeaders(void) const
 281 {
 282     if (mCDE.mVersionToExtract != mLFH.mVersionToExtract) {
 283         LOGV("cmp: VersionToExtract\n");
 284         return false;
 285     }
 286     if (mCDE.mGPBitFlag != mLFH.mGPBitFlag) {
 287         LOGV("cmp: GPBitFlag\n");
 288         return false;
 289     }
 290     if (mCDE.mCompressionMethod != mLFH.mCompressionMethod) {
 291         LOGV("cmp: CompressionMethod\n");
 292         return false;
 293     }
 294     if (mCDE.mLastModFileTime != mLFH.mLastModFileTime) {
 295         LOGV("cmp: LastModFileTime\n");
 296         return false;
 297     }
 298     if (mCDE.mLastModFileDate != mLFH.mLastModFileDate) {
 299         LOGV("cmp: LastModFileDate\n");
 300         return false;
 301     }
 302     if (mCDE.mCRC32 != mLFH.mCRC32) {
 303         LOGV("cmp: CRC32\n");
 304         return false;
 305     }
 306     if (mCDE.mCompressedSize != mLFH.mCompressedSize) {
 307         LOGV("cmp: CompressedSize\n");
 308         return false;
 309     }
 310     if (mCDE.mUncompressedSize != mLFH.mUncompressedSize) {
 311         LOGV("cmp: UncompressedSize\n");
 312         return false;
 313     }
 314     if (mCDE.mFileNameLength != mLFH.mFileNameLength) {
 315         LOGV("cmp: FileNameLength\n");
 316         return false;
 317     }
 318 #if 0       // this seems to be used for padding, not real data
 319     if (mCDE.mExtraFieldLength != mLFH.mExtraFieldLength) {
 320         LOGV("cmp: ExtraFieldLength\n");
 321         return false;
 322     }
 323 #endif
 324     if (mCDE.mFileName != NULL) {
 325         if (strcmp((char*) mCDE.mFileName, (char*) mLFH.mFileName) != 0) {
 326             LOGV("cmp: FileName\n");
 327             return false;
 328         }
 329     }
 330
 331     return true;
 332 }
 333
 334
 335 /*
 336  * Convert the DOS date/time stamp into a UNIX time stamp.
 337  */
 338 time_t ZipEntry::getModWhen(void) const
 339 {
 340     struct tm parts;
 341
 342     parts.tm_sec = (mCDE.mLastModFileTime & 0x001f) << 1;
 343     parts.tm_min = (mCDE.mLastModFileTime & 0x07e0) >> 5;
 344     parts.tm_hour = (mCDE.mLastModFileTime & 0xf800) >> 11;
 345     parts.tm_mday = (mCDE.mLastModFileDate & 0x001f);
 346     parts.tm_mon = ((mCDE.mLastModFileDate & 0x01e0) >> 5) -1;
 347     parts.tm_year = ((mCDE.mLastModFileDate & 0xfe00) >> 9) + 80;
 348     parts.tm_wday = parts.tm_yday = 0;
 349     parts.tm_isdst = -1;        // DST info "not available"
 350
 351     return mktime(&parts);
 352 }
 353
 354 /*
 355  * Set the CDE/LFH timestamp from UNIX time.
 356  */
 357 void ZipEntry::setModWhen(time_t when)
 358 {
 359 #ifdef HAVE_LOCALTIME_R
 360     struct tm tmResult;
 361 #endif
 362     time_t even;
 363     unsigned short zdate, ztime;
 364
 365     struct tm* ptm;
 366
 367     /* round up to an even number of seconds */
 368     even = (time_t)(((unsigned long)(when) + 1) & (~1));
 369
 370     /* expand */
 371 #ifdef HAVE_LOCALTIME_R
 372     ptm = localtime_r(&even, &tmResult);
 373 #else
 374     ptm = localtime(&even);
 375 #endif
 376
 377     int year;
 378     year = ptm->tm_year;
 379     if (year < 80)
 380         year = 80;
 381
 382     zdate = (year - 80) << 9 | (ptm->tm_mon+1) << 5 | ptm->tm_mday;
 383     ztime = ptm->tm_hour << 11 | ptm->tm_min << 5 | ptm->tm_sec >> 1;
 384
 385     mCDE.mLastModFileTime = mLFH.mLastModFileTime = ztime;
 386     mCDE.mLastModFileDate = mLFH.mLastModFileDate = zdate;
 387 }
 388
 389
 390 /*
 391  * ===========================================================================
 392  *      ZipEntry::LocalFileHeader
 393  * ===========================================================================
 394  */
 395
 396 /*
 397  * Read a local file header.
 398  *
 399  * On entry, "fp" points to the signature at the start of the header.
 400  * On exit, "fp" points to the start of data.
 401  */
 402 status_t ZipEntry::LocalFileHeader::read(FILE* fp)
 403 {
 404     status_t result = NO_ERROR;
 405     unsigned char buf[kLFHLen];
 406
 407     assert(mFileName == NULL);
 408     assert(mExtraField == NULL);
 409
 410     if (fread(buf, 1, kLFHLen, fp) != kLFHLen) {
 411         result = UNKNOWN_ERROR;
 412         goto bail;
 413     }
 414
 415     if (ZipEntry::getLongLE(&buf[0x00]) != kSignature) {
 416         LOGD("whoops: didn't find expected signature\n");
 417         result = UNKNOWN_ERROR;
 418         goto bail;
 419     }
 420
 421     mVersionToExtract = ZipEntry::getShortLE(&buf[0x04]);
 422     mGPBitFlag = ZipEntry::getShortLE(&buf[0x06]);
 423     mCompressionMethod = ZipEntry::getShortLE(&buf[0x08]);
 424     mLastModFileTime = ZipEntry::getShortLE(&buf[0x0a]);
 425     mLastModFileDate = ZipEntry::getShortLE(&buf[0x0c]);
 426     mCRC32 = ZipEntry::getLongLE(&buf[0x0e]);
 427     mCompressedSize = ZipEntry::getLongLE(&buf[0x12]);
 428     mUncompressedSize = ZipEntry::getLongLE(&buf[0x16]);
 429     mFileNameLength = ZipEntry::getShortLE(&buf[0x1a]);
 430     mExtraFieldLength = ZipEntry::getShortLE(&buf[0x1c]);
 431
 432     // TODO: validate sizes
 433
 434     /* grab filename */
 435     if (mFileNameLength != 0) {
 436         mFileName = new unsigned char[mFileNameLength+1];
 437         if (mFileName == NULL) {
 438             result = NO_MEMORY;
 439             goto bail;
 440         }
 441         if (fread(mFileName, 1, mFileNameLength, fp) != mFileNameLength) {
 442             result = UNKNOWN_ERROR;
 443             goto bail;
 444         }
 445         mFileName[mFileNameLength] = '\0';
 446     }
 447
 448     /* grab extra field */
 449     if (mExtraFieldLength != 0) {
 450         mExtraField = new unsigned char[mExtraFieldLength+1];
 451         if (mExtraField == NULL) {
 452             result = NO_MEMORY;
 453             goto bail;
 454         }
 455         if (fread(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) {
 456             result = UNKNOWN_ERROR;
 457             goto bail;
 458         }
 459         mExtraField[mExtraFieldLength] = '\0';
 460     }
 461
 462 bail:
 463     return result;
 464 }
 465
 466 /*
 467  * Write a local file header.
 468  */
 469 status_t ZipEntry::LocalFileHeader::write(FILE* fp)
 470 {
 471     unsigned char buf[kLFHLen];
 472
 473     ZipEntry::putLongLE(&buf[0x00], kSignature);
 474     ZipEntry::putShortLE(&buf[0x04], mVersionToExtract);
 475     ZipEntry::putShortLE(&buf[0x06], mGPBitFlag);
 476     ZipEntry::putShortLE(&buf[0x08], mCompressionMethod);
 477     ZipEntry::putShortLE(&buf[0x0a], mLastModFileTime);
 478     ZipEntry::putShortLE(&buf[0x0c], mLastModFileDate);
 479     ZipEntry::putLongLE(&buf[0x0e], mCRC32);
 480     ZipEntry::putLongLE(&buf[0x12], mCompressedSize);
 481     ZipEntry::putLongLE(&buf[0x16], mUncompressedSize);
 482     ZipEntry::putShortLE(&buf[0x1a], mFileNameLength);
 483     ZipEntry::putShortLE(&buf[0x1c], mExtraFieldLength);
 484
 485     if (fwrite(buf, 1, kLFHLen, fp) != kLFHLen)
 486         return UNKNOWN_ERROR;
 487
 488     /* write filename */
 489     if (mFileNameLength != 0) {
 490         if (fwrite(mFileName, 1, mFileNameLength, fp) != mFileNameLength)
 491             return UNKNOWN_ERROR;
 492     }
 493
 494     /* write "extra field" */
 495     if (mExtraFieldLength != 0) {
 496         if (fwrite(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength)
 497             return UNKNOWN_ERROR;
 498     }
 499
 500     return NO_ERROR;
 501 }
 502
 503
 504 /*
 505  * Dump the contents of a LocalFileHeader object.
 506  */
 507 void ZipEntry::LocalFileHeader::dump(void) const
 508 {
 509     LOGD(" LocalFileHeader contents:\n");
 510     LOGD("  versToExt=%u gpBits=0x%04x compression=%u\n",
 511         mVersionToExtract, mGPBitFlag, mCompressionMethod);
 512     LOGD("  modTime=0x%04x modDate=0x%04x crc32=0x%08lx\n",
 513         mLastModFileTime, mLastModFileDate, mCRC32);
 514     LOGD("  compressedSize=%lu uncompressedSize=%lu\n",
 515         mCompressedSize, mUncompressedSize);
 516     LOGD("  filenameLen=%u extraLen=%u\n",
 517         mFileNameLength, mExtraFieldLength);
 518     if (mFileName != NULL)
 519         LOGD("  filename: '%s'\n", mFileName);
 520 }
 521
 522
 523 /*
 524  * ===========================================================================
 525  *      ZipEntry::CentralDirEntry
 526  * ===========================================================================
 527  */
 528
 529 /*
 530  * Read the central dir entry that appears next in the file.
 531  *
 532  * On entry, "fp" should be positioned on the signature bytes for the
 533  * entry.  On exit, "fp" will point at the signature word for the next
 534  * entry or for the EOCD.
 535  */
 536 status_t ZipEntry::CentralDirEntry::read(FILE* fp)
 537 {
 538     status_t result = NO_ERROR;
 539     unsigned char buf[kCDELen];
 540
 541     /* no re-use */
 542     assert(mFileName == NULL);
 543     assert(mExtraField == NULL);
 544     assert(mFileComment == NULL);
 545
 546     if (fread(buf, 1, kCDELen, fp) != kCDELen) {
 547         result = UNKNOWN_ERROR;
 548         goto bail;
 549     }
 550
 551     if (ZipEntry::getLongLE(&buf[0x00]) != kSignature) {
 552         LOGD("Whoops: didn't find expected signature\n");
 553         result = UNKNOWN_ERROR;
 554         goto bail;
 555     }
 556
 557     mVersionMadeBy = ZipEntry::getShortLE(&buf[0x04]);
 558     mVersionToExtract = ZipEntry::getShortLE(&buf[0x06]);
 559     mGPBitFlag = ZipEntry::getShortLE(&buf[0x08]);
 560     mCompressionMethod = ZipEntry::getShortLE(&buf[0x0a]);
 561     mLastModFileTime = ZipEntry::getShortLE(&buf[0x0c]);
 562     mLastModFileDate = ZipEntry::getShortLE(&buf[0x0e]);
 563     mCRC32 = ZipEntry::getLongLE(&buf[0x10]);
 564     mCompressedSize = ZipEntry::getLongLE(&buf[0x14]);
 565     mUncompressedSize = ZipEntry::getLongLE(&buf[0x18]);
 566     mFileNameLength = ZipEntry::getShortLE(&buf[0x1c]);
 567     mExtraFieldLength = ZipEntry::getShortLE(&buf[0x1e]);
 568     mFileCommentLength = ZipEntry::getShortLE(&buf[0x20]);
 569     mDiskNumberStart = ZipEntry::getShortLE(&buf[0x22]);
 570     mInternalAttrs = ZipEntry::getShortLE(&buf[0x24]);
 571     mExternalAttrs = ZipEntry::getLongLE(&buf[0x26]);
 572     mLocalHeaderRelOffset = ZipEntry::getLongLE(&buf[0x2a]);
 573
 574     // TODO: validate sizes and offsets
 575
 576     /* grab filename */
 577     if (mFileNameLength != 0) {
 578         mFileName = new unsigned char[mFileNameLength+1];
 579         if (mFileName == NULL) {
 580             result = NO_MEMORY;
 581             goto bail;
 582         }
 583         if (fread(mFileName, 1, mFileNameLength, fp) != mFileNameLength) {
 584             result = UNKNOWN_ERROR;
 585             goto bail;
 586         }
 587         mFileName[mFileNameLength] = '\0';
 588     }
 589
 590     /* read "extra field" */
 591     if (mExtraFieldLength != 0) {
 592         mExtraField = new unsigned char[mExtraFieldLength+1];
 593         if (mExtraField == NULL) {
 594             result = NO_MEMORY;
 595             goto bail;
 596         }
 597         if (fread(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) {
 598             result = UNKNOWN_ERROR;
 599             goto bail;
 600         }
 601         mExtraField[mExtraFieldLength] = '\0';
 602     }
 603
 604
 605     /* grab comment, if any */
 606     if (mFileCommentLength != 0) {
 607         mFileComment = new unsigned char[mFileCommentLength+1];
 608         if (mFileComment == NULL) {
 609             result = NO_MEMORY;
 610             goto bail;
 611         }
 612         if (fread(mFileComment, 1, mFileCommentLength, fp) != mFileCommentLength)
 613         {
 614             result = UNKNOWN_ERROR;
 615             goto bail;
 616         }
 617         mFileComment[mFileCommentLength] = '\0';
 618     }
 619
 620 bail:
 621     return result;
 622 }
 623
 624 /*
 625  * Write a central dir entry.
 626  */
 627 status_t ZipEntry::CentralDirEntry::write(FILE* fp)
 628 {
 629     unsigned char buf[kCDELen];
 630
 631     ZipEntry::putLongLE(&buf[0x00], kSignature);
 632     ZipEntry::putShortLE(&buf[0x04], mVersionMadeBy);
 633     ZipEntry::putShortLE(&buf[0x06], mVersionToExtract);
 634     ZipEntry::putShortLE(&buf[0x08], mGPBitFlag);
 635     ZipEntry::putShortLE(&buf[0x0a], mCompressionMethod);
 636     ZipEntry::putShortLE(&buf[0x0c], mLastModFileTime);
 637     ZipEntry::putShortLE(&buf[0x0e], mLastModFileDate);
 638     ZipEntry::putLongLE(&buf[0x10], mCRC32);
 639     ZipEntry::putLongLE(&buf[0x14], mCompressedSize);
 640     ZipEntry::putLongLE(&buf[0x18], mUncompressedSize);
 641     ZipEntry::putShortLE(&buf[0x1c], mFileNameLength);
 642     ZipEntry::putShortLE(&buf[0x1e], mExtraFieldLength);
 643     ZipEntry::putShortLE(&buf[0x20], mFileCommentLength);
 644     ZipEntry::putShortLE(&buf[0x22], mDiskNumberStart);
 645     ZipEntry::putShortLE(&buf[0x24], mInternalAttrs);
 646     ZipEntry::putLongLE(&buf[0x26], mExternalAttrs);
 647     ZipEntry::putLongLE(&buf[0x2a], mLocalHeaderRelOffset);
 648
 649     if (fwrite(buf, 1, kCDELen, fp) != kCDELen)
 650         return UNKNOWN_ERROR;
 651
 652     /* write filename */
 653     if (mFileNameLength != 0) {
 654         if (fwrite(mFileName, 1, mFileNameLength, fp) != mFileNameLength)
 655             return UNKNOWN_ERROR;
 656     }
 657
 658     /* write "extra field" */
 659     if (mExtraFieldLength != 0) {
 660         if (fwrite(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength)
 661             return UNKNOWN_ERROR;
 662     }
 663
 664     /* write comment */
 665     if (mFileCommentLength != 0) {
 666         if (fwrite(mFileComment, 1, mFileCommentLength, fp) != mFileCommentLength)
 667             return UNKNOWN_ERROR;
 668     }
 669
 670     return NO_ERROR;
 671 }
 672
 673 /*
 674  * Dump the contents of a CentralDirEntry object.
 675  */
 676 void ZipEntry::CentralDirEntry::dump(void) const
 677 {
 678     LOGD(" CentralDirEntry contents:\n");
 679     LOGD("  versMadeBy=%u versToExt=%u gpBits=0x%04x compression=%u\n",
 680         mVersionMadeBy, mVersionToExtract, mGPBitFlag, mCompressionMethod);
 681     LOGD("  modTime=0x%04x modDate=0x%04x crc32=0x%08lx\n",
 682         mLastModFileTime, mLastModFileDate, mCRC32);
 683     LOGD("  compressedSize=%lu uncompressedSize=%lu\n",
 684         mCompressedSize, mUncompressedSize);
 685     LOGD("  filenameLen=%u extraLen=%u commentLen=%u\n",
 686         mFileNameLength, mExtraFieldLength, mFileCommentLength);
 687     LOGD("  diskNumStart=%u intAttr=0x%04x extAttr=0x%08lx relOffset=%lu\n",
 688         mDiskNumberStart, mInternalAttrs, mExternalAttrs,
 689         mLocalHeaderRelOffset);
 690
 691     if (mFileName != NULL)
 692         LOGD("  filename: '%s'\n", mFileName);
 693     if (mFileComment != NULL)
 694         LOGD("  comment: '%s'\n", mFileComment);
 695 }
 696