Lines Matching +full:bzip2 +full:. +full:zipx
5 * All rights reserved.
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
14 * documentation and/or other materials provided with the distribution.
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include "archive_platform.h"
29 __FBSDID("$FreeBSD: stable/11/contrib/libarchive/libarchive/archive_read_support_format_zip.c 370535 2021-09-10 08:34:36Z git2svn $");
33 * http://www.pkware.com/documents/casestudies/APPNOTE.TXT
38 * information.
41 * libarchive in January 2005. Support for seekable input sources was
42 * added in Nov 2011. Zip64 support (including a significant code
43 * refactoring) was added in 2014.
47 #include <errno.h>
50 #include <stdlib.h>
53 #include <zlib.h>
56 #include <bzlib.h>
59 #include <lzma.h>
62 #include "archive.h"
63 #include "archive_digest_private.h"
64 #include "archive_cryptor_private.h"
65 #include "archive_endian.h"
66 #include "archive_entry.h"
67 #include "archive_entry_locale.h"
68 #include "archive_hmac_private.h"
69 #include "archive_private.h"
70 #include "archive_rb.h"
71 #include "archive_read_private.h"
72 #include "archive_ppmd8_private.h"
75 #include "archive_crc32.h"
95 unsigned char flags; /* Our extra markers. */
99 * when compression is 99. */
106 * 1 - 128 bits, 2 - 192 bits, 2 - 256 bits. */
108 /* Actual compression method. */
117 /* Bits used in zip_flags. */
123 in http://www.pkware.com/documents/casestudies/APPNOTE.TXT */
126 /* Bits used in flags. */
132 * http://www.winzip.com/aes_info.htm
134 /* Value used in compression method. */
136 /* Authentication code size. */
142 /* Structural information about the archive. */
158 /* Information about entry we're currently reading. */
162 /* These count the number of bytes actually read for the entry. */
172 /* Flags to mark progress of decompression. */
208 /* Decryption buffer. */
211 * extends for decrypted_bytes_remaining. Decryption
213 * to clients from the beginning. When the block hits the
215 * the beginning of the buffer.
223 /* Traditional PKWARE decryption. */
227 /* WinZip AES decryption. */
228 /* Contexts used for AES decryption. */
234 /* Strong encryption's decryption header information. */
247 /* Many systems define min or MIN, but not all. */
262 * streams inside ZIP files. It has 2 purposes: one is to fetch the next
264 * many compressed bytes were read. */
267 /* Get the handle to current decompression context. */
272 /* Fetch next byte. */
281 /* Increment the counter. */
284 /* Return the next compressed byte. */
291 Traditional PKWARE Decryption functions.
348 /* Return the last byte for CRC check. */
391 * Common code for streaming or seeking modes.
394 * from entry bodies, and common API.
403 /* Used by "ignorecrc32" option to speed up tests. */
430 {12, "bzip"}, /* File is compressed using BZIP2 algorithm */
453 if (compression_methods[i].id == compression)
454 return compression_methods[i].name;
460 /* Convert an MSDOS-style date/time into Unix-style time. */
471 ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
472 ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
473 ts.tm_mday = msDate & 0x1f; /* Day of month. */
474 ts.tm_hour = (msTime >> 11) & 0x1f;
475 ts.tm_min = (msTime >> 5) & 0x3f;
476 ts.tm_sec = (msTime << 1) & 0x3e;
477 ts.tm_isdst = -1;
483 * id1+size1+data1 + id2+size2+data2 ...
484 * triplets. id and size are 2 bytes each.
499 /* Some ZIP files may have trailing 0 bytes. Let's check they
500 * are all 0 and ignore them instead of returning an error.
504 * also support them.
539 /* Zip64 extended information extra field. */
588 * multi-volume Zip files. */
593 /* Strong encryption field. */
609 /* Extended time field "UT". */
620 /* Flag bits indicate which dates are present. */
654 /* Info-ZIP Unix Extra Field (old version) "UX". */
675 * central directory) in local file header.
678 * streaming extraction. Currently being
680 * ... subject to change.
684 * which additional fields are included. The
686 * the future.
689 * 7 bits. If high-order bit is set, a subsequent
690 * byte holds the next 7 bits, etc.
706 /* We only support first 7 bits of bitmap; skip rest. */
730 /* Not used by libarchive at present. */
787 /* Info-ZIP Unicode Path Extra Field. */
794 * in UTF-8. */
801 * field will more likely be correct. */
806 /* Make sure the CRC32 of the filename matches. */
830 * name from the main field. */
833 "0x7075 extra field path.\n");
839 /* Info-ZIP Unix Extra Field (type 2) "Ux". */
853 /* Info-Zip Unix Extra Field (type 3) "ux". */
856 /* TODO: support arbitrary uidsize/gidsize. */
859 /* get a uid size. */
871 /* get a gid size. */
888 /* WinZip AES extra data field. */
896 /* Vendor version. */
897 zip_entry->aes_extra.vendor =
899 /* AES encryption strength. */
900 zip_entry->aes_extra.strength = p[offset + 4];
901 /* Actual compression method. */
902 zip_entry->aes_extra.compression =
915 * Assumes file pointer is at beginning of local file header.
932 /* Save a copy of the original for consistency checks. */
941 /* Setup default conversion. */
986 /* Read the filename. */
993 /* The filename is stored to be UTF-8. */
1017 "from %s to current locale.",
1023 /* Read the extra data. */
1037 * stats the pipe instead of synthesizing a file entry. */
1043 /* If the mode is totally empty, set some sane default. */
1049 * separator. Normalize to slash. */
1058 if (s.s[i] == '\\')
1059 s.s[i] = '/';
1061 archive_entry_copy_pathname_w(entry, s.s);
1067 * even if the External File Attributes contains bogus values. If this
1068 * is not a directory and there is no type, assume a regular file. */
1081 /* Correct file type as needed. */
1101 archive_entry_copy_pathname_w(entry, s.s);
1112 archive_entry_set_pathname(entry, s.s);
1120 * is definitive, so ignore the length-at-end flag. */
1123 the central directory. If both have it, warn about
1124 mismatches. */
1126 zip_entry->crc32 = zip_entry_central_dir.crc32;
1128 && zip_entry->crc32 != zip_entry_central_dir.crc32) {
1136 = zip_entry_central_dir.compressed_size;
1138 != zip_entry_central_dir.compressed_size) {
1143 (intmax_t)zip_entry_central_dir.compressed_size,
1149 = zip_entry_central_dir.uncompressed_size;
1151 != zip_entry_central_dir.uncompressed_size) {
1156 (intmax_t)zip_entry_central_dir.uncompressed_size,
1194 case 8: /* Deflate compression. */
1201 case 14: /* ZIPx LZMA compression. */
1202 /*(see zip file format specification, section 4.4.5)*/
1208 default: /* Unsupported compression. */
1256 * in an automatic conversion.
1263 "from %s to current locale.",
1278 /* Set the size only if it's meaningful. */
1283 /* If there's no body, force read_data() to return EOF immediately. */
1288 /* Set up a more descriptive format name. */
1290 archive_string_sprintf(&zip->format_name, "ZIP %d.%d (%s)",
1293 a->archive.archive_format_name = zip->format_name.s;
1303 /* Check authentication code. */
1312 /* Read authentication code. */
1336 * Read "uncompressed" data. There are three cases:
1337 * 1) We know the size of the data. This is always true for the
1338 * seeking reader (we've examined the Central Directory already).
1339 * 2) ZIP_LENGTH_AT_END was set, but only the CRC was deferred.
1341 * the CRC from the data descriptor afterwards.
1343 * we have no size information. In this case, we can do pretty
1344 * well by watching for the data descriptor record. The data
1346 * provide a strong check.
1348 * TODO: Technically, the PK\007\010 signature is optional.
1350 * and size fields but had no leading signature. In practice,
1351 * newer writers seem to provide the signature pretty consistently.
1354 * to be sure we've actually seen the end of the entry.
1357 * zip->end_of_entry if it consumes all of the data.
1378 /* Grab at least 24 bytes. */
1384 file. */
1391 * by the correct 4-byte CRC. */
1400 && zip->entry->aes_extra.vendor == AES_VENDOR_AE_2))) {
1432 /* If not at EOF, ensure we consume at least one byte. */
1436 * might be. */
1437 /* Return bytes up until that point. On the next call,
1438 * the code above will verify the data descriptor. */
1461 /* Grab a bunch of bytes. */
1513 /* Consume the optional PK\007\010 marker. */
1602 /* To unpack ZIPX's "LZMA" (id 14) stream we can use standard liblzma
1603 * that is a part of XZ Utils. The stream format stored inside ZIPX
1605 * `lzma` utility which was later deprecated in favour of `xz` utility.
1607 * "lzma alone" decoder from XZ Utils. */
1619 * to be freed later. */
1622 /* The "lzma alone" file format and the stream format inside ZIPx are
1623 * almost the same. Here's an example of a structure of "lzma alone"
1630 * <lzma_params><uncompressed_size><data...>
1633 * parameters of this LZMA stream. The uncompressed_size field is an
1635 * uncompressed file, or UINT64_MAX if this value is unknown.
1636 * The <data...> part is the actual lzma-compressed data stream.
1638 * Now here's the structure of the stream inside the ZIPX file:
1641 * 00000000: 0914 0500 5d00 8000 0000 2814 .... ....
1644 * <magic1><magic2><lzma_params><data...>
1646 * This means that the ZIPX file contains an additional magic1 and
1648 * set as in the "lzma alone" format, and the <data...> field is the
1649 * same as in the "lzma alone" format as well. Note that also the zipx
1650 * format is missing the uncompressed_size field.
1652 * So, in order to use the "lzma alone" decoder for the zipx lzma
1656 * zipx lzma stream into the decoder.
1659 /* Read magic1,magic2,lzma_params from the ZIPX stream. */
1673 * a proper place into the lzma alone header. */
1674 memcpy(&alone_header.bytes[0], p + 4, 5);
1677 * monitor how many bytes there are still to be uncompressed. */
1678 alone_header.uncompressed_size = UINT64_MAX;
1692 zip->zipx_lzma_stream.next_in = (void*) &alone_header;
1693 zip->zipx_lzma_stream.avail_in = sizeof(alone_header);
1694 zip->zipx_lzma_stream.total_in = 0;
1695 zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
1696 zip->zipx_lzma_stream.avail_out = zip->uncompressed_buffer_size;
1697 zip->zipx_lzma_stream.total_out = 0;
1699 /* Feed only the header into the lzma alone decoder. This will
1701 * output bytes yet. */
1709 /* We've already consumed some bytes, so take this into account. */
1730 /* Initialize decompressor if not yet initialized. */
1745 zip->zipx_lzma_stream.next_in = compressed_buf;
1746 zip->zipx_lzma_stream.avail_in = in_bytes;
1747 zip->zipx_lzma_stream.total_in = 0;
1748 zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
1749 zip->zipx_lzma_stream.avail_out = zip->uncompressed_buffer_size;
1750 zip->zipx_lzma_stream.total_out = 0;
1752 /* Perform the decompression. */
1773 if((int64_t) zip->zipx_lzma_stream.total_in !=
1786 to_consume = zip->zipx_lzma_stream.total_in;
1791 zip->entry_uncompressed_bytes_read += zip->zipx_lzma_stream.total_out;
1793 *size = zip->zipx_lzma_stream.total_out;
1815 /* Initialize decompressor if not yet initialized. */
1822 /* Fetch more compressed data. The same note as in deflate handler
1825 * Note: '1' here is a performance optimization. Recall that the
1828 * data.
1837 /* Set decompressor parameters. */
1840 zip->zipx_lzma_stream.next_in = compressed_buf;
1841 zip->zipx_lzma_stream.avail_in = in_bytes;
1842 zip->zipx_lzma_stream.total_in = 0;
1843 zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
1844 zip->zipx_lzma_stream.avail_out =
1847 * supposed to. */
1851 zip->zipx_lzma_stream.total_out = 0;
1853 /* Perform the decompression. */
1861 /* This case is optional in lzma alone format. It can happen,
1862 * but most of the files don't have it. (GitHub #1257) */
1866 if((int64_t) zip->zipx_lzma_stream.total_in !=
1887 to_consume = zip->zipx_lzma_stream.total_in;
1889 /* Update pointers. */
1893 zip->entry_uncompressed_bytes_read += zip->zipx_lzma_stream.total_out;
1899 /* Return values. */
1900 *size = zip->zipx_lzma_stream.total_out;
1903 /* Behave the same way as during deflate decompression. */
1908 /* Free lzma decoder handle because we'll no longer need it. */
1928 /* Remove previous decompression context if it exists. */
1930 __archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
1934 /* Create a new decompression context. */
1935 __archive_ppmd8_functions.Ppmd8_Construct(&zip->ppmd8);
1938 /* Setup function pointers required by Ppmd8 decompressor. The
1940 * and will increment the 'zip->zipx_ppmd_read_compressed' counter. */
1941 zip->ppmd8.Stream.In = &zip->zipx_ppmd_stream;
1942 zip->zipx_ppmd_stream.a = a;
1943 zip->zipx_ppmd_stream.Read = &ppmd_read;
1945 /* Reset number of read bytes to 0. */
1948 /* Read Ppmd8 header (2 bytes). */
1957 /* Decode the stream's compression parameters. */
1970 /* Allocate the memory needed to properly decompress the file. */
1971 if(!__archive_ppmd8_functions.Ppmd8_Alloc(&zip->ppmd8, mem << 20)) {
1979 * cleanup phase. */
1982 /* Perform further Ppmd8 initialization. */
1983 if(!__archive_ppmd8_functions.Ppmd8_RangeDec_Init(&zip->ppmd8)) {
1989 __archive_ppmd8_functions.Ppmd8_Init(&zip->ppmd8, order,
1992 /* Allocate the buffer that will hold uncompressed data. */
2005 /* Ppmd8 initialization is done. */
2008 /* We've already read 2 bytes in the output stream. Additionally,
2009 * Ppmd8 initialization code could read some data as well. So we
2011 * bytes Ppmd8 init function used. */
2029 * context first. */
2036 /* Fetch for more data. We're reading 1 byte here, but libarchive
2037 * should prefetch more bytes. */
2046 * point will be called by Ppmd8_DecodeSymbol. */
2049 /* Decompression loop. */
2051 int sym = __archive_ppmd8_functions.Ppmd8_DecodeSymbol(
2059 * to be read. */
2071 /* Update pointers for libarchive. */
2075 /* Update pointers so we can continue decompression in another call. */
2080 /* If we're at the end of stream, deinitialize Ppmd8 context. */
2082 __archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
2086 /* Seek for optional marker, same way as in each zip entry. */
2101 * exists. */
2107 /* Allocate a new BZ2 decompression context. */
2112 "bzip2 initialization failed(%d)",
2118 /* Mark the bzstream field to be released in cleanup phase. */
2121 /* (Re)allocate the buffer that will contain decompressed bytes. */
2129 "No memory for bzip2 decompression");
2133 /* Initialization done. */
2150 /* Initialize decompression context if we're here for the first time. */
2157 /* Fetch more compressed bytes. */
2161 "Truncated bzip2 file body");
2167 /* libbz2 doesn't complain when caller feeds avail_in == 0.
2169 * undesirable. This is why we need to make this check
2170 * manually. */
2173 "Truncated bzip2 file body");
2177 /* Setup buffer boundaries. */
2178 zip->bzstream.next_in = (char*)(uintptr_t) compressed_buff;
2179 zip->bzstream.avail_in = in_bytes;
2180 zip->bzstream.total_in_hi32 = 0;
2181 zip->bzstream.total_in_lo32 = 0;
2182 zip->bzstream.next_out = (char*) zip->uncompressed_buffer;
2183 zip->bzstream.avail_out = zip->uncompressed_buffer_size;
2184 zip->bzstream.total_out_hi32 = 0;
2185 zip->bzstream.total_out_lo32 = 0;
2187 /* Perform the decompression. */
2192 * decompression context now. */
2199 "Failed to clean up bzip2 "
2208 * chunk of data, but more data is still in queue. */
2212 "bzip2 decompression failed");
2216 /* Update the pointers so decompressor can continue decoding. */
2217 to_consume = zip->bzstream.total_in_lo32;
2220 total_out = ((uint64_t) zip->bzstream.total_out_hi32 << 32) +
2221 zip->bzstream.total_out_lo32;
2227 /* Give libarchive its due. */
2231 /* Seek for optional marker, like in other entries. */
2247 /* If we haven't yet read any data, initialize the decompressor. */
2256 "Can't initialize ZIP decompression.");
2259 /* Stream structure has been set up. */
2261 /* We've initialized decompression for this stream. */
2280 /* If the buffer hasn't been allocated, allocate it now. */
2297 * Note: '1' here is a performance optimization.
2300 * decompressor to combine reads by copying data.
2363 * A bug in zlib.h: stream.next_in should be marked 'const'
2365 * next_in pointer, only reads it). The result: this ugly
2366 * cast to remove 'const'.
2368 zip->stream.next_in = (Bytef *)(uintptr_t)(const void *)compressed_buff;
2369 zip->stream.avail_in = (uInt)bytes_avail;
2370 zip->stream.total_in = 0;
2371 zip->stream.next_out = zip->uncompressed_buffer;
2372 zip->stream.avail_out = (uInt)zip->uncompressed_buffer_size;
2373 zip->stream.total_out = 0;
2392 /* Consume as much as the compressor actually used. */
2393 bytes_avail = zip->stream.total_in;
2401 /* Calculate compressed data as much as we used.*/
2408 *size = zip->stream.total_out;
2409 zip->entry_uncompressed_bytes_read += zip->stream.total_out;
2435 * Read an initialization vector data field.
2459 * Read a size of remaining decryption header field.
2468 /* Check if format version is supported. */
2478 * Read an encryption algorithm field.
2493 /* Supported encryption algorithm. */
2503 * Read a bit length field.
2508 * Read a flags field.
2512 case 0x0001: /* Password is required to decrypt. */
2513 case 0x0002: /* Certificates only. */
2514 case 0x0003: /* Password or certificate required to decrypt. */
2531 * Read an encrypted random data field.
2557 * Read a reserved data field.
2562 /* Reserved data size should be zero. */
2568 * Read a password validation data field.
2602 * This is not fully implemented yet.*/
2652 the start of the data area.
2684 * Initialize ctx for Traditional PKWARE Decryption.
2689 break;/* The passphrase is OK. */
2691 /* Avoid infinity loop. */
2725 switch (zip->entry->aes_extra.strength) {
2756 /* Check password verification value. */
2760 break;/* The passphrase is OK. */
2762 /* Avoid infinity loop. */
2791 zip->entry->compression = zip->entry->aes_extra.compression;
2820 /* If we hit end-of-entry last time, return ARCHIVE_EOF. */
2824 /* Return EOF immediately if this is a non-regular file. */
2845 case 0: /* No compression. */
2849 case 12: /* ZIPx bzip2 compression. */
2854 case 14: /* ZIPx LZMA compression. */
2857 case 95: /* ZIPx XZ compression. */
2861 /* PPMd support is built-in, so we don't need any #if guards. */
2862 case 98: /* ZIPx PPMd compression. */
2867 case 8: /* Deflate compression. */
2871 default: /* Unsupported compression. */
2872 /* Return a warning. */
2877 * be able to skip() it and try the next entry. */
2887 /* If we hit the end, swallow any end-of-data marker. */
2889 /* Check file size, CRC against these values. */
2900 * size. */
2912 zip->entry->aes_extra.vendor != AES_VENDOR_AE_2) &&
2954 __archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
3000 /* Handle filenames as libarchive 2.x */
3020 /* Mostly useful for testing. */
3035 * supervisor that we didn't handle it. It will generate
3036 * a suitable error if no one used this option. */
3081 * So we've effectively verified ~29 total bits of check data.
3094 * PK signature. In particular, that would make it possible
3096 * a network socket. */
3107 a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
3108 if (a->archive.archive_format_name == NULL)
3109 a->archive.archive_format_name = "ZIP";
3115 * a reader to determine if an entry is encrypted or not. If the
3117 * archive_read_data(), so be it. We'll do the same check there
3118 * as well.
3124 /* Make sure we have a zip_entry structure to use. */
3143 /* Search ahead for the next local file header. */
3159 /* Regular file entry. */
3167 * based only on the local file headers.
3170 * entries for at least directories.
3172 * directory permissions.
3176 * permissions, either. <sigh>
3183 * empty archive. */
3207 /* If we've already read to end of data, we're done. */
3211 /* So we know we're streaming... */
3214 /* We know the compressed length, so we can just skip. */
3237 /* We're streaming and we don't know the length. */
3239 * find an exact end-of-entry by decompressing it. */
3242 case 8: /* Deflate compression. */
3254 default: /* Uncompressed or unknown. */
3255 /* Scan for a PK\007\010 signature. */
3304 /* Streamable reader doesn't support mac extensions. */
3309 * any encrypted entries yet.
3349 * be re-read again if this bidder loses.
3353 * outbid. But we can certainly do better...
3365 /* Sanity-check the EOCD we've found. */
3367 /* This must be the first volume. */
3370 /* Central directory must be on this volume. */
3373 /* All central directory entries must be on this volume. */
3376 /* Central directory can't extend beyond start of EOCD record. */
3380 /* Save the central directory location for later use. */
3385 returned by the streaming Zip bidder. This ensures
3387 whenever seek is available. */
3393 * from it.
3401 /* Sanity-check the locator record. */
3403 /* Central dir must be on first volume. */
3406 /* Must be only a single volume. */
3410 /* Find the Zip64 EOCD record. */
3416 /* Make sure we can read all of it. */
3428 /* CD can't be split. */
3432 /* Save the central directory offset for later use. */
3449 trashing the look-ahead buffers with a seek. */
3468 * within this Zip archive). */
3476 * regular EOCD if present. */
3496 * the in-memory copy of the central directory. */
3531 return (strcmp(e2->rsrcname.s, e1->rsrcname.s));
3538 return (strcmp((const char *)key, e->rsrcname.s));
3570 s = strrchr(str.s, '/');
3575 * tree to zip->tree RB tree to expose. */
3577 __archive_rb_tree_find_node(&zip->tree_rsrc, str.s);
3598 * Find the start of the central directory. The end-of-CD
3601 * file, which makes the recorded offsets all too small.
3603 * find the real start of the central directory. Then we
3605 * padding.
3701 * Better be zero.
3710 more information. */
3729 * extra data. */
3747 * it is.
3750 /* Treat every entry as a regular entry. */
3759 * a directory. We should treat it as a non
3760 * resource fork file to expose it. */
3762 (r - name < 3 || r[0] != '.' ||
3766 /* Expose its parent directories. */
3771 * a directory. */
3779 * resource file at zip->tree_rsrc. */
3784 archive_strcat(&(zip_entry->rsrcname), "._");
3789 * file offset. */
3795 /* Skip the comment too ... */
3838 case 0: /* No compression. */
3847 case 8: /* Deflate compression. */
3850 default: /* Unsupported compression. */
3851 /* Return a warning. */
3856 * be able to skip() it and try the next entry. */
3909 case 0: /* No compression. */
3920 case 8: /* Deflate compression. */
3927 zip->stream.next_in =
3929 zip->stream.avail_in = (uInt)bytes_avail;
3930 zip->stream.total_in = 0;
3931 zip->stream.next_out = mp;
3932 zip->stream.avail_out = (uInt)metadata_bytes;
3933 zip->stream.total_out = 0;
3954 bytes_used = zip->stream.total_in;
3955 metadata_bytes -= zip->stream.total_out;
3956 mp += zip->stream.total_out;
3988 * a reader to determine if an entry is encrypted or not. If the
3990 * archive_read_data(), so be it. We'll do the same check there
3991 * as well.
3997 a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
3998 if (a->archive.archive_format_name == NULL)
3999 a->archive.archive_format_name = "ZIP";
4006 * other entries in the archive file. */
4010 /* Get next entry in local header offset order. */
4018 if (zip->entry->rsrcname.s)
4020 &zip->tree_rsrc, zip->entry->rsrcname.s);
4033 * redundant data reading. */
4056 * need to bother doing anything here.
4086 /* Set this by default on Mac OS. */
4092 * any encrypted entries yet.