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 <androidfw/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? */
errnoToStatus(int err)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  */
open(const char * zipFileName,int flags)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             ALOGD("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         ALOGD("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  */
getEntryByIndex(int idx) const135 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  */
getEntryByName(const char * fileName) const146 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  */
discardEntries(void)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  */
readCentralDir(void)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         ALOGD("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         ALOGD("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         ALOGD("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         ALOGD("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         ALOGD("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         ALOGD("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         ALOGD("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         ALOGD("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             ALOGD("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             ALOGD("EOCD check read failed\n");
329             result = INVALID_OPERATION;
330             goto bail;
331         }
332         if (ZipEntry::getLongLE(checkBuf) != EndOfCentralDir::kSignature) {
333             ALOGD("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  */
addCommon(const char * fileName,const void * data,size_t size,const char * storageName,int sourceType,int compressionMethod,ZipEntry ** ppEntry)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 = 0;
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                 ALOGD("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                     ALOGD("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                 ALOGD("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             ALOGD("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             ALOGD("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     pEntry->setModWhen(modWhen);
501     pEntry->setLFHOffset(lfhPosn);
502     mEOCD.mNumEntries++;
503     mEOCD.mTotalNumEntries++;
504     mEOCD.mCentralDirSize = 0;      // mark invalid; set by flush()
505     mEOCD.mCentralDirOffset = endPosn;
506 
507     /*
508      * Go back and write the LFH.
509      */
510     if (fseek(mZipFp, lfhPosn, SEEK_SET) != 0) {
511         result = UNKNOWN_ERROR;
512         goto bail;
513     }
514     pEntry->mLFH.write(mZipFp);
515 
516     /*
517      * Add pEntry to the list.
518      */
519     mEntries.add(pEntry);
520     if (ppEntry != NULL)
521         *ppEntry = pEntry;
522     pEntry = NULL;
523 
524 bail:
525     if (inputFp != NULL)
526         fclose(inputFp);
527     delete pEntry;
528     return result;
529 }
530 
531 /*
532  * Add an entry by copying it from another zip file.  If "padding" is
533  * nonzero, the specified number of bytes will be added to the "extra"
534  * field in the header.
535  *
536  * If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
537  */
add(const ZipFile * pSourceZip,const ZipEntry * pSourceEntry,int padding,ZipEntry ** ppEntry)538 status_t ZipFile::add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry,
539     int padding, ZipEntry** ppEntry)
540 {
541     ZipEntry* pEntry = NULL;
542     status_t result;
543     long lfhPosn, endPosn;
544 
545     if (mReadOnly)
546         return INVALID_OPERATION;
547 
548     /* make sure we're in a reasonable state */
549     assert(mZipFp != NULL);
550     assert(mEntries.size() == mEOCD.mTotalNumEntries);
551 
552     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) {
553         result = UNKNOWN_ERROR;
554         goto bail;
555     }
556 
557     pEntry = new ZipEntry;
558     if (pEntry == NULL) {
559         result = NO_MEMORY;
560         goto bail;
561     }
562 
563     result = pEntry->initFromExternal(pSourceZip, pSourceEntry);
564     if (result != NO_ERROR)
565         goto bail;
566     if (padding != 0) {
567         result = pEntry->addPadding(padding);
568         if (result != NO_ERROR)
569             goto bail;
570     }
571 
572     /*
573      * From here on out, failures are more interesting.
574      */
575     mNeedCDRewrite = true;
576 
577     /*
578      * Write the LFH.  Since we're not recompressing the data, we already
579      * have all of the fields filled out.
580      */
581     lfhPosn = ftell(mZipFp);
582     pEntry->mLFH.write(mZipFp);
583 
584     /*
585      * Copy the data over.
586      *
587      * If the "has data descriptor" flag is set, we want to copy the DD
588      * fields as well.  This is a fixed-size area immediately following
589      * the data.
590      */
591     if (fseek(pSourceZip->mZipFp, pSourceEntry->getFileOffset(), SEEK_SET) != 0)
592     {
593         result = UNKNOWN_ERROR;
594         goto bail;
595     }
596 
597     off_t copyLen;
598     copyLen = pSourceEntry->getCompressedLen();
599     if ((pSourceEntry->mLFH.mGPBitFlag & ZipEntry::kUsesDataDescr) != 0)
600         copyLen += ZipEntry::kDataDescriptorLen;
601 
602     if (copyPartialFpToFp(mZipFp, pSourceZip->mZipFp, copyLen, NULL)
603         != NO_ERROR)
604     {
605         ALOGW("copy of '%s' failed\n", pEntry->mCDE.mFileName);
606         result = UNKNOWN_ERROR;
607         goto bail;
608     }
609 
610     /*
611      * Update file offsets.
612      */
613     endPosn = ftell(mZipFp);
614 
615     /*
616      * Success!  Fill out new values.
617      */
618     pEntry->setLFHOffset(lfhPosn);      // sets mCDE.mLocalHeaderRelOffset
619     mEOCD.mNumEntries++;
620     mEOCD.mTotalNumEntries++;
621     mEOCD.mCentralDirSize = 0;      // mark invalid; set by flush()
622     mEOCD.mCentralDirOffset = endPosn;
623 
624     /*
625      * Add pEntry to the list.
626      */
627     mEntries.add(pEntry);
628     if (ppEntry != NULL)
629         *ppEntry = pEntry;
630     pEntry = NULL;
631 
632     result = NO_ERROR;
633 
634 bail:
635     delete pEntry;
636     return result;
637 }
638 
639 /*
640  * Copy all of the bytes in "src" to "dst".
641  *
642  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
643  * will be seeked immediately past the data.
644  */
copyFpToFp(FILE * dstFp,FILE * srcFp,unsigned long * pCRC32)645 status_t ZipFile::copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32)
646 {
647     unsigned char tmpBuf[32768];
648     size_t count;
649 
650     *pCRC32 = crc32(0L, Z_NULL, 0);
651 
652     while (1) {
653         count = fread(tmpBuf, 1, sizeof(tmpBuf), srcFp);
654         if (ferror(srcFp) || ferror(dstFp))
655             return errnoToStatus(errno);
656         if (count == 0)
657             break;
658 
659         *pCRC32 = crc32(*pCRC32, tmpBuf, count);
660 
661         if (fwrite(tmpBuf, 1, count, dstFp) != count) {
662             ALOGD("fwrite %d bytes failed\n", (int) count);
663             return UNKNOWN_ERROR;
664         }
665     }
666 
667     return NO_ERROR;
668 }
669 
670 /*
671  * Copy all of the bytes in "src" to "dst".
672  *
673  * On exit, "dstFp" will be seeked immediately past the data.
674  */
copyDataToFp(FILE * dstFp,const void * data,size_t size,unsigned long * pCRC32)675 status_t ZipFile::copyDataToFp(FILE* dstFp,
676     const void* data, size_t size, unsigned long* pCRC32)
677 {
678     *pCRC32 = crc32(0L, Z_NULL, 0);
679     if (size > 0) {
680         *pCRC32 = crc32(*pCRC32, (const unsigned char*)data, size);
681         if (fwrite(data, 1, size, dstFp) != size) {
682             ALOGD("fwrite %d bytes failed\n", (int) size);
683             return UNKNOWN_ERROR;
684         }
685     }
686 
687     return NO_ERROR;
688 }
689 
690 /*
691  * Copy some of the bytes in "src" to "dst".
692  *
693  * If "pCRC32" is NULL, the CRC will not be computed.
694  *
695  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
696  * will be seeked immediately past the data just written.
697  */
copyPartialFpToFp(FILE * dstFp,FILE * srcFp,long length,unsigned long * pCRC32)698 status_t ZipFile::copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length,
699     unsigned long* pCRC32)
700 {
701     unsigned char tmpBuf[32768];
702     size_t count;
703 
704     if (pCRC32 != NULL)
705         *pCRC32 = crc32(0L, Z_NULL, 0);
706 
707     while (length) {
708         long readSize;
709 
710         readSize = sizeof(tmpBuf);
711         if (readSize > length)
712             readSize = length;
713 
714         count = fread(tmpBuf, 1, readSize, srcFp);
715         if ((long) count != readSize) {     // error or unexpected EOF
716             ALOGD("fread %d bytes failed\n", (int) readSize);
717             return UNKNOWN_ERROR;
718         }
719 
720         if (pCRC32 != NULL)
721             *pCRC32 = crc32(*pCRC32, tmpBuf, count);
722 
723         if (fwrite(tmpBuf, 1, count, dstFp) != count) {
724             ALOGD("fwrite %d bytes failed\n", (int) count);
725             return UNKNOWN_ERROR;
726         }
727 
728         length -= readSize;
729     }
730 
731     return NO_ERROR;
732 }
733 
734 /*
735  * Compress all of the data in "srcFp" and write it to "dstFp".
736  *
737  * On exit, "srcFp" will be seeked to the end of the file, and "dstFp"
738  * will be seeked immediately past the compressed data.
739  */
compressFpToFp(FILE * dstFp,FILE * srcFp,const void * data,size_t size,unsigned long * pCRC32)740 status_t ZipFile::compressFpToFp(FILE* dstFp, FILE* srcFp,
741     const void* data, size_t size, unsigned long* pCRC32)
742 {
743     status_t result = NO_ERROR;
744     const size_t kBufSize = 32768;
745     unsigned char* inBuf = NULL;
746     unsigned char* outBuf = NULL;
747     z_stream zstream;
748     bool atEof = false;     // no feof() aviailable yet
749     unsigned long crc;
750     int zerr;
751 
752     /*
753      * Create an input buffer and an output buffer.
754      */
755     inBuf = new unsigned char[kBufSize];
756     outBuf = new unsigned char[kBufSize];
757     if (inBuf == NULL || outBuf == NULL) {
758         result = NO_MEMORY;
759         goto bail;
760     }
761 
762     /*
763      * Initialize the zlib stream.
764      */
765     memset(&zstream, 0, sizeof(zstream));
766     zstream.zalloc = Z_NULL;
767     zstream.zfree = Z_NULL;
768     zstream.opaque = Z_NULL;
769     zstream.next_in = NULL;
770     zstream.avail_in = 0;
771     zstream.next_out = outBuf;
772     zstream.avail_out = kBufSize;
773     zstream.data_type = Z_UNKNOWN;
774 
775     zerr = deflateInit2(&zstream, Z_BEST_COMPRESSION,
776         Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
777     if (zerr != Z_OK) {
778         result = UNKNOWN_ERROR;
779         if (zerr == Z_VERSION_ERROR) {
780             ALOGE("Installed zlib is not compatible with linked version (%s)\n",
781                 ZLIB_VERSION);
782         } else {
783             ALOGD("Call to deflateInit2 failed (zerr=%d)\n", zerr);
784         }
785         goto bail;
786     }
787 
788     crc = crc32(0L, Z_NULL, 0);
789 
790     /*
791      * Loop while we have data.
792      */
793     do {
794         size_t getSize;
795         int flush;
796 
797         /* only read if the input buffer is empty */
798         if (zstream.avail_in == 0 && !atEof) {
799             ALOGV("+++ reading %d bytes\n", (int)kBufSize);
800             if (data) {
801                 getSize = size > kBufSize ? kBufSize : size;
802                 memcpy(inBuf, data, getSize);
803                 data = ((const char*)data) + getSize;
804                 size -= getSize;
805             } else {
806                 getSize = fread(inBuf, 1, kBufSize, srcFp);
807                 if (ferror(srcFp)) {
808                     ALOGD("deflate read failed (errno=%d)\n", errno);
809                     goto z_bail;
810                 }
811             }
812             if (getSize < kBufSize) {
813                 ALOGV("+++  got %d bytes, EOF reached\n",
814                     (int)getSize);
815                 atEof = true;
816             }
817 
818             crc = crc32(crc, inBuf, getSize);
819 
820             zstream.next_in = inBuf;
821             zstream.avail_in = getSize;
822         }
823 
824         if (atEof)
825             flush = Z_FINISH;       /* tell zlib that we're done */
826         else
827             flush = Z_NO_FLUSH;     /* more to come! */
828 
829         zerr = deflate(&zstream, flush);
830         if (zerr != Z_OK && zerr != Z_STREAM_END) {
831             ALOGD("zlib deflate call failed (zerr=%d)\n", zerr);
832             result = UNKNOWN_ERROR;
833             goto z_bail;
834         }
835 
836         /* write when we're full or when we're done */
837         if (zstream.avail_out == 0 ||
838             (zerr == Z_STREAM_END && zstream.avail_out != (uInt) kBufSize))
839         {
840             ALOGV("+++ writing %d bytes\n", (int) (zstream.next_out - outBuf));
841             if (fwrite(outBuf, 1, zstream.next_out - outBuf, dstFp) !=
842                 (size_t)(zstream.next_out - outBuf))
843             {
844                 ALOGD("write %d failed in deflate\n",
845                     (int) (zstream.next_out - outBuf));
846                 goto z_bail;
847             }
848 
849             zstream.next_out = outBuf;
850             zstream.avail_out = kBufSize;
851         }
852     } while (zerr == Z_OK);
853 
854     assert(zerr == Z_STREAM_END);       /* other errors should've been caught */
855 
856     *pCRC32 = crc;
857 
858 z_bail:
859     deflateEnd(&zstream);        /* free up any allocated structures */
860 
861 bail:
862     delete[] inBuf;
863     delete[] outBuf;
864 
865     return result;
866 }
867 
868 /*
869  * Mark an entry as deleted.
870  *
871  * We will eventually need to crunch the file down, but if several files
872  * are being removed (perhaps as part of an "update" process) we can make
873  * things considerably faster by deferring the removal to "flush" time.
874  */
remove(ZipEntry * pEntry)875 status_t ZipFile::remove(ZipEntry* pEntry)
876 {
877     /*
878      * Should verify that pEntry is actually part of this archive, and
879      * not some stray ZipEntry from a different file.
880      */
881 
882     /* mark entry as deleted, and mark archive as dirty */
883     pEntry->setDeleted();
884     mNeedCDRewrite = true;
885     return NO_ERROR;
886 }
887 
888 /*
889  * Flush any pending writes.
890  *
891  * In particular, this will crunch out deleted entries, and write the
892  * Central Directory and EOCD if we have stomped on them.
893  */
flush(void)894 status_t ZipFile::flush(void)
895 {
896     status_t result = NO_ERROR;
897     long eocdPosn;
898     int i, count;
899 
900     if (mReadOnly)
901         return INVALID_OPERATION;
902     if (!mNeedCDRewrite)
903         return NO_ERROR;
904 
905     assert(mZipFp != NULL);
906 
907     result = crunchArchive();
908     if (result != NO_ERROR)
909         return result;
910 
911     if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0)
912         return UNKNOWN_ERROR;
913 
914     count = mEntries.size();
915     for (i = 0; i < count; i++) {
916         ZipEntry* pEntry = mEntries[i];
917         pEntry->mCDE.write(mZipFp);
918     }
919 
920     eocdPosn = ftell(mZipFp);
921     mEOCD.mCentralDirSize = eocdPosn - mEOCD.mCentralDirOffset;
922 
923     mEOCD.write(mZipFp);
924 
925     /*
926      * If we had some stuff bloat up during compression and get replaced
927      * with plain files, or if we deleted some entries, there's a lot
928      * of wasted space at the end of the file.  Remove it now.
929      */
930     if (ftruncate(fileno(mZipFp), ftell(mZipFp)) != 0) {
931         ALOGW("ftruncate failed %ld: %s\n", ftell(mZipFp), strerror(errno));
932         // not fatal
933     }
934 
935     /* should we clear the "newly added" flag in all entries now? */
936 
937     mNeedCDRewrite = false;
938     return NO_ERROR;
939 }
940 
941 /*
942  * Crunch deleted files out of an archive by shifting the later files down.
943  *
944  * Because we're not using a temp file, we do the operation inside the
945  * current file.
946  */
crunchArchive(void)947 status_t ZipFile::crunchArchive(void)
948 {
949     status_t result = NO_ERROR;
950     int i, count;
951     long delCount, adjust;
952 
953 #if 0
954     printf("CONTENTS:\n");
955     for (i = 0; i < (int) mEntries.size(); i++) {
956         printf(" %d: lfhOff=%ld del=%d\n",
957             i, mEntries[i]->getLFHOffset(), mEntries[i]->getDeleted());
958     }
959     printf("  END is %ld\n", (long) mEOCD.mCentralDirOffset);
960 #endif
961 
962     /*
963      * Roll through the set of files, shifting them as appropriate.  We
964      * could probably get a slight performance improvement by sliding
965      * multiple files down at once (because we could use larger reads
966      * when operating on batches of small files), but it's not that useful.
967      */
968     count = mEntries.size();
969     delCount = adjust = 0;
970     for (i = 0; i < count; i++) {
971         ZipEntry* pEntry = mEntries[i];
972         long span;
973 
974         if (pEntry->getLFHOffset() != 0) {
975             long nextOffset;
976 
977             /* Get the length of this entry by finding the offset
978              * of the next entry.  Directory entries don't have
979              * file offsets, so we need to find the next non-directory
980              * entry.
981              */
982             nextOffset = 0;
983             for (int ii = i+1; nextOffset == 0 && ii < count; ii++)
984                 nextOffset = mEntries[ii]->getLFHOffset();
985             if (nextOffset == 0)
986                 nextOffset = mEOCD.mCentralDirOffset;
987             span = nextOffset - pEntry->getLFHOffset();
988 
989             assert(span >= ZipEntry::LocalFileHeader::kLFHLen);
990         } else {
991             /* This is a directory entry.  It doesn't have
992              * any actual file contents, so there's no need to
993              * move anything.
994              */
995             span = 0;
996         }
997 
998         //printf("+++ %d: off=%ld span=%ld del=%d [count=%d]\n",
999         //    i, pEntry->getLFHOffset(), span, pEntry->getDeleted(), count);
1000 
1001         if (pEntry->getDeleted()) {
1002             adjust += span;
1003             delCount++;
1004 
1005             delete pEntry;
1006             mEntries.removeAt(i);
1007 
1008             /* adjust loop control */
1009             count--;
1010             i--;
1011         } else if (span != 0 && adjust > 0) {
1012             /* shuffle this entry back */
1013             //printf("+++ Shuffling '%s' back %ld\n",
1014             //    pEntry->getFileName(), adjust);
1015             result = filemove(mZipFp, pEntry->getLFHOffset() - adjust,
1016                         pEntry->getLFHOffset(), span);
1017             if (result != NO_ERROR) {
1018                 /* this is why you use a temp file */
1019                 ALOGE("error during crunch - archive is toast\n");
1020                 return result;
1021             }
1022 
1023             pEntry->setLFHOffset(pEntry->getLFHOffset() - adjust);
1024         }
1025     }
1026 
1027     /*
1028      * Fix EOCD info.  We have to wait until the end to do some of this
1029      * because we use mCentralDirOffset to determine "span" for the
1030      * last entry.
1031      */
1032     mEOCD.mCentralDirOffset -= adjust;
1033     mEOCD.mNumEntries -= delCount;
1034     mEOCD.mTotalNumEntries -= delCount;
1035     mEOCD.mCentralDirSize = 0;  // mark invalid; set by flush()
1036 
1037     assert(mEOCD.mNumEntries == mEOCD.mTotalNumEntries);
1038     assert(mEOCD.mNumEntries == count);
1039 
1040     return result;
1041 }
1042 
1043 /*
1044  * Works like memmove(), but on pieces of a file.
1045  */
filemove(FILE * fp,off_t dst,off_t src,size_t n)1046 status_t ZipFile::filemove(FILE* fp, off_t dst, off_t src, size_t n)
1047 {
1048     if (dst == src || n <= 0)
1049         return NO_ERROR;
1050 
1051     unsigned char readBuf[32768];
1052 
1053     if (dst < src) {
1054         /* shift stuff toward start of file; must read from start */
1055         while (n != 0) {
1056             size_t getSize = sizeof(readBuf);
1057             if (getSize > n)
1058                 getSize = n;
1059 
1060             if (fseek(fp, (long) src, SEEK_SET) != 0) {
1061                 ALOGD("filemove src seek %ld failed\n", (long) src);
1062                 return UNKNOWN_ERROR;
1063             }
1064 
1065             if (fread(readBuf, 1, getSize, fp) != getSize) {
1066                 ALOGD("filemove read %ld off=%ld failed\n",
1067                     (long) getSize, (long) src);
1068                 return UNKNOWN_ERROR;
1069             }
1070 
1071             if (fseek(fp, (long) dst, SEEK_SET) != 0) {
1072                 ALOGD("filemove dst seek %ld failed\n", (long) dst);
1073                 return UNKNOWN_ERROR;
1074             }
1075 
1076             if (fwrite(readBuf, 1, getSize, fp) != getSize) {
1077                 ALOGD("filemove write %ld off=%ld failed\n",
1078                     (long) getSize, (long) dst);
1079                 return UNKNOWN_ERROR;
1080             }
1081 
1082             src += getSize;
1083             dst += getSize;
1084             n -= getSize;
1085         }
1086     } else {
1087         /* shift stuff toward end of file; must read from end */
1088         assert(false);      // write this someday, maybe
1089         return UNKNOWN_ERROR;
1090     }
1091 
1092     return NO_ERROR;
1093 }
1094 
1095 
1096 /*
1097  * Get the modification time from a file descriptor.
1098  */
getModTime(int fd)1099 time_t ZipFile::getModTime(int fd)
1100 {
1101     struct stat sb;
1102 
1103     if (fstat(fd, &sb) < 0) {
1104         ALOGD("HEY: fstat on fd %d failed\n", fd);
1105         return (time_t) -1;
1106     }
1107 
1108     return sb.st_mtime;
1109 }
1110 
1111 
1112 #if 0       /* this is a bad idea */
1113 /*
1114  * Get a copy of the Zip file descriptor.
1115  *
1116  * We don't allow this if the file was opened read-write because we tend
1117  * to leave the file contents in an uncertain state between calls to
1118  * flush().  The duplicated file descriptor should only be valid for reads.
1119  */
1120 int ZipFile::getZipFd(void) const
1121 {
1122     if (!mReadOnly)
1123         return INVALID_OPERATION;
1124     assert(mZipFp != NULL);
1125 
1126     int fd;
1127     fd = dup(fileno(mZipFp));
1128     if (fd < 0) {
1129         ALOGD("didn't work, errno=%d\n", errno);
1130     }
1131 
1132     return fd;
1133 }
1134 #endif
1135 
1136 
1137 #if 0
1138 /*
1139  * Expand data.
1140  */
1141 bool ZipFile::uncompress(const ZipEntry* pEntry, void* buf) const
1142 {
1143     return false;
1144 }
1145 #endif
1146 
1147 // free the memory when you're done
uncompress(const ZipEntry * entry)1148 void* ZipFile::uncompress(const ZipEntry* entry)
1149 {
1150     size_t unlen = entry->getUncompressedLen();
1151     size_t clen = entry->getCompressedLen();
1152 
1153     void* buf = malloc(unlen);
1154     if (buf == NULL) {
1155         return NULL;
1156     }
1157 
1158     fseek(mZipFp, 0, SEEK_SET);
1159 
1160     off_t offset = entry->getFileOffset();
1161     if (fseek(mZipFp, offset, SEEK_SET) != 0) {
1162         goto bail;
1163     }
1164 
1165     switch (entry->getCompressionMethod())
1166     {
1167         case ZipEntry::kCompressStored: {
1168             ssize_t amt = fread(buf, 1, unlen, mZipFp);
1169             if (amt != (ssize_t)unlen) {
1170                 goto bail;
1171             }
1172 #if 0
1173             printf("data...\n");
1174             const unsigned char* p = (unsigned char*)buf;
1175             const unsigned char* end = p+unlen;
1176             for (int i=0; i<32 && p < end; i++) {
1177                 printf("0x%08x ", (int)(offset+(i*0x10)));
1178                 for (int j=0; j<0x10 && p < end; j++) {
1179                     printf(" %02x", *p);
1180                     p++;
1181                 }
1182                 printf("\n");
1183             }
1184 #endif
1185 
1186             }
1187             break;
1188         case ZipEntry::kCompressDeflated: {
1189             if (!ZipUtils::inflateToBuffer(mZipFp, buf, unlen, clen)) {
1190                 goto bail;
1191             }
1192             }
1193             break;
1194         default:
1195             goto bail;
1196     }
1197     return buf;
1198 
1199 bail:
1200     free(buf);
1201     return NULL;
1202 }
1203 
1204 
1205 /*
1206  * ===========================================================================
1207  *      ZipFile::EndOfCentralDir
1208  * ===========================================================================
1209  */
1210 
1211 /*
1212  * Read the end-of-central-dir fields.
1213  *
1214  * "buf" should be positioned at the EOCD signature, and should contain
1215  * the entire EOCD area including the comment.
1216  */
readBuf(const unsigned char * buf,int len)1217 status_t ZipFile::EndOfCentralDir::readBuf(const unsigned char* buf, int len)
1218 {
1219     /* don't allow re-use */
1220     assert(mComment == NULL);
1221 
1222     if (len < kEOCDLen) {
1223         /* looks like ZIP file got truncated */
1224         ALOGD(" Zip EOCD: expected >= %d bytes, found %d\n",
1225             kEOCDLen, len);
1226         return INVALID_OPERATION;
1227     }
1228 
1229     /* this should probably be an assert() */
1230     if (ZipEntry::getLongLE(&buf[0x00]) != kSignature)
1231         return UNKNOWN_ERROR;
1232 
1233     mDiskNumber = ZipEntry::getShortLE(&buf[0x04]);
1234     mDiskWithCentralDir = ZipEntry::getShortLE(&buf[0x06]);
1235     mNumEntries = ZipEntry::getShortLE(&buf[0x08]);
1236     mTotalNumEntries = ZipEntry::getShortLE(&buf[0x0a]);
1237     mCentralDirSize = ZipEntry::getLongLE(&buf[0x0c]);
1238     mCentralDirOffset = ZipEntry::getLongLE(&buf[0x10]);
1239     mCommentLen = ZipEntry::getShortLE(&buf[0x14]);
1240 
1241     // TODO: validate mCentralDirOffset
1242 
1243     if (mCommentLen > 0) {
1244         if (kEOCDLen + mCommentLen > len) {
1245             ALOGD("EOCD(%d) + comment(%d) exceeds len (%d)\n",
1246                 kEOCDLen, mCommentLen, len);
1247             return UNKNOWN_ERROR;
1248         }
1249         mComment = new unsigned char[mCommentLen];
1250         memcpy(mComment, buf + kEOCDLen, mCommentLen);
1251     }
1252 
1253     return NO_ERROR;
1254 }
1255 
1256 /*
1257  * Write an end-of-central-directory section.
1258  */
write(FILE * fp)1259 status_t ZipFile::EndOfCentralDir::write(FILE* fp)
1260 {
1261     unsigned char buf[kEOCDLen];
1262 
1263     ZipEntry::putLongLE(&buf[0x00], kSignature);
1264     ZipEntry::putShortLE(&buf[0x04], mDiskNumber);
1265     ZipEntry::putShortLE(&buf[0x06], mDiskWithCentralDir);
1266     ZipEntry::putShortLE(&buf[0x08], mNumEntries);
1267     ZipEntry::putShortLE(&buf[0x0a], mTotalNumEntries);
1268     ZipEntry::putLongLE(&buf[0x0c], mCentralDirSize);
1269     ZipEntry::putLongLE(&buf[0x10], mCentralDirOffset);
1270     ZipEntry::putShortLE(&buf[0x14], mCommentLen);
1271 
1272     if (fwrite(buf, 1, kEOCDLen, fp) != kEOCDLen)
1273         return UNKNOWN_ERROR;
1274     if (mCommentLen > 0) {
1275         assert(mComment != NULL);
1276         if (fwrite(mComment, mCommentLen, 1, fp) != mCommentLen)
1277             return UNKNOWN_ERROR;
1278     }
1279 
1280     return NO_ERROR;
1281 }
1282 
1283 /*
1284  * Dump the contents of an EndOfCentralDir object.
1285  */
dump(void) const1286 void ZipFile::EndOfCentralDir::dump(void) const
1287 {
1288     ALOGD(" EndOfCentralDir contents:\n");
1289     ALOGD("  diskNum=%u diskWCD=%u numEnt=%u totalNumEnt=%u\n",
1290         mDiskNumber, mDiskWithCentralDir, mNumEntries, mTotalNumEntries);
1291     ALOGD("  centDirSize=%lu centDirOff=%lu commentLen=%u\n",
1292         mCentralDirSize, mCentralDirOffset, mCommentLen);
1293 }
1294 
1295