Subversion Repositories Games.Descent

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * ZIP support routines for PhysicsFS.
  3.  *
  4.  * Please see the file LICENSE.txt in the source's root directory.
  5.  *
  6.  *  This file written by Ryan C. Gordon, with some peeking at "unzip.c"
  7.  *   by Gilles Vollant.
  8.  */
  9.  
  10. #define __PHYSICSFS_INTERNAL__
  11. #include "physfs_internal.h"
  12.  
  13. #if PHYSFS_SUPPORTS_ZIP
  14.  
  15. #include <errno.h>
  16. #include <time.h>
  17.  
  18. #include "physfs_miniz.h"
  19.  
  20. /*
  21.  * A buffer of ZIP_READBUFSIZE is allocated for each compressed file opened,
  22.  *  and is freed when you close the file; compressed data is read into
  23.  *  this buffer, and then is decompressed into the buffer passed to
  24.  *  PHYSFS_read().
  25.  *
  26.  * Uncompressed entries in a zipfile do not allocate this buffer; they just
  27.  *  read data directly into the buffer passed to PHYSFS_read().
  28.  *
  29.  * Depending on your speed and memory requirements, you should tweak this
  30.  *  value.
  31.  */
  32. #define ZIP_READBUFSIZE   (16 * 1024)
  33.  
  34.  
  35. /*
  36.  * Entries are "unresolved" until they are first opened. At that time,
  37.  *  local file headers parsed/validated, data offsets will be updated to look
  38.  *  at the actual file data instead of the header, and symlinks will be
  39.  *  followed and optimized. This means that we don't seek and read around the
  40.  *  archive until forced to do so, and after the first time, we had to do
  41.  *  less reading and parsing, which is very CD-ROM friendly.
  42.  */
  43. typedef enum
  44. {
  45.     ZIP_UNRESOLVED_FILE,
  46.     ZIP_UNRESOLVED_SYMLINK,
  47.     ZIP_RESOLVING,
  48.     ZIP_RESOLVED,
  49.     ZIP_DIRECTORY,
  50.     ZIP_BROKEN_FILE,
  51.     ZIP_BROKEN_SYMLINK
  52. } ZipResolveType;
  53.  
  54.  
  55. /*
  56.  * One ZIPentry is kept for each file in an open ZIP archive.
  57.  */
  58. typedef struct _ZIPentry
  59. {
  60.     __PHYSFS_DirTreeEntry tree;         /* manages directory tree         */
  61.     struct _ZIPentry *symlink;          /* NULL or file we symlink to     */
  62.     ZipResolveType resolved;            /* Have we resolved file/symlink? */
  63.     PHYSFS_uint64 offset;               /* offset of data in archive      */
  64.     PHYSFS_uint16 version;              /* version made by                */
  65.     PHYSFS_uint16 version_needed;       /* version needed to extract      */
  66.     PHYSFS_uint16 general_bits;         /* general purpose bits           */
  67.     PHYSFS_uint16 compression_method;   /* compression method             */
  68.     PHYSFS_uint32 crc;                  /* crc-32                         */
  69.     PHYSFS_uint64 compressed_size;      /* compressed size                */
  70.     PHYSFS_uint64 uncompressed_size;    /* uncompressed size              */
  71.     PHYSFS_sint64 last_mod_time;        /* last file mod time             */
  72.     PHYSFS_uint32 dos_mod_time;         /* original MS-DOS style mod time */
  73. } ZIPentry;
  74.  
  75. /*
  76.  * One ZIPinfo is kept for each open ZIP archive.
  77.  */
  78. typedef struct
  79. {
  80.     __PHYSFS_DirTree tree;    /* manages directory tree.                */
  81.     PHYSFS_Io *io;            /* the i/o interface for this archive.    */
  82.     int zip64;                /* non-zero if this is a Zip64 archive.   */
  83.     int has_crypto;           /* non-zero if any entry uses encryption. */
  84. } ZIPinfo;
  85.  
  86. /*
  87.  * One ZIPfileinfo is kept for each open file in a ZIP archive.
  88.  */
  89. typedef struct
  90. {
  91.     ZIPentry *entry;                      /* Info on file.              */
  92.     PHYSFS_Io *io;                        /* physical file handle.      */
  93.     PHYSFS_uint32 compressed_position;    /* offset in compressed data. */
  94.     PHYSFS_uint32 uncompressed_position;  /* tell() position.           */
  95.     PHYSFS_uint8 *buffer;                 /* decompression buffer.      */
  96.     PHYSFS_uint32 crypto_keys[3];         /* for "traditional" crypto.  */
  97.     PHYSFS_uint32 initial_crypto_keys[3]; /* for "traditional" crypto.  */
  98.     z_stream stream;                      /* zlib stream state.         */
  99. } ZIPfileinfo;
  100.  
  101.  
  102. /* Magic numbers... */
  103. #define ZIP_LOCAL_FILE_SIG                          0x04034b50
  104. #define ZIP_CENTRAL_DIR_SIG                         0x02014b50
  105. #define ZIP_END_OF_CENTRAL_DIR_SIG                  0x06054b50
  106. #define ZIP64_END_OF_CENTRAL_DIR_SIG                0x06064b50
  107. #define ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG  0x07064b50
  108. #define ZIP64_EXTENDED_INFO_EXTRA_FIELD_SIG         0x0001
  109.  
  110. /* compression methods... */
  111. #define COMPMETH_NONE 0
  112. /* ...and others... */
  113.  
  114.  
  115. #define UNIX_FILETYPE_MASK    0170000
  116. #define UNIX_FILETYPE_SYMLINK 0120000
  117.  
  118. #define ZIP_GENERAL_BITS_TRADITIONAL_CRYPTO   (1 << 0)
  119. #define ZIP_GENERAL_BITS_IGNORE_LOCAL_HEADER  (1 << 3)
  120.  
  121. /* support for "traditional" PKWARE encryption. */
  122. static int zip_entry_is_tradional_crypto(const ZIPentry *entry)
  123. {
  124.     return (entry->general_bits & ZIP_GENERAL_BITS_TRADITIONAL_CRYPTO) != 0;
  125. } /* zip_entry_is_traditional_crypto */
  126.  
  127. static int zip_entry_ignore_local_header(const ZIPentry *entry)
  128. {
  129.     return (entry->general_bits & ZIP_GENERAL_BITS_IGNORE_LOCAL_HEADER) != 0;
  130. } /* zip_entry_is_traditional_crypto */
  131.  
  132. static PHYSFS_uint32 zip_crypto_crc32(const PHYSFS_uint32 crc, const PHYSFS_uint8 val)
  133. {
  134.     int i;
  135.     PHYSFS_uint32 xorval = (crc ^ ((PHYSFS_uint32) val)) & 0xFF;
  136.     for (i = 0; i < 8; i++)
  137.         xorval = ((xorval & 1) ? (0xEDB88320 ^ (xorval >> 1)) : (xorval >> 1));
  138.     return xorval ^ (crc >> 8);
  139. } /* zip_crc32 */
  140.  
  141. static void zip_update_crypto_keys(PHYSFS_uint32 *keys, const PHYSFS_uint8 val)
  142. {
  143.     keys[0] = zip_crypto_crc32(keys[0], val);
  144.     keys[1] = keys[1] + (keys[0] & 0x000000FF);
  145.     keys[1] = (keys[1] * 134775813) + 1;
  146.     keys[2] = zip_crypto_crc32(keys[2], (PHYSFS_uint8) ((keys[1] >> 24) & 0xFF));
  147. } /* zip_update_crypto_keys */
  148.  
  149. static PHYSFS_uint8 zip_decrypt_byte(const PHYSFS_uint32 *keys)
  150. {
  151.     const PHYSFS_uint16 tmp = keys[2] | 2;
  152.     return (PHYSFS_uint8) ((tmp * (tmp ^ 1)) >> 8);
  153. } /* zip_decrypt_byte */
  154.  
  155. static PHYSFS_sint64 zip_read_decrypt(ZIPfileinfo *finfo, void *buf, PHYSFS_uint64 len)
  156. {
  157.     PHYSFS_Io *io = finfo->io;
  158.     const PHYSFS_sint64 br = io->read(io, buf, len);
  159.  
  160.     /* Decompression the new data if necessary. */
  161.     if (zip_entry_is_tradional_crypto(finfo->entry) && (br > 0))
  162.     {
  163.         PHYSFS_uint32 *keys = finfo->crypto_keys;
  164.         PHYSFS_uint8 *ptr = (PHYSFS_uint8 *) buf;
  165.         PHYSFS_sint64 i;
  166.         for (i = 0; i < br; i++, ptr++)
  167.         {
  168.             const PHYSFS_uint8 ch = *ptr ^ zip_decrypt_byte(keys);
  169.             zip_update_crypto_keys(keys, ch);
  170.             *ptr = ch;
  171.         } /* for */
  172.     } /* if  */
  173.  
  174.     return br;
  175. } /* zip_read_decrypt */
  176.  
  177. static int zip_prep_crypto_keys(ZIPfileinfo *finfo, const PHYSFS_uint8 *crypto_header, const PHYSFS_uint8 *password)
  178. {
  179.     /* It doesn't appear to be documented in PKWare's APPNOTE.TXT, but you
  180.        need to use a different byte in the header to verify the password
  181.        if general purpose bit 3 is set. Discovered this from Info-Zip.
  182.        That's what the (verifier) value is doing, below. */
  183.  
  184.     PHYSFS_uint32 *keys = finfo->crypto_keys;
  185.     const ZIPentry *entry = finfo->entry;
  186.     const int usedate = zip_entry_ignore_local_header(entry);
  187.     const PHYSFS_uint8 verifier = (PHYSFS_uint8) ((usedate ? (entry->dos_mod_time >> 8) : (entry->crc >> 24)) & 0xFF);
  188.     PHYSFS_uint8 finalbyte = 0;
  189.     int i = 0;
  190.  
  191.     /* initialize vector with defaults, then password, then header. */
  192.     keys[0] = 305419896;
  193.     keys[1] = 591751049;
  194.     keys[2] = 878082192;
  195.  
  196.     while (*password)
  197.         zip_update_crypto_keys(keys, *(password++));
  198.  
  199.     for (i = 0; i < 12; i++)
  200.     {
  201.         const PHYSFS_uint8 c = crypto_header[i] ^ zip_decrypt_byte(keys);
  202.         zip_update_crypto_keys(keys, c);
  203.         finalbyte = c;
  204.     } /* for */
  205.  
  206.     /* you have a 1/256 chance of passing this test incorrectly. :/ */
  207.     if (finalbyte != verifier)
  208.         BAIL(PHYSFS_ERR_BAD_PASSWORD, 0);
  209.  
  210.     /* save the initial vector for seeking purposes. Not secure!! */
  211.     memcpy(finfo->initial_crypto_keys, finfo->crypto_keys, 12);
  212.     return 1;
  213. } /* zip_prep_crypto_keys */
  214.  
  215.  
  216. /*
  217.  * Bridge physfs allocation functions to zlib's format...
  218.  */
  219. static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size)
  220. {
  221.     return ((PHYSFS_Allocator *) opaque)->Malloc(items * size);
  222. } /* zlibPhysfsAlloc */
  223.  
  224. /*
  225.  * Bridge physfs allocation functions to zlib's format...
  226.  */
  227. static void zlibPhysfsFree(voidpf opaque, voidpf address)
  228. {
  229.     ((PHYSFS_Allocator *) opaque)->Free(address);
  230. } /* zlibPhysfsFree */
  231.  
  232.  
  233. /*
  234.  * Construct a new z_stream to a sane state.
  235.  */
  236. static void initializeZStream(z_stream *pstr)
  237. {
  238.     memset(pstr, '\0', sizeof (z_stream));
  239.     pstr->zalloc = zlibPhysfsAlloc;
  240.     pstr->zfree = zlibPhysfsFree;
  241.     pstr->opaque = &allocator;
  242. } /* initializeZStream */
  243.  
  244.  
  245. static PHYSFS_ErrorCode zlib_error_code(int rc)
  246. {
  247.     switch (rc)
  248.     {
  249.         case Z_OK: return PHYSFS_ERR_OK;  /* not an error. */
  250.         case Z_STREAM_END: return PHYSFS_ERR_OK; /* not an error. */
  251.         case Z_ERRNO: return PHYSFS_ERR_IO;
  252.         case Z_MEM_ERROR: return PHYSFS_ERR_OUT_OF_MEMORY;
  253.         default: return PHYSFS_ERR_CORRUPT;
  254.     } /* switch */
  255. } /* zlib_error_string */
  256.  
  257.  
  258. /*
  259.  * Wrap all zlib calls in this, so the physfs error state is set appropriately.
  260.  */
  261. static int zlib_err(const int rc)
  262. {
  263.     PHYSFS_setErrorCode(zlib_error_code(rc));
  264.     return rc;
  265. } /* zlib_err */
  266.  
  267. /*
  268.  * Read an unsigned 64-bit int and swap to native byte order.
  269.  */
  270. static int readui64(PHYSFS_Io *io, PHYSFS_uint64 *val)
  271. {
  272.     PHYSFS_uint64 v;
  273.     BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
  274.     *val = PHYSFS_swapULE64(v);
  275.     return 1;
  276. } /* readui64 */
  277.  
  278. /*
  279.  * Read an unsigned 32-bit int and swap to native byte order.
  280.  */
  281. static int readui32(PHYSFS_Io *io, PHYSFS_uint32 *val)
  282. {
  283.     PHYSFS_uint32 v;
  284.     BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
  285.     *val = PHYSFS_swapULE32(v);
  286.     return 1;
  287. } /* readui32 */
  288.  
  289.  
  290. /*
  291.  * Read an unsigned 16-bit int and swap to native byte order.
  292.  */
  293. static int readui16(PHYSFS_Io *io, PHYSFS_uint16 *val)
  294. {
  295.     PHYSFS_uint16 v;
  296.     BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
  297.     *val = PHYSFS_swapULE16(v);
  298.     return 1;
  299. } /* readui16 */
  300.  
  301.  
  302. static PHYSFS_sint64 ZIP_read(PHYSFS_Io *_io, void *buf, PHYSFS_uint64 len)
  303. {
  304.     ZIPfileinfo *finfo = (ZIPfileinfo *) _io->opaque;
  305.     ZIPentry *entry = finfo->entry;
  306.     PHYSFS_sint64 retval = 0;
  307.     PHYSFS_sint64 maxread = (PHYSFS_sint64) len;
  308.     PHYSFS_sint64 avail = entry->uncompressed_size -
  309.                           finfo->uncompressed_position;
  310.  
  311.     if (avail < maxread)
  312.         maxread = avail;
  313.  
  314.     BAIL_IF_ERRPASS(maxread == 0, 0);    /* quick rejection. */
  315.  
  316.     if (entry->compression_method == COMPMETH_NONE)
  317.         retval = zip_read_decrypt(finfo, buf, maxread);
  318.     else
  319.     {
  320.         finfo->stream.next_out = buf;
  321.         finfo->stream.avail_out = (uInt) maxread;
  322.  
  323.         while (retval < maxread)
  324.         {
  325.             const PHYSFS_uint32 before = (PHYSFS_uint32) finfo->stream.total_out;
  326.             int rc;
  327.  
  328.             if (finfo->stream.avail_in == 0)
  329.             {
  330.                 PHYSFS_sint64 br;
  331.  
  332.                 br = entry->compressed_size - finfo->compressed_position;
  333.                 if (br > 0)
  334.                 {
  335.                     if (br > ZIP_READBUFSIZE)
  336.                         br = ZIP_READBUFSIZE;
  337.  
  338.                     br = zip_read_decrypt(finfo, finfo->buffer, (PHYSFS_uint64) br);
  339.                     if (br <= 0)
  340.                         break;
  341.  
  342.                     finfo->compressed_position += (PHYSFS_uint32) br;
  343.                     finfo->stream.next_in = finfo->buffer;
  344.                     finfo->stream.avail_in = (unsigned int) br;
  345.                 } /* if */
  346.             } /* if */
  347.  
  348.             rc = zlib_err(inflate(&finfo->stream, Z_SYNC_FLUSH));
  349.             retval += (finfo->stream.total_out - before);
  350.  
  351.             if (rc != Z_OK)
  352.                 break;
  353.         } /* while */
  354.     } /* else */
  355.  
  356.     if (retval > 0)
  357.         finfo->uncompressed_position += (PHYSFS_uint32) retval;
  358.  
  359.     return retval;
  360. } /* ZIP_read */
  361.  
  362.  
  363. static PHYSFS_sint64 ZIP_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)
  364. {
  365.     BAIL(PHYSFS_ERR_READ_ONLY, -1);
  366. } /* ZIP_write */
  367.  
  368.  
  369. static PHYSFS_sint64 ZIP_tell(PHYSFS_Io *io)
  370. {
  371.     return ((ZIPfileinfo *) io->opaque)->uncompressed_position;
  372. } /* ZIP_tell */
  373.  
  374.  
  375. static int ZIP_seek(PHYSFS_Io *_io, PHYSFS_uint64 offset)
  376. {
  377.     ZIPfileinfo *finfo = (ZIPfileinfo *) _io->opaque;
  378.     ZIPentry *entry = finfo->entry;
  379.     PHYSFS_Io *io = finfo->io;
  380.     const int encrypted = zip_entry_is_tradional_crypto(entry);
  381.  
  382.     BAIL_IF(offset > entry->uncompressed_size, PHYSFS_ERR_PAST_EOF, 0);
  383.  
  384.     if (!encrypted && (entry->compression_method == COMPMETH_NONE))
  385.     {
  386.         PHYSFS_sint64 newpos = offset + entry->offset;
  387.         BAIL_IF_ERRPASS(!io->seek(io, newpos), 0);
  388.         finfo->uncompressed_position = (PHYSFS_uint32) offset;
  389.     } /* if */
  390.  
  391.     else
  392.     {
  393.         /*
  394.          * If seeking backwards, we need to redecode the file
  395.          *  from the start and throw away the compressed bits until we hit
  396.          *  the offset we need. If seeking forward, we still need to
  397.          *  decode, but we don't rewind first.
  398.          */
  399.         if (offset < finfo->uncompressed_position)
  400.         {
  401.             /* we do a copy so state is sane if inflateInit2() fails. */
  402.             z_stream str;
  403.             initializeZStream(&str);
  404.             if (zlib_err(inflateInit2(&str, -MAX_WBITS)) != Z_OK)
  405.                 return 0;
  406.  
  407.             if (!io->seek(io, entry->offset + (encrypted ? 12 : 0)))
  408.                 return 0;
  409.  
  410.             inflateEnd(&finfo->stream);
  411.             memcpy(&finfo->stream, &str, sizeof (z_stream));
  412.             finfo->uncompressed_position = finfo->compressed_position = 0;
  413.  
  414.             if (encrypted)
  415.                 memcpy(finfo->crypto_keys, finfo->initial_crypto_keys, 12);
  416.         } /* if */
  417.  
  418.         while (finfo->uncompressed_position != offset)
  419.         {
  420.             PHYSFS_uint8 buf[512];
  421.             PHYSFS_uint32 maxread;
  422.  
  423.             maxread = (PHYSFS_uint32) (offset - finfo->uncompressed_position);
  424.             if (maxread > sizeof (buf))
  425.                 maxread = sizeof (buf);
  426.  
  427.             if (ZIP_read(_io, buf, maxread) != maxread)
  428.                 return 0;
  429.         } /* while */
  430.     } /* else */
  431.  
  432.     return 1;
  433. } /* ZIP_seek */
  434.  
  435.  
  436. static PHYSFS_sint64 ZIP_length(PHYSFS_Io *io)
  437. {
  438.     const ZIPfileinfo *finfo = (ZIPfileinfo *) io->opaque;
  439.     return (PHYSFS_sint64) finfo->entry->uncompressed_size;
  440. } /* ZIP_length */
  441.  
  442.  
  443. static PHYSFS_Io *zip_get_io(PHYSFS_Io *io, ZIPinfo *inf, ZIPentry *entry);
  444.  
  445. static PHYSFS_Io *ZIP_duplicate(PHYSFS_Io *io)
  446. {
  447.     ZIPfileinfo *origfinfo = (ZIPfileinfo *) io->opaque;
  448.     PHYSFS_Io *retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
  449.     ZIPfileinfo *finfo = (ZIPfileinfo *) allocator.Malloc(sizeof (ZIPfileinfo));
  450.     GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);
  451.     GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);
  452.     memset(finfo, '\0', sizeof (*finfo));
  453.  
  454.     finfo->entry = origfinfo->entry;
  455.     finfo->io = zip_get_io(origfinfo->io, NULL, finfo->entry);
  456.     GOTO_IF_ERRPASS(!finfo->io, failed);
  457.  
  458.     initializeZStream(&finfo->stream);
  459.     if (finfo->entry->compression_method != COMPMETH_NONE)
  460.     {
  461.         finfo->buffer = (PHYSFS_uint8 *) allocator.Malloc(ZIP_READBUFSIZE);
  462.         GOTO_IF(!finfo->buffer, PHYSFS_ERR_OUT_OF_MEMORY, failed);
  463.         if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)
  464.             goto failed;
  465.     } /* if */
  466.  
  467.     memcpy(retval, io, sizeof (PHYSFS_Io));
  468.     retval->opaque = finfo;
  469.     return retval;
  470.  
  471. failed:
  472.     if (finfo != NULL)
  473.     {
  474.         if (finfo->io != NULL)
  475.             finfo->io->destroy(finfo->io);
  476.  
  477.         if (finfo->buffer != NULL)
  478.         {
  479.             allocator.Free(finfo->buffer);
  480.             inflateEnd(&finfo->stream);
  481.         } /* if */
  482.  
  483.         allocator.Free(finfo);
  484.     } /* if */
  485.  
  486.     if (retval != NULL)
  487.         allocator.Free(retval);
  488.  
  489.     return NULL;
  490. } /* ZIP_duplicate */
  491.  
  492. static int ZIP_flush(PHYSFS_Io *io) { return 1;  /* no write support. */ }
  493.  
  494. static void ZIP_destroy(PHYSFS_Io *io)
  495. {
  496.     ZIPfileinfo *finfo = (ZIPfileinfo *) io->opaque;
  497.     finfo->io->destroy(finfo->io);
  498.  
  499.     if (finfo->entry->compression_method != COMPMETH_NONE)
  500.         inflateEnd(&finfo->stream);
  501.  
  502.     if (finfo->buffer != NULL)
  503.         allocator.Free(finfo->buffer);
  504.  
  505.     allocator.Free(finfo);
  506.     allocator.Free(io);
  507. } /* ZIP_destroy */
  508.  
  509.  
  510. static const PHYSFS_Io ZIP_Io =
  511. {
  512.     CURRENT_PHYSFS_IO_API_VERSION, NULL,
  513.     ZIP_read,
  514.     ZIP_write,
  515.     ZIP_seek,
  516.     ZIP_tell,
  517.     ZIP_length,
  518.     ZIP_duplicate,
  519.     ZIP_flush,
  520.     ZIP_destroy
  521. };
  522.  
  523.  
  524.  
  525. static PHYSFS_sint64 zip_find_end_of_central_dir(PHYSFS_Io *io, PHYSFS_sint64 *len)
  526. {
  527.     PHYSFS_uint8 buf[256];
  528.     PHYSFS_uint8 extra[4] = { 0, 0, 0, 0 };
  529.     PHYSFS_sint32 i = 0;
  530.     PHYSFS_sint64 filelen;
  531.     PHYSFS_sint64 filepos;
  532.     PHYSFS_sint32 maxread;
  533.     PHYSFS_sint32 totalread = 0;
  534.     int found = 0;
  535.  
  536.     filelen = io->length(io);
  537.     BAIL_IF_ERRPASS(filelen == -1, -1);
  538.  
  539.     /*
  540.      * Jump to the end of the file and start reading backwards.
  541.      *  The last thing in the file is the zipfile comment, which is variable
  542.      *  length, and the field that specifies its size is before it in the
  543.      *  file (argh!)...this means that we need to scan backwards until we
  544.      *  hit the end-of-central-dir signature. We can then sanity check that
  545.      *  the comment was as big as it should be to make sure we're in the
  546.      *  right place. The comment length field is 16 bits, so we can stop
  547.      *  searching for that signature after a little more than 64k at most,
  548.      *  and call it a corrupted zipfile.
  549.      */
  550.  
  551.     if (sizeof (buf) < filelen)
  552.     {
  553.         filepos = filelen - sizeof (buf);
  554.         maxread = sizeof (buf);
  555.     } /* if */
  556.     else
  557.     {
  558.         filepos = 0;
  559.         maxread = (PHYSFS_uint32) filelen;
  560.     } /* else */
  561.  
  562.     while ((totalread < filelen) && (totalread < 65557))
  563.     {
  564.         BAIL_IF_ERRPASS(!io->seek(io, filepos), -1);
  565.  
  566.         /* make sure we catch a signature between buffers. */
  567.         if (totalread != 0)
  568.         {
  569.             if (!__PHYSFS_readAll(io, buf, maxread - 4))
  570.                 return -1;
  571.             memcpy(&buf[maxread - 4], &extra, sizeof (extra));
  572.             totalread += maxread - 4;
  573.         } /* if */
  574.         else
  575.         {
  576.             if (!__PHYSFS_readAll(io, buf, maxread))
  577.                 return -1;
  578.             totalread += maxread;
  579.         } /* else */
  580.  
  581.         memcpy(&extra, buf, sizeof (extra));
  582.  
  583.         for (i = maxread - 4; i > 0; i--)
  584.         {
  585.             if ((buf[i + 0] == 0x50) &&
  586.                 (buf[i + 1] == 0x4B) &&
  587.                 (buf[i + 2] == 0x05) &&
  588.                 (buf[i + 3] == 0x06) )
  589.             {
  590.                 found = 1;  /* that's the signature! */
  591.                 break;  
  592.             } /* if */
  593.         } /* for */
  594.  
  595.         if (found)
  596.             break;
  597.  
  598.         filepos -= (maxread - 4);
  599.         if (filepos < 0)
  600.             filepos = 0;
  601.     } /* while */
  602.  
  603.     BAIL_IF(!found, PHYSFS_ERR_UNSUPPORTED, -1);
  604.  
  605.     if (len != NULL)
  606.         *len = filelen;
  607.  
  608.     return (filepos + i);
  609. } /* zip_find_end_of_central_dir */
  610.  
  611.  
  612. static int isZip(PHYSFS_Io *io)
  613. {
  614.     PHYSFS_uint32 sig = 0;
  615.     int retval = 0;
  616.  
  617.     /*
  618.      * The first thing in a zip file might be the signature of the
  619.      *  first local file record, so it makes for a quick determination.
  620.      */
  621.     if (readui32(io, &sig))
  622.     {
  623.         retval = (sig == ZIP_LOCAL_FILE_SIG);
  624.         if (!retval)
  625.         {
  626.             /*
  627.              * No sig...might be a ZIP with data at the start
  628.              *  (a self-extracting executable, etc), so we'll have to do
  629.              *  it the hard way...
  630.              */
  631.             retval = (zip_find_end_of_central_dir(io, NULL) != -1);
  632.         } /* if */
  633.     } /* if */
  634.  
  635.     return retval;
  636. } /* isZip */
  637.  
  638.  
  639. /* Convert paths from old, buggy DOS zippers... */
  640. static void zip_convert_dos_path(const PHYSFS_uint16 entryversion, char *path)
  641. {
  642.     const PHYSFS_uint8 hosttype = (PHYSFS_uint8) ((entryversion >> 8) & 0xFF);
  643.     if (hosttype == 0)  /* FS_FAT_ */
  644.     {
  645.         while (*path)
  646.         {
  647.             if (*path == '\\')
  648.                 *path = '/';
  649.             path++;
  650.         } /* while */
  651.     } /* if */
  652. } /* zip_convert_dos_path */
  653.  
  654.  
  655. static void zip_expand_symlink_path(char *path)
  656. {
  657.     char *ptr = path;
  658.     char *prevptr = path;
  659.  
  660.     while (1)
  661.     {
  662.         ptr = strchr(ptr, '/');
  663.         if (ptr == NULL)
  664.             break;
  665.  
  666.         if (*(ptr + 1) == '.')
  667.         {
  668.             if (*(ptr + 2) == '/')
  669.             {
  670.                 /* current dir in middle of string: ditch it. */
  671.                 memmove(ptr, ptr + 2, strlen(ptr + 2) + 1);
  672.             } /* else if */
  673.  
  674.             else if (*(ptr + 2) == '\0')
  675.             {
  676.                 /* current dir at end of string: ditch it. */
  677.                 *ptr = '\0';
  678.             } /* else if */
  679.  
  680.             else if (*(ptr + 2) == '.')
  681.             {
  682.                 if (*(ptr + 3) == '/')
  683.                 {
  684.                     /* parent dir in middle: move back one, if possible. */
  685.                     memmove(prevptr, ptr + 4, strlen(ptr + 4) + 1);
  686.                     ptr = prevptr;
  687.                     while (prevptr != path)
  688.                     {
  689.                         prevptr--;
  690.                         if (*prevptr == '/')
  691.                         {
  692.                             prevptr++;
  693.                             break;
  694.                         } /* if */
  695.                     } /* while */
  696.                 } /* if */
  697.  
  698.                 if (*(ptr + 3) == '\0')
  699.                 {
  700.                     /* parent dir at end: move back one, if possible. */
  701.                     *prevptr = '\0';
  702.                 } /* if */
  703.             } /* if */
  704.         } /* if */
  705.         else
  706.         {
  707.             prevptr = ptr;
  708.             ptr++;
  709.         } /* else */
  710.     } /* while */
  711. } /* zip_expand_symlink_path */
  712.  
  713.  
  714. static inline ZIPentry *zip_find_entry(ZIPinfo *info, const char *path)
  715. {
  716.     return (ZIPentry *) __PHYSFS_DirTreeFind(&info->tree, path);
  717. } /* zip_find_entry */
  718.  
  719. /* (forward reference: zip_follow_symlink and zip_resolve call each other.) */
  720. static int zip_resolve(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry);
  721.  
  722. /*
  723.  * Look for the entry named by (path). If it exists, resolve it, and return
  724.  *  a pointer to that entry. If it's another symlink, keep resolving until you
  725.  *  hit a real file and then return a pointer to the final non-symlink entry.
  726.  *  If there's a problem, return NULL.
  727.  */
  728. static ZIPentry *zip_follow_symlink(PHYSFS_Io *io, ZIPinfo *info, char *path)
  729. {
  730.     ZIPentry *entry;
  731.  
  732.     zip_expand_symlink_path(path);
  733.     entry = zip_find_entry(info, path);
  734.     if (entry != NULL)
  735.     {
  736.         if (!zip_resolve(io, info, entry))  /* recursive! */
  737.             entry = NULL;
  738.         else
  739.         {
  740.             if (entry->symlink != NULL)
  741.                 entry = entry->symlink;
  742.         } /* else */
  743.     } /* if */
  744.  
  745.     return entry;
  746. } /* zip_follow_symlink */
  747.  
  748.  
  749. static int zip_resolve_symlink(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)
  750. {
  751.     const size_t size = (size_t) entry->uncompressed_size;
  752.     char *path = NULL;
  753.     int rc = 0;
  754.  
  755.     /*
  756.      * We've already parsed the local file header of the symlink at this
  757.      *  point. Now we need to read the actual link from the file data and
  758.      *  follow it.
  759.      */
  760.  
  761.     BAIL_IF_ERRPASS(!io->seek(io, entry->offset), 0);
  762.  
  763.     path = (char *) __PHYSFS_smallAlloc(size + 1);
  764.     BAIL_IF(!path, PHYSFS_ERR_OUT_OF_MEMORY, 0);
  765.    
  766.     if (entry->compression_method == COMPMETH_NONE)
  767.         rc = __PHYSFS_readAll(io, path, size);
  768.  
  769.     else  /* symlink target path is compressed... */
  770.     {
  771.         z_stream stream;
  772.         const size_t complen = (size_t) entry->compressed_size;
  773.         PHYSFS_uint8 *compressed = (PHYSFS_uint8*) __PHYSFS_smallAlloc(complen);
  774.         if (compressed != NULL)
  775.         {
  776.             if (__PHYSFS_readAll(io, compressed, complen))
  777.             {
  778.                 initializeZStream(&stream);
  779.                 stream.next_in = compressed;
  780.                 stream.avail_in = (unsigned int) complen;
  781.                 stream.next_out = (unsigned char *) path;
  782.                 stream.avail_out = (unsigned int) size;
  783.                 if (zlib_err(inflateInit2(&stream, -MAX_WBITS)) == Z_OK)
  784.                 {
  785.                     rc = zlib_err(inflate(&stream, Z_FINISH));
  786.                     inflateEnd(&stream);
  787.  
  788.                     /* both are acceptable outcomes... */
  789.                     rc = ((rc == Z_OK) || (rc == Z_STREAM_END));
  790.                 } /* if */
  791.             } /* if */
  792.             __PHYSFS_smallFree(compressed);
  793.         } /* if */
  794.     } /* else */
  795.  
  796.     if (rc)
  797.     {
  798.         path[entry->uncompressed_size] = '\0';    /* null-terminate it. */
  799.         zip_convert_dos_path(entry->version, path);
  800.         entry->symlink = zip_follow_symlink(io, info, path);
  801.     } /* else */
  802.  
  803.     __PHYSFS_smallFree(path);
  804.  
  805.     return (entry->symlink != NULL);
  806. } /* zip_resolve_symlink */
  807.  
  808.  
  809. /*
  810.  * Parse the local file header of an entry, and update entry->offset.
  811.  */
  812. static int zip_parse_local(PHYSFS_Io *io, ZIPentry *entry)
  813. {
  814.     PHYSFS_uint32 ui32;
  815.     PHYSFS_uint16 ui16;
  816.     PHYSFS_uint16 fnamelen;
  817.     PHYSFS_uint16 extralen;
  818.  
  819.     /*
  820.      * crc and (un)compressed_size are always zero if this is a "JAR"
  821.      *  archive created with Sun's Java tools, apparently. We only
  822.      *  consider this archive corrupted if those entries don't match and
  823.      *  aren't zero. That seems to work well.
  824.      * We also ignore a mismatch if the value is 0xFFFFFFFF here, since it's
  825.      *  possible that's a Zip64 thing.
  826.      */
  827.  
  828.     /* !!! FIXME: apparently these are zero if general purpose bit 3 is set,
  829.        !!! FIXME:  which is probably true for Jar files, fwiw, but we don't
  830.        !!! FIXME:  care about these values anyhow. */
  831.  
  832.     BAIL_IF_ERRPASS(!io->seek(io, entry->offset), 0);
  833.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  834.     BAIL_IF(ui32 != ZIP_LOCAL_FILE_SIG, PHYSFS_ERR_CORRUPT, 0);
  835.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  836.     BAIL_IF(ui16 != entry->version_needed, PHYSFS_ERR_CORRUPT, 0);
  837.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);  /* general bits. */
  838.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  839.     BAIL_IF(ui16 != entry->compression_method, PHYSFS_ERR_CORRUPT, 0);
  840.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);  /* date/time */
  841.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  842.     BAIL_IF(ui32 && (ui32 != entry->crc), PHYSFS_ERR_CORRUPT, 0);
  843.  
  844.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  845.     BAIL_IF(ui32 && (ui32 != 0xFFFFFFFF) &&
  846.                   (ui32 != entry->compressed_size), PHYSFS_ERR_CORRUPT, 0);
  847.  
  848.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  849.     BAIL_IF(ui32 && (ui32 != 0xFFFFFFFF) &&
  850.                  (ui32 != entry->uncompressed_size), PHYSFS_ERR_CORRUPT, 0);
  851.  
  852.     BAIL_IF_ERRPASS(!readui16(io, &fnamelen), 0);
  853.     BAIL_IF_ERRPASS(!readui16(io, &extralen), 0);
  854.  
  855.     entry->offset += fnamelen + extralen + 30;
  856.     return 1;
  857. } /* zip_parse_local */
  858.  
  859.  
  860. static int zip_resolve(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)
  861. {
  862.     int retval = 1;
  863.     const ZipResolveType resolve_type = entry->resolved;
  864.  
  865.     if (resolve_type == ZIP_DIRECTORY)
  866.         return 1;   /* we're good. */
  867.  
  868.     /* Don't bother if we've failed to resolve this entry before. */
  869.     BAIL_IF(resolve_type == ZIP_BROKEN_FILE, PHYSFS_ERR_CORRUPT, 0);
  870.     BAIL_IF(resolve_type == ZIP_BROKEN_SYMLINK, PHYSFS_ERR_CORRUPT, 0);
  871.  
  872.     /* uhoh...infinite symlink loop! */
  873.     BAIL_IF(resolve_type == ZIP_RESOLVING, PHYSFS_ERR_SYMLINK_LOOP, 0);
  874.  
  875.     /*
  876.      * We fix up the offset to point to the actual data on the
  877.      *  first open, since we don't want to seek across the whole file on
  878.      *  archive open (can be SLOW on large, CD-stored files), but we
  879.      *  need to check the local file header...not just for corruption,
  880.      *  but since it stores offset info the central directory does not.
  881.      */
  882.     if (resolve_type != ZIP_RESOLVED)
  883.     {
  884.         if (entry->tree.isdir)  /* an ancestor dir that DirTree filled in? */
  885.         {
  886.             entry->resolved = ZIP_DIRECTORY;
  887.             return 1;
  888.         } /* if */
  889.  
  890.         retval = zip_parse_local(io, entry);
  891.         if (retval)
  892.         {
  893.             /*
  894.              * If it's a symlink, find the original file. This will cause
  895.              *  resolution of other entries (other symlinks and, eventually,
  896.              *  the real file) if all goes well.
  897.              */
  898.             if (resolve_type == ZIP_UNRESOLVED_SYMLINK)
  899.                 retval = zip_resolve_symlink(io, info, entry);
  900.         } /* if */
  901.  
  902.         if (resolve_type == ZIP_UNRESOLVED_SYMLINK)
  903.             entry->resolved = ((retval) ? ZIP_RESOLVED : ZIP_BROKEN_SYMLINK);
  904.         else if (resolve_type == ZIP_UNRESOLVED_FILE)
  905.             entry->resolved = ((retval) ? ZIP_RESOLVED : ZIP_BROKEN_FILE);
  906.     } /* if */
  907.  
  908.     return retval;
  909. } /* zip_resolve */
  910.  
  911.  
  912. static int zip_entry_is_symlink(const ZIPentry *entry)
  913. {
  914.     return ((entry->resolved == ZIP_UNRESOLVED_SYMLINK) ||
  915.             (entry->resolved == ZIP_BROKEN_SYMLINK) ||
  916.             (entry->symlink));
  917. } /* zip_entry_is_symlink */
  918.  
  919.  
  920. static int zip_version_does_symlinks(PHYSFS_uint32 version)
  921. {
  922.     int retval = 0;
  923.     PHYSFS_uint8 hosttype = (PHYSFS_uint8) ((version >> 8) & 0xFF);
  924.  
  925.     switch (hosttype)
  926.     {
  927.             /*
  928.              * These are the platforms that can NOT build an archive with
  929.              *  symlinks, according to the Info-ZIP project.
  930.              */
  931.         case 0:  /* FS_FAT_  */
  932.         case 1:  /* AMIGA_   */
  933.         case 2:  /* VMS_     */
  934.         case 4:  /* VM_CSM_  */
  935.         case 6:  /* FS_HPFS_ */
  936.         case 11: /* FS_NTFS_ */
  937.         case 14: /* FS_VFAT_ */
  938.         case 13: /* ACORN_   */
  939.         case 15: /* MVS_     */
  940.         case 18: /* THEOS_   */
  941.             break;  /* do nothing. */
  942.  
  943.         default:  /* assume the rest to be unix-like. */
  944.             retval = 1;
  945.             break;
  946.     } /* switch */
  947.  
  948.     return retval;
  949. } /* zip_version_does_symlinks */
  950.  
  951.  
  952. static inline int zip_has_symlink_attr(const ZIPentry *entry,
  953.                                        const PHYSFS_uint32 extern_attr)
  954. {
  955.     PHYSFS_uint16 xattr = ((extern_attr >> 16) & 0xFFFF);
  956.     return ( (zip_version_does_symlinks(entry->version)) &&
  957.              (entry->uncompressed_size > 0) &&
  958.              ((xattr & UNIX_FILETYPE_MASK) == UNIX_FILETYPE_SYMLINK) );
  959. } /* zip_has_symlink_attr */
  960.  
  961.  
  962. static PHYSFS_sint64 zip_dos_time_to_physfs_time(PHYSFS_uint32 dostime)
  963. {
  964.     PHYSFS_uint32 dosdate;
  965.     struct tm unixtime;
  966.     memset(&unixtime, '\0', sizeof (unixtime));
  967.  
  968.     dosdate = (PHYSFS_uint32) ((dostime >> 16) & 0xFFFF);
  969.     dostime &= 0xFFFF;
  970.  
  971.     /* dissect date */
  972.     unixtime.tm_year = ((dosdate >> 9) & 0x7F) + 80;
  973.     unixtime.tm_mon  = ((dosdate >> 5) & 0x0F) - 1;
  974.     unixtime.tm_mday = ((dosdate     ) & 0x1F);
  975.  
  976.     /* dissect time */
  977.     unixtime.tm_hour = ((dostime >> 11) & 0x1F);
  978.     unixtime.tm_min  = ((dostime >>  5) & 0x3F);
  979.     unixtime.tm_sec  = ((dostime <<  1) & 0x3E);
  980.  
  981.     /* let mktime calculate daylight savings time. */
  982.     unixtime.tm_isdst = -1;
  983.  
  984.     return ((PHYSFS_sint64) mktime(&unixtime));
  985. } /* zip_dos_time_to_physfs_time */
  986.  
  987.  
  988. static ZIPentry *zip_load_entry(ZIPinfo *info, const int zip64,
  989.                                 const PHYSFS_uint64 ofs_fixup)
  990. {
  991.     PHYSFS_Io *io = info->io;
  992.     ZIPentry entry;
  993.     ZIPentry *retval = NULL;
  994.     PHYSFS_uint16 fnamelen, extralen, commentlen;
  995.     PHYSFS_uint32 external_attr;
  996.     PHYSFS_uint32 starting_disk;
  997.     PHYSFS_uint64 offset;
  998.     PHYSFS_uint16 ui16;
  999.     PHYSFS_uint32 ui32;
  1000.     PHYSFS_sint64 si64;
  1001.     char *name = NULL;
  1002.     int isdir = 0;
  1003.  
  1004.     /* sanity check with central directory signature... */
  1005.     BAIL_IF_ERRPASS(!readui32(io, &ui32), NULL);
  1006.     BAIL_IF(ui32 != ZIP_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, NULL);
  1007.  
  1008.     memset(&entry, '\0', sizeof (entry));
  1009.  
  1010.     /* Get the pertinent parts of the record... */
  1011.     BAIL_IF_ERRPASS(!readui16(io, &entry.version), NULL);
  1012.     BAIL_IF_ERRPASS(!readui16(io, &entry.version_needed), NULL);
  1013.     BAIL_IF_ERRPASS(!readui16(io, &entry.general_bits), NULL);  /* general bits */
  1014.     BAIL_IF_ERRPASS(!readui16(io, &entry.compression_method), NULL);
  1015.     BAIL_IF_ERRPASS(!readui32(io, &entry.dos_mod_time), NULL);
  1016.     entry.last_mod_time = zip_dos_time_to_physfs_time(entry.dos_mod_time);
  1017.     BAIL_IF_ERRPASS(!readui32(io, &entry.crc), NULL);
  1018.     BAIL_IF_ERRPASS(!readui32(io, &ui32), NULL);
  1019.     entry.compressed_size = (PHYSFS_uint64) ui32;
  1020.     BAIL_IF_ERRPASS(!readui32(io, &ui32), NULL);
  1021.     entry.uncompressed_size = (PHYSFS_uint64) ui32;
  1022.     BAIL_IF_ERRPASS(!readui16(io, &fnamelen), NULL);
  1023.     BAIL_IF_ERRPASS(!readui16(io, &extralen), NULL);
  1024.     BAIL_IF_ERRPASS(!readui16(io, &commentlen), NULL);
  1025.     BAIL_IF_ERRPASS(!readui16(io, &ui16), NULL);
  1026.     starting_disk = (PHYSFS_uint32) ui16;
  1027.     BAIL_IF_ERRPASS(!readui16(io, &ui16), NULL);  /* internal file attribs */
  1028.     BAIL_IF_ERRPASS(!readui32(io, &external_attr), NULL);
  1029.     BAIL_IF_ERRPASS(!readui32(io, &ui32), NULL);
  1030.     offset = (PHYSFS_uint64) ui32;
  1031.  
  1032.     name = (char *) __PHYSFS_smallAlloc(fnamelen + 1);
  1033.     BAIL_IF(!name, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
  1034.     if (!__PHYSFS_readAll(io, name, fnamelen))
  1035.     {
  1036.         __PHYSFS_smallFree(name);
  1037.         return NULL;
  1038.     } /* if */
  1039.  
  1040.     if (name[fnamelen - 1] == '/')
  1041.     {
  1042.         name[fnamelen - 1] = '\0';
  1043.         isdir = 1;
  1044.     } /* if */
  1045.     name[fnamelen] = '\0';  /* null-terminate the filename. */
  1046.  
  1047.     zip_convert_dos_path(entry.version, name);
  1048.  
  1049.     retval = (ZIPentry *) __PHYSFS_DirTreeAdd(&info->tree, name, isdir);
  1050.     __PHYSFS_smallFree(name);
  1051.  
  1052.     BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
  1053.  
  1054.     /* It's okay to BAIL without freeing retval, because it's stored in the
  1055.        __PHYSFS_DirTree and will be freed later anyhow. */
  1056.     BAIL_IF(retval->last_mod_time != 0, PHYSFS_ERR_CORRUPT, NULL); /* dupe? */
  1057.  
  1058.     /* Move the data we already read into place in the official object. */
  1059.     memcpy(((PHYSFS_uint8 *) retval) + sizeof (__PHYSFS_DirTreeEntry),
  1060.            ((PHYSFS_uint8 *) &entry) + sizeof (__PHYSFS_DirTreeEntry),
  1061.            sizeof (*retval) - sizeof (__PHYSFS_DirTreeEntry));
  1062.  
  1063.     retval->symlink = NULL;  /* will be resolved later, if necessary. */
  1064.  
  1065.     if (isdir)
  1066.         retval->resolved = ZIP_DIRECTORY;
  1067.     else
  1068.     {
  1069.         retval->resolved = (zip_has_symlink_attr(retval, external_attr)) ?
  1070.                                 ZIP_UNRESOLVED_SYMLINK : ZIP_UNRESOLVED_FILE;
  1071.     } /* else */
  1072.  
  1073.     si64 = io->tell(io);
  1074.     BAIL_IF_ERRPASS(si64 == -1, NULL);
  1075.  
  1076.     /* If the actual sizes didn't fit in 32-bits, look for the Zip64
  1077.         extended information extra field... */
  1078.     if ( (zip64) &&
  1079.          ((offset == 0xFFFFFFFF) ||
  1080.           (starting_disk == 0xFFFFFFFF) ||
  1081.           (retval->compressed_size == 0xFFFFFFFF) ||
  1082.           (retval->uncompressed_size == 0xFFFFFFFF)) )
  1083.     {
  1084.         int found = 0;
  1085.         PHYSFS_uint16 sig = 0;
  1086.         PHYSFS_uint16 len = 0;
  1087.         while (extralen > 4)
  1088.         {
  1089.             BAIL_IF_ERRPASS(!readui16(io, &sig), NULL);
  1090.             BAIL_IF_ERRPASS(!readui16(io, &len), NULL);
  1091.  
  1092.             si64 += 4 + len;
  1093.             extralen -= 4 + len;
  1094.             if (sig != ZIP64_EXTENDED_INFO_EXTRA_FIELD_SIG)
  1095.             {
  1096.                 BAIL_IF_ERRPASS(!io->seek(io, si64), NULL);
  1097.                 continue;
  1098.             } /* if */
  1099.  
  1100.             found = 1;
  1101.             break;
  1102.         } /* while */
  1103.  
  1104.         BAIL_IF(!found, PHYSFS_ERR_CORRUPT, NULL);
  1105.  
  1106.         if (retval->uncompressed_size == 0xFFFFFFFF)
  1107.         {
  1108.             BAIL_IF(len < 8, PHYSFS_ERR_CORRUPT, NULL);
  1109.             BAIL_IF_ERRPASS(!readui64(io, &retval->uncompressed_size), NULL);
  1110.             len -= 8;
  1111.         } /* if */
  1112.  
  1113.         if (retval->compressed_size == 0xFFFFFFFF)
  1114.         {
  1115.             BAIL_IF(len < 8, PHYSFS_ERR_CORRUPT, NULL);
  1116.             BAIL_IF_ERRPASS(!readui64(io, &retval->compressed_size), NULL);
  1117.             len -= 8;
  1118.         } /* if */
  1119.  
  1120.         if (offset == 0xFFFFFFFF)
  1121.         {
  1122.             BAIL_IF(len < 8, PHYSFS_ERR_CORRUPT, NULL);
  1123.             BAIL_IF_ERRPASS(!readui64(io, &offset), NULL);
  1124.             len -= 8;
  1125.         } /* if */
  1126.  
  1127.         if (starting_disk == 0xFFFFFFFF)
  1128.         {
  1129.             BAIL_IF(len < 8, PHYSFS_ERR_CORRUPT, NULL);
  1130.             BAIL_IF_ERRPASS(!readui32(io, &starting_disk), NULL);
  1131.             len -= 4;
  1132.         } /* if */
  1133.  
  1134.         BAIL_IF(len != 0, PHYSFS_ERR_CORRUPT, NULL);
  1135.     } /* if */
  1136.  
  1137.     BAIL_IF(starting_disk != 0, PHYSFS_ERR_CORRUPT, NULL);
  1138.  
  1139.     retval->offset = offset + ofs_fixup;
  1140.  
  1141.     /* seek to the start of the next entry in the central directory... */
  1142.     BAIL_IF_ERRPASS(!io->seek(io, si64 + extralen + commentlen), NULL);
  1143.  
  1144.     return retval;  /* success. */
  1145. } /* zip_load_entry */
  1146.  
  1147.  
  1148. /* This leaves things allocated on error; the caller will clean up the mess. */
  1149. static int zip_load_entries(ZIPinfo *info,
  1150.                             const PHYSFS_uint64 data_ofs,
  1151.                             const PHYSFS_uint64 central_ofs,
  1152.                             const PHYSFS_uint64 entry_count)
  1153. {
  1154.     PHYSFS_Io *io = info->io;
  1155.     const int zip64 = info->zip64;
  1156.     PHYSFS_uint64 i;
  1157.  
  1158.     BAIL_IF_ERRPASS(!io->seek(io, central_ofs), 0);
  1159.  
  1160.     for (i = 0; i < entry_count; i++)
  1161.     {
  1162.         ZIPentry *entry = zip_load_entry(info, zip64, data_ofs);
  1163.         BAIL_IF_ERRPASS(!entry, 0);
  1164.         if (zip_entry_is_tradional_crypto(entry))
  1165.             info->has_crypto = 1;
  1166.     } /* for */
  1167.  
  1168.     return 1;
  1169. } /* zip_load_entries */
  1170.  
  1171.  
  1172. static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
  1173.                                                    PHYSFS_sint64 _pos,
  1174.                                                    PHYSFS_uint64 offset)
  1175. {
  1176.     /*
  1177.      * Naturally, the offset is useless to us; it is the offset from the
  1178.      *  start of file, which is meaningless if we've appended this .zip to
  1179.      *  a self-extracting .exe. We need to find this on our own. It should
  1180.      *  be directly before the locator record, but the record in question,
  1181.      *  like the original end-of-central-directory record, ends with a
  1182.      *  variable-length field. Unlike the original, which has to store the
  1183.      *  size of that variable-length field in a 16-bit int and thus has to be
  1184.      *  within 64k, the new one gets 64-bits.
  1185.      *
  1186.      * Fortunately, the only currently-specified record for that variable
  1187.      *  length block is some weird proprietary thing that deals with EBCDIC
  1188.      *  and tape backups or something. So we don't seek far.
  1189.      */
  1190.  
  1191.     PHYSFS_uint32 ui32;
  1192.     const PHYSFS_uint64 pos = (PHYSFS_uint64) _pos;
  1193.  
  1194.     assert(_pos > 0);
  1195.  
  1196.     /* Try offset specified in the Zip64 end of central directory locator. */
  1197.     /* This works if the entire PHYSFS_Io is the zip file. */
  1198.     BAIL_IF_ERRPASS(!io->seek(io, offset), -1);
  1199.     BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
  1200.     if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
  1201.         return offset;
  1202.  
  1203.     /* Try 56 bytes before the Zip64 end of central directory locator. */
  1204.     /* This works if the record isn't variable length and is version 1. */
  1205.     if (pos > 56)
  1206.     {
  1207.         BAIL_IF_ERRPASS(!io->seek(io, pos-56), -1);
  1208.         BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
  1209.         if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
  1210.             return pos-56;
  1211.     } /* if */
  1212.  
  1213.     /* Try 84 bytes before the Zip64 end of central directory locator. */
  1214.     /* This works if the record isn't variable length and is version 2. */
  1215.     if (pos > 84)
  1216.     {
  1217.         BAIL_IF_ERRPASS(!io->seek(io, pos-84), -1);
  1218.         BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
  1219.         if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
  1220.             return pos-84;
  1221.     } /* if */
  1222.  
  1223.     /* Ok, brute force: we know it's between (offset) and (pos) somewhere. */
  1224.     /*  Just try moving back at most 256k. Oh well. */
  1225.     if ((offset < pos) && (pos > 4))
  1226.     {
  1227.         const size_t maxbuflen = 256 * 1024;
  1228.         size_t len = (size_t) (pos - offset);
  1229.         PHYSFS_uint8 *buf = NULL;
  1230.         PHYSFS_sint32 i;
  1231.  
  1232.         if (len > maxbuflen)
  1233.             len = maxbuflen;
  1234.  
  1235.         buf = (PHYSFS_uint8 *) __PHYSFS_smallAlloc(len);
  1236.         BAIL_IF(!buf, PHYSFS_ERR_OUT_OF_MEMORY, -1);
  1237.  
  1238.         if (!io->seek(io, pos - len) || !__PHYSFS_readAll(io, buf, len))
  1239.         {
  1240.             __PHYSFS_smallFree(buf);
  1241.             return -1;  /* error was set elsewhere. */
  1242.         } /* if */
  1243.  
  1244.         for (i = (PHYSFS_sint32) (len - 4); i >= 0; i--)
  1245.         {
  1246.             if ( (buf[i] == 0x50) && (buf[i+1] == 0x4b) &&
  1247.                  (buf[i+2] == 0x06) && (buf[i+3] == 0x06) )
  1248.             {
  1249.                 __PHYSFS_smallFree(buf);
  1250.                 return pos - ((PHYSFS_sint64) (len - i));
  1251.             } /* if */
  1252.         } /* for */
  1253.  
  1254.         __PHYSFS_smallFree(buf);
  1255.     } /* if */
  1256.  
  1257.     BAIL(PHYSFS_ERR_CORRUPT, -1);  /* didn't find it. */
  1258. } /* zip64_find_end_of_central_dir */
  1259.  
  1260.  
  1261. static int zip64_parse_end_of_central_dir(ZIPinfo *info,
  1262.                                           PHYSFS_uint64 *data_start,
  1263.                                           PHYSFS_uint64 *dir_ofs,
  1264.                                           PHYSFS_uint64 *entry_count,
  1265.                                           PHYSFS_sint64 pos)
  1266. {
  1267.     PHYSFS_Io *io = info->io;
  1268.     PHYSFS_uint64 ui64;
  1269.     PHYSFS_uint32 ui32;
  1270.     PHYSFS_uint16 ui16;
  1271.  
  1272.     /* We should be positioned right past the locator signature. */
  1273.  
  1274.     if ((pos < 0) || (!io->seek(io, pos)))
  1275.         return 0;
  1276.  
  1277.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1278.     if (ui32 != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG)
  1279.         return -1;  /* it's not a Zip64 archive. Not an error, though! */
  1280.  
  1281.     info->zip64 = 1;
  1282.  
  1283.     /* number of the disk with the start of the central directory. */
  1284.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1285.     BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
  1286.  
  1287.     /* offset of Zip64 end of central directory record. */
  1288.     BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
  1289.  
  1290.     /* total number of disks */
  1291.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1292.     BAIL_IF(ui32 != 1, PHYSFS_ERR_CORRUPT, 0);
  1293.  
  1294.     pos = zip64_find_end_of_central_dir(io, pos, ui64);
  1295.     if (pos < 0)
  1296.         return 0;  /* oh well. */
  1297.  
  1298.     /*
  1299.      * For self-extracting archives, etc, there's crapola in the file
  1300.      *  before the zipfile records; we calculate how much data there is
  1301.      *  prepended by determining how far the zip64-end-of-central-directory
  1302.      *  offset is from where it is supposed to be...the difference in bytes
  1303.      *  is how much arbitrary data is at the start of the physical file.
  1304.      */
  1305.     assert(((PHYSFS_uint64) pos) >= ui64);
  1306.     *data_start = ((PHYSFS_uint64) pos) - ui64;
  1307.  
  1308.     BAIL_IF_ERRPASS(!io->seek(io, pos), 0);
  1309.  
  1310.     /* check signature again, just in case. */
  1311.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1312.     BAIL_IF(ui32 != ZIP64_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
  1313.  
  1314.     /* size of Zip64 end of central directory record. */
  1315.     BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
  1316.  
  1317.     /* version made by. */
  1318.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1319.  
  1320.     /* version needed to extract. */
  1321.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1322.  
  1323.     /* number of this disk. */
  1324.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1325.     BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
  1326.  
  1327.     /* number of disk with start of central directory record. */
  1328.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1329.     BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
  1330.  
  1331.     /* total number of entries in the central dir on this disk */
  1332.     BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
  1333.  
  1334.     /* total number of entries in the central dir */
  1335.     BAIL_IF_ERRPASS(!readui64(io, entry_count), 0);
  1336.     BAIL_IF(ui64 != *entry_count, PHYSFS_ERR_CORRUPT, 0);
  1337.  
  1338.     /* size of the central directory */
  1339.     BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
  1340.  
  1341.     /* offset of central directory */
  1342.     BAIL_IF_ERRPASS(!readui64(io, dir_ofs), 0);
  1343.  
  1344.     /* Since we know the difference, fix up the central dir offset... */
  1345.     *dir_ofs += *data_start;
  1346.  
  1347.     /*
  1348.      * There are more fields here, for encryption and feature-specific things,
  1349.      *  but we don't care about any of them at the moment.
  1350.      */
  1351.  
  1352.     return 1;  /* made it. */
  1353. } /* zip64_parse_end_of_central_dir */
  1354.  
  1355.  
  1356. static int zip_parse_end_of_central_dir(ZIPinfo *info,
  1357.                                         PHYSFS_uint64 *data_start,
  1358.                                         PHYSFS_uint64 *dir_ofs,
  1359.                                         PHYSFS_uint64 *entry_count)
  1360. {
  1361.     PHYSFS_Io *io = info->io;
  1362.     PHYSFS_uint16 entryCount16;
  1363.     PHYSFS_uint32 offset32;
  1364.     PHYSFS_uint32 ui32;
  1365.     PHYSFS_uint16 ui16;
  1366.     PHYSFS_sint64 len;
  1367.     PHYSFS_sint64 pos;
  1368.     int rc;
  1369.  
  1370.     /* find the end-of-central-dir record, and seek to it. */
  1371.     pos = zip_find_end_of_central_dir(io, &len);
  1372.     BAIL_IF_ERRPASS(pos == -1, 0);
  1373.     BAIL_IF_ERRPASS(!io->seek(io, pos), 0);
  1374.  
  1375.     /* check signature again, just in case. */
  1376.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1377.     BAIL_IF(ui32 != ZIP_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
  1378.  
  1379.     /* Seek back to see if "Zip64 end of central directory locator" exists. */
  1380.     /* this record is 20 bytes before end-of-central-dir */
  1381.     rc = zip64_parse_end_of_central_dir(info, data_start, dir_ofs,
  1382.                                         entry_count, pos - 20);
  1383.  
  1384.     /* Error or success? Bounce out of here. Keep going if not zip64. */
  1385.     if ((rc == 0) || (rc == 1))
  1386.         return rc;
  1387.  
  1388.     assert(rc == -1);  /* no error, just not a Zip64 archive. */
  1389.  
  1390.     /* Not Zip64? Seek back to where we were and keep processing. */
  1391.     BAIL_IF_ERRPASS(!io->seek(io, pos + 4), 0);
  1392.  
  1393.     /* number of this disk */
  1394.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1395.     BAIL_IF(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
  1396.  
  1397.     /* number of the disk with the start of the central directory */
  1398.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1399.     BAIL_IF(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
  1400.  
  1401.     /* total number of entries in the central dir on this disk */
  1402.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1403.  
  1404.     /* total number of entries in the central dir */
  1405.     BAIL_IF_ERRPASS(!readui16(io, &entryCount16), 0);
  1406.     BAIL_IF(ui16 != entryCount16, PHYSFS_ERR_CORRUPT, 0);
  1407.  
  1408.     *entry_count = entryCount16;
  1409.  
  1410.     /* size of the central directory */
  1411.     BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
  1412.  
  1413.     /* offset of central directory */
  1414.     BAIL_IF_ERRPASS(!readui32(io, &offset32), 0);
  1415.     *dir_ofs = (PHYSFS_uint64) offset32;
  1416.     BAIL_IF(((PHYSFS_uint64) pos) < (*dir_ofs + ui32), PHYSFS_ERR_CORRUPT, 0);
  1417.  
  1418.     /*
  1419.      * For self-extracting archives, etc, there's crapola in the file
  1420.      *  before the zipfile records; we calculate how much data there is
  1421.      *  prepended by determining how far the central directory offset is
  1422.      *  from where it is supposed to be (start of end-of-central-dir minus
  1423.      *  sizeof central dir)...the difference in bytes is how much arbitrary
  1424.      *  data is at the start of the physical file.
  1425.      */
  1426.     *data_start = (PHYSFS_uint64) (pos - (*dir_ofs + ui32));
  1427.  
  1428.     /* Now that we know the difference, fix up the central dir offset... */
  1429.     *dir_ofs += *data_start;
  1430.  
  1431.     /* zipfile comment length */
  1432.     BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
  1433.  
  1434.     /*
  1435.      * Make sure that the comment length matches to the end of file...
  1436.      *  If it doesn't, we're either in the wrong part of the file, or the
  1437.      *  file is corrupted, but we give up either way.
  1438.      */
  1439.     BAIL_IF((pos + 22 + ui16) != len, PHYSFS_ERR_CORRUPT, 0);
  1440.  
  1441.     return 1;  /* made it. */
  1442. } /* zip_parse_end_of_central_dir */
  1443.  
  1444.  
  1445. static void ZIP_closeArchive(void *opaque)
  1446. {
  1447.     ZIPinfo *info = (ZIPinfo *) (opaque);
  1448.  
  1449.     if (!info)
  1450.         return;
  1451.  
  1452.     if (info->io)
  1453.         info->io->destroy(info->io);
  1454.  
  1455.     __PHYSFS_DirTreeDeinit(&info->tree);
  1456.  
  1457.     allocator.Free(info);
  1458. } /* ZIP_closeArchive */
  1459.  
  1460.  
  1461. static void *ZIP_openArchive(PHYSFS_Io *io, const char *name,
  1462.                              int forWriting, int *claimed)
  1463. {
  1464.     ZIPinfo *info = NULL;
  1465.     ZIPentry *root = NULL;
  1466.     PHYSFS_uint64 dstart = 0;  /* data start */
  1467.     PHYSFS_uint64 cdir_ofs;  /* central dir offset */
  1468.     PHYSFS_uint64 count;
  1469.  
  1470.     assert(io != NULL);  /* shouldn't ever happen. */
  1471.  
  1472.     BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
  1473.     BAIL_IF_ERRPASS(!isZip(io), NULL);
  1474.  
  1475.     *claimed = 1;
  1476.  
  1477.     info = (ZIPinfo *) allocator.Malloc(sizeof (ZIPinfo));
  1478.     BAIL_IF(!info, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
  1479.     memset(info, '\0', sizeof (ZIPinfo));
  1480.  
  1481.     info->io = io;
  1482.  
  1483.     if (!zip_parse_end_of_central_dir(info, &dstart, &cdir_ofs, &count))
  1484.         goto ZIP_openarchive_failed;
  1485.     else if (!__PHYSFS_DirTreeInit(&info->tree, sizeof (ZIPentry)))
  1486.         goto ZIP_openarchive_failed;
  1487.  
  1488.     root = (ZIPentry *) info->tree.root;
  1489.     root->resolved = ZIP_DIRECTORY;
  1490.  
  1491.     if (!zip_load_entries(info, dstart, cdir_ofs, count))
  1492.         goto ZIP_openarchive_failed;
  1493.  
  1494.     assert(info->tree.root->sibling == NULL);
  1495.     return info;
  1496.  
  1497. ZIP_openarchive_failed:
  1498.     info->io = NULL;  /* don't let ZIP_closeArchive destroy (io). */
  1499.     ZIP_closeArchive(info);
  1500.     return NULL;
  1501. } /* ZIP_openArchive */
  1502.  
  1503.  
  1504. static PHYSFS_Io *zip_get_io(PHYSFS_Io *io, ZIPinfo *inf, ZIPentry *entry)
  1505. {
  1506.     int success;
  1507.     PHYSFS_Io *retval = io->duplicate(io);
  1508.     BAIL_IF_ERRPASS(!retval, NULL);
  1509.  
  1510.     assert(!entry->tree.isdir); /* should have been checked before calling. */
  1511.  
  1512.     /* (inf) can be NULL if we already resolved. */
  1513.     success = (inf == NULL) || zip_resolve(retval, inf, entry);
  1514.     if (success)
  1515.     {
  1516.         PHYSFS_sint64 offset;
  1517.         offset = ((entry->symlink) ? entry->symlink->offset : entry->offset);
  1518.         success = retval->seek(retval, offset);
  1519.     } /* if */
  1520.  
  1521.     if (!success)
  1522.     {
  1523.         retval->destroy(retval);
  1524.         retval = NULL;
  1525.     } /* if */
  1526.  
  1527.     return retval;
  1528. } /* zip_get_io */
  1529.  
  1530.  
  1531. static PHYSFS_Io *ZIP_openRead(void *opaque, const char *filename)
  1532. {
  1533.     PHYSFS_Io *retval = NULL;
  1534.     ZIPinfo *info = (ZIPinfo *) opaque;
  1535.     ZIPentry *entry = zip_find_entry(info, filename);
  1536.     ZIPfileinfo *finfo = NULL;
  1537.     PHYSFS_Io *io = NULL;
  1538.     PHYSFS_uint8 *password = NULL;
  1539.  
  1540.     /* if not found, see if maybe "$PASSWORD" is appended. */
  1541.     if ((!entry) && (info->has_crypto))
  1542.     {
  1543.         const char *ptr = strrchr(filename, '$');
  1544.         if (ptr != NULL)
  1545.         {
  1546.             const size_t len = (size_t) (ptr - filename);
  1547.             char *str = (char *) __PHYSFS_smallAlloc(len + 1);
  1548.             BAIL_IF(!str, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
  1549.             memcpy(str, filename, len);
  1550.             str[len] = '\0';
  1551.             entry = zip_find_entry(info, str);
  1552.             __PHYSFS_smallFree(str);
  1553.             password = (PHYSFS_uint8 *) (ptr + 1);
  1554.         } /* if */
  1555.     } /* if */
  1556.  
  1557.     BAIL_IF_ERRPASS(!entry, NULL);
  1558.  
  1559.     BAIL_IF_ERRPASS(!zip_resolve(info->io, info, entry), NULL);
  1560.  
  1561.     BAIL_IF(entry->tree.isdir, PHYSFS_ERR_NOT_A_FILE, NULL);
  1562.  
  1563.     retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
  1564.     GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
  1565.  
  1566.     finfo = (ZIPfileinfo *) allocator.Malloc(sizeof (ZIPfileinfo));
  1567.     GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
  1568.     memset(finfo, '\0', sizeof (ZIPfileinfo));
  1569.  
  1570.     io = zip_get_io(info->io, info, entry);
  1571.     GOTO_IF_ERRPASS(!io, ZIP_openRead_failed);
  1572.     finfo->io = io;
  1573.     finfo->entry = ((entry->symlink != NULL) ? entry->symlink : entry);
  1574.     initializeZStream(&finfo->stream);
  1575.  
  1576.     if (finfo->entry->compression_method != COMPMETH_NONE)
  1577.     {
  1578.         finfo->buffer = (PHYSFS_uint8 *) allocator.Malloc(ZIP_READBUFSIZE);
  1579.         if (!finfo->buffer)
  1580.             GOTO(PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
  1581.         else if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)
  1582.             goto ZIP_openRead_failed;
  1583.     } /* if */
  1584.  
  1585.     if (!zip_entry_is_tradional_crypto(entry))
  1586.         GOTO_IF(password != NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
  1587.     else
  1588.     {
  1589.         PHYSFS_uint8 crypto_header[12];
  1590.         GOTO_IF(password == NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
  1591.         if (io->read(io, crypto_header, 12) != 12)
  1592.             goto ZIP_openRead_failed;
  1593.         else if (!zip_prep_crypto_keys(finfo, crypto_header, password))
  1594.             goto ZIP_openRead_failed;
  1595.     } /* if */
  1596.  
  1597.     memcpy(retval, &ZIP_Io, sizeof (PHYSFS_Io));
  1598.     retval->opaque = finfo;
  1599.  
  1600.     return retval;
  1601.  
  1602. ZIP_openRead_failed:
  1603.     if (finfo != NULL)
  1604.     {
  1605.         if (finfo->io != NULL)
  1606.             finfo->io->destroy(finfo->io);
  1607.  
  1608.         if (finfo->buffer != NULL)
  1609.         {
  1610.             allocator.Free(finfo->buffer);
  1611.             inflateEnd(&finfo->stream);
  1612.         } /* if */
  1613.  
  1614.         allocator.Free(finfo);
  1615.     } /* if */
  1616.  
  1617.     if (retval != NULL)
  1618.         allocator.Free(retval);
  1619.  
  1620.     return NULL;
  1621. } /* ZIP_openRead */
  1622.  
  1623.  
  1624. static PHYSFS_Io *ZIP_openWrite(void *opaque, const char *filename)
  1625. {
  1626.     BAIL(PHYSFS_ERR_READ_ONLY, NULL);
  1627. } /* ZIP_openWrite */
  1628.  
  1629.  
  1630. static PHYSFS_Io *ZIP_openAppend(void *opaque, const char *filename)
  1631. {
  1632.     BAIL(PHYSFS_ERR_READ_ONLY, NULL);
  1633. } /* ZIP_openAppend */
  1634.  
  1635.  
  1636. static int ZIP_remove(void *opaque, const char *name)
  1637. {
  1638.     BAIL(PHYSFS_ERR_READ_ONLY, 0);
  1639. } /* ZIP_remove */
  1640.  
  1641.  
  1642. static int ZIP_mkdir(void *opaque, const char *name)
  1643. {
  1644.     BAIL(PHYSFS_ERR_READ_ONLY, 0);
  1645. } /* ZIP_mkdir */
  1646.  
  1647.  
  1648. static int ZIP_stat(void *opaque, const char *filename, PHYSFS_Stat *stat)
  1649. {
  1650.     ZIPinfo *info = (ZIPinfo *) opaque;
  1651.     ZIPentry *entry = zip_find_entry(info, filename);
  1652.  
  1653.     if (entry == NULL)
  1654.         return 0;
  1655.  
  1656.     else if (!zip_resolve(info->io, info, entry))
  1657.         return 0;
  1658.  
  1659.     else if (entry->resolved == ZIP_DIRECTORY)
  1660.     {
  1661.         stat->filesize = 0;
  1662.         stat->filetype = PHYSFS_FILETYPE_DIRECTORY;
  1663.     } /* if */
  1664.  
  1665.     else if (zip_entry_is_symlink(entry))
  1666.     {
  1667.         stat->filesize = 0;
  1668.         stat->filetype = PHYSFS_FILETYPE_SYMLINK;
  1669.     } /* else if */
  1670.  
  1671.     else
  1672.     {
  1673.         stat->filesize = (PHYSFS_sint64) entry->uncompressed_size;
  1674.         stat->filetype = PHYSFS_FILETYPE_REGULAR;
  1675.     } /* else */
  1676.  
  1677.     stat->modtime = ((entry) ? entry->last_mod_time : 0);
  1678.     stat->createtime = stat->modtime;
  1679.     stat->accesstime = -1;
  1680.     stat->readonly = 1; /* .zip files are always read only */
  1681.  
  1682.     return 1;
  1683. } /* ZIP_stat */
  1684.  
  1685.  
  1686. const PHYSFS_Archiver __PHYSFS_Archiver_ZIP =
  1687. {
  1688.     CURRENT_PHYSFS_ARCHIVER_API_VERSION,
  1689.     {
  1690.         "ZIP",
  1691.         "PkZip/WinZip/Info-Zip compatible",
  1692.         "Ryan C. Gordon <icculus@icculus.org>",
  1693.         "https://icculus.org/physfs/",
  1694.         1,  /* supportsSymlinks */
  1695.     },
  1696.     ZIP_openArchive,
  1697.     __PHYSFS_DirTreeEnumerate,
  1698.     ZIP_openRead,
  1699.     ZIP_openWrite,
  1700.     ZIP_openAppend,
  1701.     ZIP_remove,
  1702.     ZIP_mkdir,
  1703.     ZIP_stat,
  1704.     ZIP_closeArchive
  1705. };
  1706.  
  1707. #endif  /* defined PHYSFS_SUPPORTS_ZIP */
  1708.  
  1709. /* end of physfs_archiver_zip.c ... */
  1710.  
  1711.