blob: 12e06f6d8180f34c18dee180a73086c0bd4029e6 [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Simple Zip file support.
5 */
6#include "safe_iop.h"
7#include "zlib.h"
8
9#include <errno.h>
10#include <fcntl.h>
11#include <limits.h>
12#include <stdint.h> // for uintptr_t
13#include <stdlib.h>
14#include <sys/stat.h> // for S_ISLNK()
15#include <unistd.h>
16
17#define LOG_TAG "minzip"
18#include "Zip.h"
19#include "Bits.h"
20#include "Log.h"
21#include "DirUtil.h"
22
23#undef NDEBUG // do this after including Log.h
24#include <assert.h>
25
26#define SORT_ENTRIES 1
27
28/*
29 * Offset and length constants (java.util.zip naming convention).
30 */
31enum {
32 CENSIG = 0x02014b50, // PK12
33 CENHDR = 46,
34
35 CENVEM = 4,
36 CENVER = 6,
37 CENFLG = 8,
38 CENHOW = 10,
39 CENTIM = 12,
40 CENCRC = 16,
41 CENSIZ = 20,
42 CENLEN = 24,
43 CENNAM = 28,
Doug Zongker596271f2009-04-29 16:52:04 -070044 CENEXT = 30,
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080045 CENCOM = 32,
46 CENDSK = 34,
47 CENATT = 36,
48 CENATX = 38,
49 CENOFF = 42,
50
51 ENDSIG = 0x06054b50, // PK56
52 ENDHDR = 22,
53
54 ENDSUB = 8,
55 ENDTOT = 10,
56 ENDSIZ = 12,
57 ENDOFF = 16,
58 ENDCOM = 20,
59
60 EXTSIG = 0x08074b50, // PK78
61 EXTHDR = 16,
62
63 EXTCRC = 4,
64 EXTSIZ = 8,
65 EXTLEN = 12,
66
67 LOCSIG = 0x04034b50, // PK34
68 LOCHDR = 30,
Doug Zongker596271f2009-04-29 16:52:04 -070069
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080070 LOCVER = 4,
71 LOCFLG = 6,
72 LOCHOW = 8,
73 LOCTIM = 10,
74 LOCCRC = 14,
Doug Zongker596271f2009-04-29 16:52:04 -070075 LOCSIZ = 18,
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080076 LOCLEN = 22,
77 LOCNAM = 26,
78 LOCEXT = 28,
79
80 STORED = 0,
81 DEFLATED = 8,
82
83 CENVEM_UNIX = 3 << 8, // the high byte of CENVEM
84};
85
86
87/*
88 * For debugging, dump the contents of a ZipEntry.
89 */
90#if 0
91static void dumpEntry(const ZipEntry* pEntry)
92{
93 LOGI(" %p '%.*s'\n", pEntry->fileName,pEntry->fileNameLen,pEntry->fileName);
94 LOGI(" off=%ld comp=%ld uncomp=%ld how=%d\n", pEntry->offset,
95 pEntry->compLen, pEntry->uncompLen, pEntry->compression);
96}
97#endif
98
99/*
100 * (This is a mzHashTableLookup callback.)
101 *
102 * Compare two ZipEntry structs, by name.
103 */
104static int hashcmpZipEntry(const void* ventry1, const void* ventry2)
105{
106 const ZipEntry* entry1 = (const ZipEntry*) ventry1;
107 const ZipEntry* entry2 = (const ZipEntry*) ventry2;
108
109 if (entry1->fileNameLen != entry2->fileNameLen)
110 return entry1->fileNameLen - entry2->fileNameLen;
111 return memcmp(entry1->fileName, entry2->fileName, entry1->fileNameLen);
112}
113
114/*
115 * (This is a mzHashTableLookup callback.)
116 *
117 * find a ZipEntry struct by name.
118 */
119static int hashcmpZipName(const void* ventry, const void* vname)
120{
121 const ZipEntry* entry = (const ZipEntry*) ventry;
122 const char* name = (const char*) vname;
123 unsigned int nameLen = strlen(name);
124
125 if (entry->fileNameLen != nameLen)
126 return entry->fileNameLen - nameLen;
127 return memcmp(entry->fileName, name, nameLen);
128}
129
130/*
131 * Compute the hash code for a ZipEntry filename.
132 *
133 * Not expected to be compatible with any other hash function, so we init
134 * to 2 to ensure it doesn't happen to match.
135 */
136static unsigned int computeHash(const char* name, int nameLen)
137{
138 unsigned int hash = 2;
139
140 while (nameLen--)
141 hash = hash * 31 + *name++;
142
143 return hash;
144}
145
146static void addEntryToHashTable(HashTable* pHash, ZipEntry* pEntry)
147{
148 unsigned int itemHash = computeHash(pEntry->fileName, pEntry->fileNameLen);
149 const ZipEntry* found;
150
151 found = (const ZipEntry*)mzHashTableLookup(pHash,
152 itemHash, pEntry, hashcmpZipEntry, true);
153 if (found != pEntry) {
154 LOGW("WARNING: duplicate entry '%.*s' in Zip\n",
155 found->fileNameLen, found->fileName);
156 /* keep going */
157 }
158}
159
160static int validFilename(const char *fileName, unsigned int fileNameLen)
161{
162 // Forbid super long filenames.
163 if (fileNameLen >= PATH_MAX) {
164 LOGW("Filename too long (%d chatacters)\n", fileNameLen);
165 return 0;
166 }
167
168 // Require all characters to be printable ASCII (no NUL, no UTF-8, etc).
169 unsigned int i;
170 for (i = 0; i < fileNameLen; ++i) {
171 if (fileName[i] < 32 || fileName[i] >= 127) {
172 LOGW("Filename contains invalid character '\%03o'\n", fileName[i]);
173 return 0;
174 }
175 }
176
177 return 1;
178}
179
180/*
181 * Parse the contents of a Zip archive. After confirming that the file
182 * is in fact a Zip, we scan out the contents of the central directory and
183 * store it in a hash table.
184 *
185 * Returns "true" on success.
186 */
Doug Zongker99916f02014-01-13 14:16:58 -0800187static bool parseZipArchive(ZipArchive* pArchive)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800188{
189 bool result = false;
190 const unsigned char* ptr;
191 unsigned int i, numEntries, cdOffset;
192 unsigned int val;
193
194 /*
195 * The first 4 bytes of the file will either be the local header
196 * signature for the first file (LOCSIG) or, if the archive doesn't
197 * have any files in it, the end-of-central-directory signature (ENDSIG).
198 */
Doug Zongker99916f02014-01-13 14:16:58 -0800199 val = get4LE(pArchive->addr);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800200 if (val == ENDSIG) {
201 LOGI("Found Zip archive, but it looks empty\n");
202 goto bail;
203 } else if (val != LOCSIG) {
204 LOGV("Not a Zip archive (found 0x%08x)\n", val);
205 goto bail;
206 }
207
208 /*
209 * Find the EOCD. We'll find it immediately unless they have a file
210 * comment.
211 */
Doug Zongker99916f02014-01-13 14:16:58 -0800212 ptr = pArchive->addr + pArchive->length - ENDHDR;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800213
Doug Zongker99916f02014-01-13 14:16:58 -0800214 while (ptr >= (const unsigned char*) pArchive->addr) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800215 if (*ptr == (ENDSIG & 0xff) && get4LE(ptr) == ENDSIG)
216 break;
217 ptr--;
218 }
Doug Zongker99916f02014-01-13 14:16:58 -0800219 if (ptr < (const unsigned char*) pArchive->addr) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800220 LOGI("Could not find end-of-central-directory in Zip\n");
221 goto bail;
222 }
223
224 /*
225 * There are two interesting items in the EOCD block: the number of
226 * entries in the file, and the file offset of the start of the
227 * central directory.
228 */
229 numEntries = get2LE(ptr + ENDSUB);
230 cdOffset = get4LE(ptr + ENDOFF);
231
232 LOGVV("numEntries=%d cdOffset=%d\n", numEntries, cdOffset);
Doug Zongker99916f02014-01-13 14:16:58 -0800233 if (numEntries == 0 || cdOffset >= pArchive->length) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800234 LOGW("Invalid entries=%d offset=%d (len=%zd)\n",
Doug Zongker99916f02014-01-13 14:16:58 -0800235 numEntries, cdOffset, pArchive->length);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800236 goto bail;
237 }
238
239 /*
240 * Create data structures to hold entries.
241 */
242 pArchive->numEntries = numEntries;
243 pArchive->pEntries = (ZipEntry*) calloc(numEntries, sizeof(ZipEntry));
244 pArchive->pHash = mzHashTableCreate(mzHashSize(numEntries), NULL);
245 if (pArchive->pEntries == NULL || pArchive->pHash == NULL)
246 goto bail;
247
Doug Zongker99916f02014-01-13 14:16:58 -0800248 ptr = pArchive->addr + cdOffset;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800249 for (i = 0; i < numEntries; i++) {
250 ZipEntry* pEntry;
251 unsigned int fileNameLen, extraLen, commentLen, localHdrOffset;
252 const unsigned char* localHdr;
253 const char *fileName;
254
Doug Zongker99916f02014-01-13 14:16:58 -0800255 if (ptr + CENHDR > (const unsigned char*)pArchive->addr + pArchive->length) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800256 LOGW("Ran off the end (at %d)\n", i);
257 goto bail;
258 }
259 if (get4LE(ptr) != CENSIG) {
260 LOGW("Missed a central dir sig (at %d)\n", i);
261 goto bail;
262 }
263
264 localHdrOffset = get4LE(ptr + CENOFF);
265 fileNameLen = get2LE(ptr + CENNAM);
266 extraLen = get2LE(ptr + CENEXT);
267 commentLen = get2LE(ptr + CENCOM);
268 fileName = (const char*)ptr + CENHDR;
Doug Zongker99916f02014-01-13 14:16:58 -0800269 if (fileName + fileNameLen > (const char*)pArchive->addr + pArchive->length) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800270 LOGW("Filename ran off the end (at %d)\n", i);
271 goto bail;
272 }
273 if (!validFilename(fileName, fileNameLen)) {
274 LOGW("Invalid filename (at %d)\n", i);
275 goto bail;
276 }
277
278#if SORT_ENTRIES
279 /* Figure out where this entry should go (binary search).
280 */
281 if (i > 0) {
282 int low, high;
283
284 low = 0;
285 high = i - 1;
286 while (low <= high) {
287 int mid;
288 int diff;
289 int diffLen;
290
291 mid = low + ((high - low) / 2); // avoid overflow
292
293 if (pArchive->pEntries[mid].fileNameLen < fileNameLen) {
294 diffLen = pArchive->pEntries[mid].fileNameLen;
295 } else {
296 diffLen = fileNameLen;
297 }
298 diff = strncmp(pArchive->pEntries[mid].fileName, fileName,
299 diffLen);
300 if (diff == 0) {
301 diff = pArchive->pEntries[mid].fileNameLen - fileNameLen;
302 }
303 if (diff < 0) {
304 low = mid + 1;
305 } else if (diff > 0) {
306 high = mid - 1;
307 } else {
308 high = mid;
309 break;
310 }
311 }
312
313 unsigned int target = high + 1;
314 assert(target <= i);
315 if (target != i) {
316 /* It belongs somewhere other than at the end of
317 * the list. Make some room at [target].
318 */
319 memmove(pArchive->pEntries + target + 1,
320 pArchive->pEntries + target,
321 (i - target) * sizeof(ZipEntry));
322 }
323 pEntry = &pArchive->pEntries[target];
324 } else {
325 pEntry = &pArchive->pEntries[0];
326 }
327#else
328 pEntry = &pArchive->pEntries[i];
329#endif
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800330 pEntry->fileNameLen = fileNameLen;
331 pEntry->fileName = fileName;
332
333 pEntry->compLen = get4LE(ptr + CENSIZ);
334 pEntry->uncompLen = get4LE(ptr + CENLEN);
335 pEntry->compression = get2LE(ptr + CENHOW);
336 pEntry->modTime = get4LE(ptr + CENTIM);
337 pEntry->crc32 = get4LE(ptr + CENCRC);
338
339 /* These two are necessary for finding the mode of the file.
340 */
341 pEntry->versionMadeBy = get2LE(ptr + CENVEM);
342 if ((pEntry->versionMadeBy & 0xff00) != 0 &&
343 (pEntry->versionMadeBy & 0xff00) != CENVEM_UNIX)
344 {
345 LOGW("Incompatible \"version made by\": 0x%02x (at %d)\n",
346 pEntry->versionMadeBy >> 8, i);
347 goto bail;
348 }
349 pEntry->externalFileAttributes = get4LE(ptr + CENATX);
350
Doug Zongker99916f02014-01-13 14:16:58 -0800351 // Perform pArchive->addr + localHdrOffset, ensuring that it won't
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800352 // overflow. This is needed because localHdrOffset is untrusted.
Doug Zongker99916f02014-01-13 14:16:58 -0800353 if (!safe_add((uintptr_t *)&localHdr, (uintptr_t)pArchive->addr,
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800354 (uintptr_t)localHdrOffset)) {
355 LOGW("Integer overflow adding in parseZipArchive\n");
356 goto bail;
357 }
358 if ((uintptr_t)localHdr + LOCHDR >
Doug Zongker99916f02014-01-13 14:16:58 -0800359 (uintptr_t)pArchive->addr + pArchive->length) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800360 LOGW("Bad offset to local header: %d (at %d)\n", localHdrOffset, i);
361 goto bail;
362 }
363 if (get4LE(localHdr) != LOCSIG) {
364 LOGW("Missed a local header sig (at %d)\n", i);
365 goto bail;
366 }
367 pEntry->offset = localHdrOffset + LOCHDR
368 + get2LE(localHdr + LOCNAM) + get2LE(localHdr + LOCEXT);
369 if (!safe_add(NULL, pEntry->offset, pEntry->compLen)) {
370 LOGW("Integer overflow adding in parseZipArchive\n");
371 goto bail;
372 }
Doug Zongker99916f02014-01-13 14:16:58 -0800373 if ((size_t)pEntry->offset + pEntry->compLen > pArchive->length) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800374 LOGW("Data ran off the end (at %d)\n", i);
375 goto bail;
376 }
377
378#if !SORT_ENTRIES
379 /* Add to hash table; no need to lock here.
380 * Can't do this now if we're sorting, because entries
381 * will move around.
382 */
383 addEntryToHashTable(pArchive->pHash, pEntry);
384#endif
385
386 //dumpEntry(pEntry);
387 ptr += CENHDR + fileNameLen + extraLen + commentLen;
388 }
389
390#if SORT_ENTRIES
391 /* If we're sorting, we have to wait until all entries
392 * are in their final places, otherwise the pointers will
393 * probably point to the wrong things.
394 */
395 for (i = 0; i < numEntries; i++) {
396 /* Add to hash table; no need to lock here.
397 */
398 addEntryToHashTable(pArchive->pHash, &pArchive->pEntries[i]);
399 }
400#endif
401
402 result = true;
403
404bail:
405 if (!result) {
406 mzHashTableFree(pArchive->pHash);
407 pArchive->pHash = NULL;
408 }
409 return result;
410}
411
412/*
413 * Open a Zip archive and scan out the contents.
414 *
415 * The easiest way to do this is to mmap() the whole thing and do the
416 * traditional backward scan for central directory. Since the EOCD is
417 * a relatively small bit at the end, we should end up only touching a
418 * small set of pages.
419 *
420 * This will be called on non-Zip files, especially during startup, so
421 * we don't want to be too noisy about failures. (Do we want a "quiet"
422 * flag?)
423 *
424 * On success, we fill out the contents of "pArchive".
425 */
Doug Zongker99916f02014-01-13 14:16:58 -0800426int mzOpenZipArchive(unsigned char* addr, size_t length, ZipArchive* pArchive)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800427{
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800428 int err;
429
Doug Zongker99916f02014-01-13 14:16:58 -0800430 if (length < ENDHDR) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800431 err = -1;
432 LOGV("File '%s' too small to be zip (%zd)\n", fileName, map.length);
433 goto bail;
434 }
435
Doug Zongker99916f02014-01-13 14:16:58 -0800436 pArchive->addr = addr;
437 pArchive->length = length;
438
439 if (!parseZipArchive(pArchive)) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800440 err = -1;
441 LOGV("Parsing '%s' failed\n", fileName);
442 goto bail;
443 }
444
445 err = 0;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800446
447bail:
448 if (err != 0)
449 mzCloseZipArchive(pArchive);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800450 return err;
451}
452
453/*
454 * Close a ZipArchive, closing the file and freeing the contents.
455 *
456 * NOTE: the ZipArchive may not have been fully created.
457 */
458void mzCloseZipArchive(ZipArchive* pArchive)
459{
460 LOGV("Closing archive %p\n", pArchive);
461
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800462 free(pArchive->pEntries);
463
464 mzHashTableFree(pArchive->pHash);
465
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800466 pArchive->pHash = NULL;
467 pArchive->pEntries = NULL;
468}
469
470/*
471 * Find a matching entry.
472 *
473 * Returns NULL if no matching entry found.
474 */
475const ZipEntry* mzFindZipEntry(const ZipArchive* pArchive,
476 const char* entryName)
477{
478 unsigned int itemHash = computeHash(entryName, strlen(entryName));
479
480 return (const ZipEntry*)mzHashTableLookup(pArchive->pHash,
481 itemHash, (char*) entryName, hashcmpZipName, false);
482}
483
484/*
485 * Return true if the entry is a symbolic link.
486 */
Narayan Kamath3e700cf2015-02-23 13:29:16 +0000487static bool mzIsZipEntrySymlink(const ZipEntry* pEntry)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800488{
489 if ((pEntry->versionMadeBy & 0xff00) == CENVEM_UNIX) {
490 return S_ISLNK(pEntry->externalFileAttributes >> 16);
491 }
492 return false;
493}
494
495/* Call processFunction on the uncompressed data of a STORED entry.
496 */
497static bool processStoredEntry(const ZipArchive *pArchive,
498 const ZipEntry *pEntry, ProcessZipEntryContentsFunction processFunction,
499 void *cookie)
500{
Doug Zongker99916f02014-01-13 14:16:58 -0800501 return processFunction(pArchive->addr + pEntry->offset, pEntry->uncompLen, cookie);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800502}
503
504static bool processDeflatedEntry(const ZipArchive *pArchive,
505 const ZipEntry *pEntry, ProcessZipEntryContentsFunction processFunction,
506 void *cookie)
507{
508 long result = -1;
509 unsigned char readBuf[32 * 1024];
510 unsigned char procBuf[32 * 1024];
511 z_stream zstream;
512 int zerr;
513 long compRemaining;
514
515 compRemaining = pEntry->compLen;
516
517 /*
518 * Initialize the zlib stream.
519 */
520 memset(&zstream, 0, sizeof(zstream));
521 zstream.zalloc = Z_NULL;
522 zstream.zfree = Z_NULL;
523 zstream.opaque = Z_NULL;
Doug Zongker99916f02014-01-13 14:16:58 -0800524 zstream.next_in = pArchive->addr + pEntry->offset;
525 zstream.avail_in = pEntry->compLen;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800526 zstream.next_out = (Bytef*) procBuf;
527 zstream.avail_out = sizeof(procBuf);
528 zstream.data_type = Z_UNKNOWN;
529
530 /*
531 * Use the undocumented "negative window bits" feature to tell zlib
532 * that there's no zlib header waiting for it.
533 */
534 zerr = inflateInit2(&zstream, -MAX_WBITS);
535 if (zerr != Z_OK) {
536 if (zerr == Z_VERSION_ERROR) {
537 LOGE("Installed zlib is not compatible with linked version (%s)\n",
538 ZLIB_VERSION);
539 } else {
540 LOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
541 }
542 goto bail;
543 }
544
545 /*
546 * Loop while we have data.
547 */
548 do {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800549 /* uncompress the data */
550 zerr = inflate(&zstream, Z_NO_FLUSH);
551 if (zerr != Z_OK && zerr != Z_STREAM_END) {
552 LOGD("zlib inflate call failed (zerr=%d)\n", zerr);
553 goto z_bail;
554 }
555
556 /* write when we're full or when we're done */
557 if (zstream.avail_out == 0 ||
558 (zerr == Z_STREAM_END && zstream.avail_out != sizeof(procBuf)))
559 {
560 long procSize = zstream.next_out - procBuf;
561 LOGVV("+++ processing %d bytes\n", (int) procSize);
562 bool ret = processFunction(procBuf, procSize, cookie);
563 if (!ret) {
564 LOGW("Process function elected to fail (in inflate)\n");
565 goto z_bail;
566 }
567
568 zstream.next_out = procBuf;
569 zstream.avail_out = sizeof(procBuf);
570 }
571 } while (zerr == Z_OK);
572
573 assert(zerr == Z_STREAM_END); /* other errors should've been caught */
574
575 // success!
576 result = zstream.total_out;
577
578z_bail:
579 inflateEnd(&zstream); /* free up any allocated structures */
580
581bail:
582 if (result != pEntry->uncompLen) {
583 if (result != -1) // error already shown?
584 LOGW("Size mismatch on inflated file (%ld vs %ld)\n",
585 result, pEntry->uncompLen);
586 return false;
587 }
588 return true;
589}
590
591/*
592 * Stream the uncompressed data through the supplied function,
593 * passing cookie to it each time it gets called. processFunction
594 * may be called more than once.
595 *
596 * If processFunction returns false, the operation is abandoned and
597 * mzProcessZipEntryContents() immediately returns false.
598 *
599 * This is useful for calculating the hash of an entry's uncompressed contents.
600 */
601bool mzProcessZipEntryContents(const ZipArchive *pArchive,
602 const ZipEntry *pEntry, ProcessZipEntryContentsFunction processFunction,
603 void *cookie)
604{
605 bool ret = false;
606 off_t oldOff;
607
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800608 switch (pEntry->compression) {
609 case STORED:
610 ret = processStoredEntry(pArchive, pEntry, processFunction, cookie);
611 break;
612 case DEFLATED:
613 ret = processDeflatedEntry(pArchive, pEntry, processFunction, cookie);
614 break;
615 default:
616 LOGE("Unsupported compression type %d for entry '%s'\n",
617 pEntry->compression, pEntry->fileName);
618 break;
619 }
620
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800621 return ret;
622}
623
624static bool crcProcessFunction(const unsigned char *data, int dataLen,
625 void *crc)
626{
627 *(unsigned long *)crc = crc32(*(unsigned long *)crc, data, dataLen);
628 return true;
629}
630
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800631typedef struct {
632 char *buf;
633 int bufLen;
634} CopyProcessArgs;
635
636static bool copyProcessFunction(const unsigned char *data, int dataLen,
637 void *cookie)
638{
639 CopyProcessArgs *args = (CopyProcessArgs *)cookie;
640 if (dataLen <= args->bufLen) {
641 memcpy(args->buf, data, dataLen);
642 args->buf += dataLen;
643 args->bufLen -= dataLen;
644 return true;
645 }
646 return false;
647}
648
649/*
650 * Read an entry into a buffer allocated by the caller.
651 */
652bool mzReadZipEntry(const ZipArchive* pArchive, const ZipEntry* pEntry,
653 char *buf, int bufLen)
654{
655 CopyProcessArgs args;
656 bool ret;
Doug Zongker596271f2009-04-29 16:52:04 -0700657
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800658 args.buf = buf;
659 args.bufLen = bufLen;
660 ret = mzProcessZipEntryContents(pArchive, pEntry, copyProcessFunction,
661 (void *)&args);
662 if (!ret) {
663 LOGE("Can't extract entry to buffer.\n");
664 return false;
665 }
666 return true;
667}
668
669static bool writeProcessFunction(const unsigned char *data, int dataLen,
Doug Zongker683c4622009-05-05 17:50:21 -0700670 void *cookie)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800671{
Colin Cross92cdf9c2014-02-05 17:30:31 -0800672 int fd = (int)(intptr_t)cookie;
Michael Rungef5d9f892014-05-06 16:54:42 -0700673 if (dataLen == 0) {
674 return true;
675 }
Doug Zongker596271f2009-04-29 16:52:04 -0700676 ssize_t soFar = 0;
Doug Zongker683c4622009-05-05 17:50:21 -0700677 while (true) {
Doug Zongker1c4ceae2009-05-08 09:43:28 -0700678 ssize_t n = write(fd, data+soFar, dataLen-soFar);
Doug Zongker683c4622009-05-05 17:50:21 -0700679 if (n <= 0) {
Doug Zongkera9300302014-02-10 12:35:19 -0800680 LOGE("Error writing %zd bytes from zip file from %p: %s\n",
Doug Zongker683c4622009-05-05 17:50:21 -0700681 dataLen-soFar, data+soFar, strerror(errno));
Doug Zongker1c4ceae2009-05-08 09:43:28 -0700682 if (errno != EINTR) {
683 return false;
Doug Zongker683c4622009-05-05 17:50:21 -0700684 }
Doug Zongker596271f2009-04-29 16:52:04 -0700685 } else if (n > 0) {
686 soFar += n;
687 if (soFar == dataLen) return true;
688 if (soFar > dataLen) {
Doug Zongkera9300302014-02-10 12:35:19 -0800689 LOGE("write overrun? (%zd bytes instead of %d)\n",
Doug Zongker596271f2009-04-29 16:52:04 -0700690 soFar, dataLen);
691 return false;
692 }
Doug Zongker596271f2009-04-29 16:52:04 -0700693 }
Doug Zongker683c4622009-05-05 17:50:21 -0700694 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800695}
696
697/*
698 * Uncompress "pEntry" in "pArchive" to "fd" at the current offset.
699 */
700bool mzExtractZipEntryToFile(const ZipArchive *pArchive,
Doug Zongker1c4ceae2009-05-08 09:43:28 -0700701 const ZipEntry *pEntry, int fd)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800702{
703 bool ret = mzProcessZipEntryContents(pArchive, pEntry, writeProcessFunction,
Colin Cross92cdf9c2014-02-05 17:30:31 -0800704 (void*)(intptr_t)fd);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800705 if (!ret) {
706 LOGE("Can't extract entry to file.\n");
707 return false;
708 }
709 return true;
710}
711
Doug Zongker6aece332010-02-01 14:40:12 -0800712typedef struct {
713 unsigned char* buffer;
714 long len;
715} BufferExtractCookie;
716
717static bool bufferProcessFunction(const unsigned char *data, int dataLen,
718 void *cookie) {
719 BufferExtractCookie *bec = (BufferExtractCookie*)cookie;
720
721 memmove(bec->buffer, data, dataLen);
722 bec->buffer += dataLen;
723 bec->len -= dataLen;
724
725 return true;
726}
727
728/*
729 * Uncompress "pEntry" in "pArchive" to buffer, which must be large
730 * enough to hold mzGetZipEntryUncomplen(pEntry) bytes.
731 */
732bool mzExtractZipEntryToBuffer(const ZipArchive *pArchive,
733 const ZipEntry *pEntry, unsigned char *buffer)
734{
735 BufferExtractCookie bec;
736 bec.buffer = buffer;
737 bec.len = mzGetZipEntryUncompLen(pEntry);
738
739 bool ret = mzProcessZipEntryContents(pArchive, pEntry,
740 bufferProcessFunction, (void*)&bec);
741 if (!ret || bec.len != 0) {
742 LOGE("Can't extract entry to memory buffer.\n");
743 return false;
744 }
745 return true;
746}
747
748
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800749/* Helper state to make path translation easier and less malloc-happy.
750 */
751typedef struct {
752 const char *targetDir;
753 const char *zipDir;
754 char *buf;
755 int targetDirLen;
756 int zipDirLen;
757 int bufLen;
758} MzPathHelper;
759
760/* Given the values of targetDir and zipDir in the helper,
761 * return the target filename of the provided entry.
762 * The helper must be initialized first.
763 */
764static const char *targetEntryPath(MzPathHelper *helper, ZipEntry *pEntry)
765{
766 int needLen;
767 bool firstTime = (helper->buf == NULL);
768
769 /* target file <-- targetDir + / + entry[zipDirLen:]
770 */
771 needLen = helper->targetDirLen + 1 +
772 pEntry->fileNameLen - helper->zipDirLen + 1;
773 if (needLen > helper->bufLen) {
774 char *newBuf;
775
776 needLen *= 2;
777 newBuf = (char *)realloc(helper->buf, needLen);
778 if (newBuf == NULL) {
779 return NULL;
780 }
781 helper->buf = newBuf;
782 helper->bufLen = needLen;
783 }
784
785 /* Every path will start with the target path and a slash.
786 */
787 if (firstTime) {
788 char *p = helper->buf;
789 memcpy(p, helper->targetDir, helper->targetDirLen);
790 p += helper->targetDirLen;
791 if (p == helper->buf || p[-1] != '/') {
792 helper->targetDirLen += 1;
793 *p++ = '/';
794 }
795 }
796
797 /* Replace the custom part of the path with the appropriate
798 * part of the entry's path.
799 */
800 char *epath = helper->buf + helper->targetDirLen;
801 memcpy(epath, pEntry->fileName + helper->zipDirLen,
802 pEntry->fileNameLen - helper->zipDirLen);
803 epath += pEntry->fileNameLen - helper->zipDirLen;
804 *epath = '\0';
805
806 return helper->buf;
807}
808
809/*
810 * Inflate all entries under zipDir to the directory specified by
811 * targetDir, which must exist and be a writable directory.
812 *
813 * The immediate children of zipDir will become the immediate
814 * children of targetDir; e.g., if the archive contains the entries
815 *
816 * a/b/c/one
817 * a/b/c/two
818 * a/b/c/d/three
819 *
820 * and mzExtractRecursive(a, "a/b/c", "/tmp") is called, the resulting
821 * files will be
822 *
823 * /tmp/one
824 * /tmp/two
825 * /tmp/d/three
826 *
827 * Returns true on success, false on failure.
828 */
829bool mzExtractRecursive(const ZipArchive *pArchive,
830 const char *zipDir, const char *targetDir,
831 int flags, const struct utimbuf *timestamp,
Stephen Smalley779701d2012-02-09 14:13:23 -0500832 void (*callback)(const char *fn, void *), void *cookie,
833 struct selabel_handle *sehnd)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800834{
835 if (zipDir[0] == '/') {
836 LOGE("mzExtractRecursive(): zipDir must be a relative path.\n");
837 return false;
838 }
839 if (targetDir[0] != '/') {
840 LOGE("mzExtractRecursive(): targetDir must be an absolute path.\n");
841 return false;
842 }
843
844 unsigned int zipDirLen;
845 char *zpath;
846
847 zipDirLen = strlen(zipDir);
848 zpath = (char *)malloc(zipDirLen + 2);
849 if (zpath == NULL) {
850 LOGE("Can't allocate %d bytes for zip path\n", zipDirLen + 2);
851 return false;
852 }
853 /* If zipDir is empty, we'll extract the entire zip file.
854 * Otherwise, canonicalize the path.
855 */
856 if (zipDirLen > 0) {
857 /* Make sure there's (hopefully, exactly one) slash at the
858 * end of the path. This way we don't need to worry about
859 * accidentally extracting "one/twothree" when a path like
860 * "one/two" is specified.
861 */
862 memcpy(zpath, zipDir, zipDirLen);
863 if (zpath[zipDirLen-1] != '/') {
864 zpath[zipDirLen++] = '/';
865 }
866 }
867 zpath[zipDirLen] = '\0';
868
869 /* Set up the helper structure that we'll use to assemble paths.
870 */
871 MzPathHelper helper;
872 helper.targetDir = targetDir;
873 helper.targetDirLen = strlen(helper.targetDir);
874 helper.zipDir = zpath;
875 helper.zipDirLen = strlen(helper.zipDir);
876 helper.buf = NULL;
877 helper.bufLen = 0;
878
879 /* Walk through the entries and extract anything whose path begins
880 * with zpath.
Nanik Tolaram4e8e93b2015-02-08 22:31:14 +1100881 //TODO: since the entries are sorted, binary search for the first match
882 // and stop after the first non-match.
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800883 */
884 unsigned int i;
885 bool seenMatch = false;
886 int ok = true;
Doug Zongkerbf80f492012-10-19 12:24:26 -0700887 int extractCount = 0;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800888 for (i = 0; i < pArchive->numEntries; i++) {
889 ZipEntry *pEntry = pArchive->pEntries + i;
890 if (pEntry->fileNameLen < zipDirLen) {
Nanik Tolaram4e8e93b2015-02-08 22:31:14 +1100891 //TODO: look out for a single empty directory entry that matches zpath, but
892 // missing the trailing slash. Most zip files seem to include
893 // the trailing slash, but I think it's legal to leave it off.
894 // e.g., zpath "a/b/", entry "a/b", with no children of the entry.
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800895 /* No chance of matching.
896 */
897#if SORT_ENTRIES
898 if (seenMatch) {
899 /* Since the entries are sorted, we can give up
900 * on the first mismatch after the first match.
901 */
902 break;
903 }
904#endif
905 continue;
906 }
907 /* If zpath is empty, this strncmp() will match everything,
908 * which is what we want.
909 */
910 if (strncmp(pEntry->fileName, zpath, zipDirLen) != 0) {
911#if SORT_ENTRIES
912 if (seenMatch) {
913 /* Since the entries are sorted, we can give up
914 * on the first mismatch after the first match.
915 */
916 break;
917 }
918#endif
919 continue;
920 }
921 /* This entry begins with zipDir, so we'll extract it.
922 */
923 seenMatch = true;
924
925 /* Find the target location of the entry.
926 */
927 const char *targetFile = targetEntryPath(&helper, pEntry);
928 if (targetFile == NULL) {
929 LOGE("Can't assemble target path for \"%.*s\"\n",
930 pEntry->fileNameLen, pEntry->fileName);
931 ok = false;
932 break;
933 }
934
935 /* With DRY_RUN set, invoke the callback but don't do anything else.
936 */
937 if (flags & MZ_EXTRACT_DRY_RUN) {
938 if (callback != NULL) callback(targetFile, cookie);
939 continue;
940 }
941
942 /* Create the file or directory.
943 */
944#define UNZIP_DIRMODE 0755
945#define UNZIP_FILEMODE 0644
946 if (pEntry->fileName[pEntry->fileNameLen-1] == '/') {
947 if (!(flags & MZ_EXTRACT_FILES_ONLY)) {
948 int ret = dirCreateHierarchy(
Stephen Smalley779701d2012-02-09 14:13:23 -0500949 targetFile, UNZIP_DIRMODE, timestamp, false, sehnd);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800950 if (ret != 0) {
951 LOGE("Can't create containing directory for \"%s\": %s\n",
952 targetFile, strerror(errno));
953 ok = false;
954 break;
955 }
956 LOGD("Extracted dir \"%s\"\n", targetFile);
957 }
958 } else {
959 /* This is not a directory. First, make sure that
960 * the containing directory exists.
961 */
962 int ret = dirCreateHierarchy(
Stephen Smalley779701d2012-02-09 14:13:23 -0500963 targetFile, UNZIP_DIRMODE, timestamp, true, sehnd);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800964 if (ret != 0) {
965 LOGE("Can't create containing directory for \"%s\": %s\n",
966 targetFile, strerror(errno));
967 ok = false;
968 break;
969 }
970
971 /* With FILES_ONLY set, we need to ignore metadata entirely,
972 * so treat symlinks as regular files.
973 */
974 if (!(flags & MZ_EXTRACT_FILES_ONLY) && mzIsZipEntrySymlink(pEntry)) {
975 /* The entry is a symbolic link.
976 * The relative target of the symlink is in the
977 * data section of this entry.
978 */
979 if (pEntry->uncompLen == 0) {
980 LOGE("Symlink entry \"%s\" has no target\n",
981 targetFile);
982 ok = false;
983 break;
984 }
985 char *linkTarget = malloc(pEntry->uncompLen + 1);
986 if (linkTarget == NULL) {
987 ok = false;
988 break;
989 }
990 ok = mzReadZipEntry(pArchive, pEntry, linkTarget,
991 pEntry->uncompLen);
992 if (!ok) {
993 LOGE("Can't read symlink target for \"%s\"\n",
994 targetFile);
995 free(linkTarget);
996 break;
997 }
998 linkTarget[pEntry->uncompLen] = '\0';
999
1000 /* Make the link.
1001 */
1002 ret = symlink(linkTarget, targetFile);
1003 if (ret != 0) {
1004 LOGE("Can't symlink \"%s\" to \"%s\": %s\n",
1005 targetFile, linkTarget, strerror(errno));
1006 free(linkTarget);
1007 ok = false;
1008 break;
1009 }
1010 LOGD("Extracted symlink \"%s\" -> \"%s\"\n",
1011 targetFile, linkTarget);
1012 free(linkTarget);
1013 } else {
1014 /* The entry is a regular file.
1015 * Open the target for writing.
1016 */
Stephen Smalley779701d2012-02-09 14:13:23 -05001017
Stephen Smalley779701d2012-02-09 14:13:23 -05001018 char *secontext = NULL;
1019
1020 if (sehnd) {
1021 selabel_lookup(sehnd, &secontext, targetFile, UNZIP_FILEMODE);
1022 setfscreatecon(secontext);
1023 }
Stephen Smalley779701d2012-02-09 14:13:23 -05001024
Michael Runge042c3cd2014-10-28 19:49:57 -07001025 int fd = open(targetFile, O_CREAT|O_WRONLY|O_TRUNC|O_SYNC
1026 , UNZIP_FILEMODE);
Stephen Smalley779701d2012-02-09 14:13:23 -05001027
Stephen Smalley779701d2012-02-09 14:13:23 -05001028 if (secontext) {
1029 freecon(secontext);
1030 setfscreatecon(NULL);
1031 }
Stephen Smalley779701d2012-02-09 14:13:23 -05001032
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001033 if (fd < 0) {
1034 LOGE("Can't create target file \"%s\": %s\n",
1035 targetFile, strerror(errno));
1036 ok = false;
1037 break;
1038 }
1039
Doug Zongker1c4ceae2009-05-08 09:43:28 -07001040 bool ok = mzExtractZipEntryToFile(pArchive, pEntry, fd);
Michael Runge042c3cd2014-10-28 19:49:57 -07001041 if (ok) {
1042 ok = (fsync(fd) == 0);
1043 }
1044 if (close(fd) != 0) {
1045 ok = false;
1046 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001047 if (!ok) {
1048 LOGE("Error extracting \"%s\"\n", targetFile);
1049 ok = false;
1050 break;
1051 }
1052
1053 if (timestamp != NULL && utime(targetFile, timestamp)) {
1054 LOGE("Error touching \"%s\"\n", targetFile);
1055 ok = false;
1056 break;
1057 }
1058
Doug Zongkerbf80f492012-10-19 12:24:26 -07001059 LOGV("Extracted file \"%s\"\n", targetFile);
1060 ++extractCount;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001061 }
1062 }
1063
1064 if (callback != NULL) callback(targetFile, cookie);
1065 }
1066
Doug Zongkerbf80f492012-10-19 12:24:26 -07001067 LOGD("Extracted %d file(s)\n", extractCount);
1068
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001069 free(helper.buf);
1070 free(zpath);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001071
1072 return ok;
1073}