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     char *name;                         /* Name of file in archive        */

    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     struct _ZIPentry *hashnext;         /* next item in this hash bucket  */

    74     struct _ZIPentry *children;         /* linked list of kids, if dir    */

    75     struct _ZIPentry *sibling;          /* next item in same dir          */

    76 } ZIPentry;

    77 

    78 /*

    79  * One ZIPinfo is kept for each open ZIP archive.

    80  */

    81 typedef struct

    82 {

    83     PHYSFS_Io *io;            /* the i/o interface for this archive.    */

    84     ZIPentry root;            /* root of directory tree.                */

    85     ZIPentry **hash;          /* all entries hashed for fast lookup.    */

    86     size_t hashBuckets;       /* number of buckets in hash.             */

    87     int zip64;                /* non-zero if this is a Zip64 archive.   */

    88     int has_crypto;           /* non-zero if any entry uses encryption. */

    89 } ZIPinfo;

    90 

    91 /*

    92  * One ZIPfileinfo is kept for each open file in a ZIP archive.

    93  */

    94 typedef struct

    95 {

    96     ZIPentry *entry;                      /* Info on file.              */

    97     PHYSFS_Io *io;                        /* physical file handle.      */

    98     PHYSFS_uint32 compressed_position;    /* offset in compressed data. */

    99     PHYSFS_uint32 uncompressed_position;  /* tell() position.           */

   100     PHYSFS_uint8 *buffer;                 /* decompression buffer.      */

   101     PHYSFS_uint32 crypto_keys[3];         /* for "traditional" crypto.  */

   102     PHYSFS_uint32 initial_crypto_keys[3]; /* for "traditional" crypto.  */

   103     z_stream stream;                      /* zlib stream state.         */

   104 } ZIPfileinfo;

   105 

   106 

   107 /* Magic numbers... */

   108 #define ZIP_LOCAL_FILE_SIG                          0x04034b50

   109 #define ZIP_CENTRAL_DIR_SIG                         0x02014b50

   110 #define ZIP_END_OF_CENTRAL_DIR_SIG                  0x06054b50

   111 #define ZIP64_END_OF_CENTRAL_DIR_SIG                0x06064b50

   112 #define ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG  0x07064b50

   113 #define ZIP64_EXTENDED_INFO_EXTRA_FIELD_SIG         0x0001

   114 

   115 /* compression methods... */

   116 #define COMPMETH_NONE 0

   117 /* ...and others... */

   118 

   119 

   120 #define UNIX_FILETYPE_MASK    0170000

   121 #define UNIX_FILETYPE_SYMLINK 0120000

   122 

   123 #define ZIP_GENERAL_BITS_TRADITIONAL_CRYPTO   (1 << 0)

   124 #define ZIP_GENERAL_BITS_IGNORE_LOCAL_HEADER  (1 << 3)

   125 

   126 /* support for "traditional" PKWARE encryption. */

   127 static int zip_entry_is_tradional_crypto(const ZIPentry *entry)

   128 {

   129     return (entry->general_bits & ZIP_GENERAL_BITS_TRADITIONAL_CRYPTO) != 0;

   130 } /* zip_entry_is_traditional_crypto */

   131 

   132 static int zip_entry_ignore_local_header(const ZIPentry *entry)

   133 {

   134     return (entry->general_bits & ZIP_GENERAL_BITS_IGNORE_LOCAL_HEADER) != 0;

   135 } /* zip_entry_is_traditional_crypto */

   136 

   137 static PHYSFS_uint32 zip_crypto_crc32(const PHYSFS_uint32 crc, const PHYSFS_uint8 val)

   138 {

   139     int i;

   140     PHYSFS_uint32 xorval = (crc ^ ((PHYSFS_uint32) val)) & 0xFF;

   141     for (i = 0; i < 8; i++)

   142         xorval = ((xorval & 1) ? (0xEDB88320 ^ (xorval >> 1)) : (xorval >> 1));

   143     return xorval ^ (crc >> 8);

   144 } /* zip_crc32 */

   145 

   146 static void zip_update_crypto_keys(PHYSFS_uint32 *keys, const PHYSFS_uint8 val)

   147 {

   148     keys[0] = zip_crypto_crc32(keys[0], val);

   149     keys[1] = keys[1] + (keys[0] & 0x000000FF);

   150     keys[1] = (keys[1] * 134775813) + 1;

   151     keys[2] = zip_crypto_crc32(keys[2], (PHYSFS_uint8) ((keys[1] >> 24) & 0xFF));

   152 } /* zip_update_crypto_keys */

   153 

   154 static PHYSFS_uint8 zip_decrypt_byte(const PHYSFS_uint32 *keys)

   155 {

   156     const PHYSFS_uint16 tmp = keys[2] | 2;

   157     return (PHYSFS_uint8) ((tmp * (tmp ^ 1)) >> 8);

   158 } /* zip_decrypt_byte */

   159 

   160 static PHYSFS_sint64 zip_read_decrypt(ZIPfileinfo *finfo, void *buf, PHYSFS_uint64 len)

   161 {

   162     PHYSFS_Io *io = finfo->io;

   163     const PHYSFS_sint64 br = io->read(io, buf, len);

   164 

   165     /* Decompression the new data if necessary. */

   166     if (zip_entry_is_tradional_crypto(finfo->entry) && (br > 0))

   167     {

   168         PHYSFS_uint32 *keys = finfo->crypto_keys;

   169         PHYSFS_uint8 *ptr = (PHYSFS_uint8 *) buf;

   170         PHYSFS_sint64 i;

   171         for (i = 0; i < br; i++, ptr++)

   172         {

   173             const PHYSFS_uint8 ch = *ptr ^ zip_decrypt_byte(keys);

   174             zip_update_crypto_keys(keys, ch);

   175             *ptr = ch;

   176         } /* for */

   177     } /* if  */

   178 

   179     return br;

   180 } /* zip_read_decrypt */

   181 

   182 static int zip_prep_crypto_keys(ZIPfileinfo *finfo, const PHYSFS_uint8 *crypto_header, const PHYSFS_uint8 *password)

   183 {

   184     /* It doesn't appear to be documented in PKWare's APPNOTE.TXT, but you

   185        need to use a different byte in the header to verify the password

   186        if general purpose bit 3 is set. Discovered this from Info-Zip.

   187        That's what the (verifier) value is doing, below. */

   188 

   189     PHYSFS_uint32 *keys = finfo->crypto_keys;

   190     const ZIPentry *entry = finfo->entry;

   191     const int usedate = zip_entry_ignore_local_header(entry);

   192     const PHYSFS_uint8 verifier = (PHYSFS_uint8) ((usedate ? (entry->dos_mod_time >> 8) : (entry->crc >> 24)) & 0xFF);

   193     PHYSFS_uint8 finalbyte = 0;

   194     int i = 0;

   195 

   196     /* initialize vector with defaults, then password, then header. */

   197     keys[0] = 305419896;

   198     keys[1] = 591751049;

   199     keys[2] = 878082192;

   200 

   201     while (*password)

   202         zip_update_crypto_keys(keys, *(password++));

   203 

   204     for (i = 0; i < 12; i++)

   205     {

   206         const PHYSFS_uint8 c = crypto_header[i] ^ zip_decrypt_byte(keys);

   207         zip_update_crypto_keys(keys, c);

   208         finalbyte = c;

   209     } /* for */

   210 

   211     /* you have a 1/256 chance of passing this test incorrectly. :/ */

   212     if (finalbyte != verifier)

   213         BAIL_MACRO(PHYSFS_ERR_BAD_PASSWORD, 0);

   214 

   215     /* save the initial vector for seeking purposes. Not secure!! */

   216     memcpy(finfo->initial_crypto_keys, finfo->crypto_keys, 12);

   217     return 1;

   218 } /* zip_prep_crypto_keys */

   219 

   220 

   221 /*

   222  * Bridge physfs allocation functions to zlib's format...

   223  */

   224 static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size)

   225 {

   226     return ((PHYSFS_Allocator *) opaque)->Malloc(items * size);

   227 } /* zlibPhysfsAlloc */

   228 

   229 /*

   230  * Bridge physfs allocation functions to zlib's format...

   231  */

   232 static void zlibPhysfsFree(voidpf opaque, voidpf address)

   233 {

   234     ((PHYSFS_Allocator *) opaque)->Free(address);

   235 } /* zlibPhysfsFree */

   236 

   237 

   238 /*

   239  * Construct a new z_stream to a sane state.

   240  */

   241 static void initializeZStream(z_stream *pstr)

   242 {

   243     memset(pstr, '\0', sizeof (z_stream));

   244     pstr->zalloc = zlibPhysfsAlloc;

   245     pstr->zfree = zlibPhysfsFree;

   246     pstr->opaque = &allocator;

   247 } /* initializeZStream */

   248 

   249 

   250 static PHYSFS_ErrorCode zlib_error_code(int rc)

   251 {

   252     switch (rc)

   253     {

   254         case Z_OK: return PHYSFS_ERR_OK;  /* not an error. */

   255         case Z_STREAM_END: return PHYSFS_ERR_OK; /* not an error. */

   256         case Z_ERRNO: return PHYSFS_ERR_IO;

   257         case Z_MEM_ERROR: return PHYSFS_ERR_OUT_OF_MEMORY;

   258         default: return PHYSFS_ERR_CORRUPT;

   259     } /* switch */

   260 } /* zlib_error_string */

   261 

   262 

   263 /*

   264  * Wrap all zlib calls in this, so the physfs error state is set appropriately.

   265  */

   266 static int zlib_err(const int rc)

   267 {

   268     PHYSFS_setErrorCode(zlib_error_code(rc));

   269     return rc;

   270 } /* zlib_err */

   271 

   272 /*

   273  * Hash a string for lookup an a ZIPinfo hashtable.

   274  */

   275 static inline PHYSFS_uint32 zip_hash_string(const ZIPinfo *info, const char *s)

   276 {

   277     return __PHYSFS_hashString(s, strlen(s)) % info->hashBuckets;

   278 } /* zip_hash_string */

   279 

   280 /*

   281  * Read an unsigned 64-bit int and swap to native byte order.

   282  */

   283 static int readui64(PHYSFS_Io *io, PHYSFS_uint64 *val)

   284 {

   285     PHYSFS_uint64 v;

   286     BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);

   287     *val = PHYSFS_swapULE64(v);

   288     return 1;

   289 } /* readui64 */

   290 

   291 /*

   292  * Read an unsigned 32-bit int and swap to native byte order.

   293  */

   294 static int readui32(PHYSFS_Io *io, PHYSFS_uint32 *val)

   295 {

   296     PHYSFS_uint32 v;

   297     BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);

   298     *val = PHYSFS_swapULE32(v);

   299     return 1;

   300 } /* readui32 */

   301 

   302 

   303 /*

   304  * Read an unsigned 16-bit int and swap to native byte order.

   305  */

   306 static int readui16(PHYSFS_Io *io, PHYSFS_uint16 *val)

   307 {

   308     PHYSFS_uint16 v;

   309     BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);

   310     *val = PHYSFS_swapULE16(v);

   311     return 1;

   312 } /* readui16 */

   313 

   314 

   315 static PHYSFS_sint64 ZIP_read(PHYSFS_Io *_io, void *buf, PHYSFS_uint64 len)

   316 {

   317     ZIPfileinfo *finfo = (ZIPfileinfo *) _io->opaque;

   318     ZIPentry *entry = finfo->entry;

   319     PHYSFS_sint64 retval = 0;

   320     PHYSFS_sint64 maxread = (PHYSFS_sint64) len;

   321     PHYSFS_sint64 avail = entry->uncompressed_size -

   322                           finfo->uncompressed_position;

   323 

   324     if (avail < maxread)

   325         maxread = avail;

   326 

   327     BAIL_IF_MACRO(maxread == 0, ERRPASS, 0);    /* quick rejection. */

   328 

   329     if (entry->compression_method == COMPMETH_NONE)

   330         retval = zip_read_decrypt(finfo, buf, maxread);

   331     else

   332     {

   333         finfo->stream.next_out = buf;

   334         finfo->stream.avail_out = (uInt) maxread;

   335 

   336         while (retval < maxread)

   337         {

   338             PHYSFS_uint32 before = finfo->stream.total_out;

   339             int rc;

   340 

   341             if (finfo->stream.avail_in == 0)

   342             {

   343                 PHYSFS_sint64 br;

   344 

   345                 br = entry->compressed_size - finfo->compressed_position;

   346                 if (br > 0)

   347                 {

   348                     if (br > ZIP_READBUFSIZE)

   349                         br = ZIP_READBUFSIZE;

   350 

   351                     br = zip_read_decrypt(finfo, finfo->buffer, (PHYSFS_uint64) br);

   352                     if (br <= 0)

   353                         break;

   354 

   355                     finfo->compressed_position += (PHYSFS_uint32) br;

   356                     finfo->stream.next_in = finfo->buffer;

   357                     finfo->stream.avail_in = (PHYSFS_uint32) br;

   358                 } /* if */

   359             } /* if */

   360 

   361             rc = zlib_err(inflate(&finfo->stream, Z_SYNC_FLUSH));

   362             retval += (finfo->stream.total_out - before);

   363 

   364             if (rc != Z_OK)

   365                 break;

   366         } /* while */

   367     } /* else */

   368 

   369     if (retval > 0)

   370         finfo->uncompressed_position += (PHYSFS_uint32) retval;

   371 

   372     return retval;

   373 } /* ZIP_read */

   374 

   375 

   376 static PHYSFS_sint64 ZIP_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)

   377 {

   378     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);

   379 } /* ZIP_write */

   380 

   381 

   382 static PHYSFS_sint64 ZIP_tell(PHYSFS_Io *io)

   383 {

   384     return ((ZIPfileinfo *) io->opaque)->uncompressed_position;

   385 } /* ZIP_tell */

   386 

   387 

   388 static int ZIP_seek(PHYSFS_Io *_io, PHYSFS_uint64 offset)

   389 {

   390     ZIPfileinfo *finfo = (ZIPfileinfo *) _io->opaque;

   391     ZIPentry *entry = finfo->entry;

   392     PHYSFS_Io *io = finfo->io;

   393     const int encrypted = zip_entry_is_tradional_crypto(entry);

   394 

   395     BAIL_IF_MACRO(offset > entry->uncompressed_size, PHYSFS_ERR_PAST_EOF, 0);

   396 

   397     if (!encrypted && (entry->compression_method == COMPMETH_NONE))

   398     {

   399         PHYSFS_sint64 newpos = offset + entry->offset;

   400         BAIL_IF_MACRO(!io->seek(io, newpos), ERRPASS, 0);

   401         finfo->uncompressed_position = (PHYSFS_uint32) offset;

   402     } /* if */

   403 

   404     else

   405     {

   406         /*

   407          * If seeking backwards, we need to redecode the file

   408          *  from the start and throw away the compressed bits until we hit

   409          *  the offset we need. If seeking forward, we still need to

   410          *  decode, but we don't rewind first.

   411          */

   412         if (offset < finfo->uncompressed_position)

   413         {

   414             /* we do a copy so state is sane if inflateInit2() fails. */

   415             z_stream str;

   416             initializeZStream(&str);

   417             if (zlib_err(inflateInit2(&str, -MAX_WBITS)) != Z_OK)

   418                 return 0;

   419 

   420             if (!io->seek(io, entry->offset + (encrypted ? 12 : 0)))

   421                 return 0;

   422 

   423             inflateEnd(&finfo->stream);

   424             memcpy(&finfo->stream, &str, sizeof (z_stream));

   425             finfo->uncompressed_position = finfo->compressed_position = 0;

   426 

   427             if (encrypted)

   428                 memcpy(finfo->crypto_keys, finfo->initial_crypto_keys, 12);

   429         } /* if */

   430 

   431         while (finfo->uncompressed_position != offset)

   432         {

   433             PHYSFS_uint8 buf[512];

   434             PHYSFS_uint32 maxread;

   435 

   436             maxread = (PHYSFS_uint32) (offset - finfo->uncompressed_position);

   437             if (maxread > sizeof (buf))

   438                 maxread = sizeof (buf);

   439 

   440             if (ZIP_read(_io, buf, maxread) != maxread)

   441                 return 0;

   442         } /* while */

   443     } /* else */

   444 

   445     return 1;

   446 } /* ZIP_seek */

   447 

   448 

   449 static PHYSFS_sint64 ZIP_length(PHYSFS_Io *io)

   450 {

   451     const ZIPfileinfo *finfo = (ZIPfileinfo *) io->opaque;

   452     return (PHYSFS_sint64) finfo->entry->uncompressed_size;

   453 } /* ZIP_length */

   454 

   455 

   456 static PHYSFS_Io *zip_get_io(PHYSFS_Io *io, ZIPinfo *inf, ZIPentry *entry);

   457 

   458 static PHYSFS_Io *ZIP_duplicate(PHYSFS_Io *io)

   459 {

   460     ZIPfileinfo *origfinfo = (ZIPfileinfo *) io->opaque;

   461     PHYSFS_Io *retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   462     ZIPfileinfo *finfo = (ZIPfileinfo *) allocator.Malloc(sizeof (ZIPfileinfo));

   463     GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);

   464     GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);

   465     memset(finfo, '\0', sizeof (*finfo));

   466 

   467     finfo->entry = origfinfo->entry;

   468     finfo->io = zip_get_io(origfinfo->io, NULL, finfo->entry);

   469     GOTO_IF_MACRO(!finfo->io, ERRPASS, failed);

   470 

   471     if (finfo->entry->compression_method != COMPMETH_NONE)

   472     {

   473         finfo->buffer = (PHYSFS_uint8 *) allocator.Malloc(ZIP_READBUFSIZE);

   474         GOTO_IF_MACRO(!finfo->buffer, PHYSFS_ERR_OUT_OF_MEMORY, failed);

   475         if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)

   476             goto failed;

   477     } /* if */

   478 

   479     memcpy(retval, io, sizeof (PHYSFS_Io));

   480     retval->opaque = finfo;

   481     return retval;

   482 

   483 failed:

   484     if (finfo != NULL)

   485     {

   486         if (finfo->io != NULL)

   487             finfo->io->destroy(finfo->io);

   488 

   489         if (finfo->buffer != NULL)

   490         {

   491             allocator.Free(finfo->buffer);

   492             inflateEnd(&finfo->stream);

   493         } /* if */

   494 

   495         allocator.Free(finfo);

   496     } /* if */

   497 

   498     if (retval != NULL)

   499         allocator.Free(retval);

   500 

   501     return NULL;

   502 } /* ZIP_duplicate */

   503 

   504 static int ZIP_flush(PHYSFS_Io *io) { return 1;  /* no write support. */ }

   505 

   506 static void ZIP_destroy(PHYSFS_Io *io)

   507 {

   508     ZIPfileinfo *finfo = (ZIPfileinfo *) io->opaque;

   509     finfo->io->destroy(finfo->io);

   510 

   511     if (finfo->entry->compression_method != COMPMETH_NONE)

   512         inflateEnd(&finfo->stream);

   513 

   514     if (finfo->buffer != NULL)

   515         allocator.Free(finfo->buffer);

   516 

   517     allocator.Free(finfo);

   518     allocator.Free(io);

   519 } /* ZIP_destroy */

   520 

   521 

   522 static const PHYSFS_Io ZIP_Io =

   523 {

   524     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   525     ZIP_read,

   526     ZIP_write,

   527     ZIP_seek,

   528     ZIP_tell,

   529     ZIP_length,

   530     ZIP_duplicate,

   531     ZIP_flush,

   532     ZIP_destroy

   533 };

   534 

   535 

   536 

   537 static PHYSFS_sint64 zip_find_end_of_central_dir(PHYSFS_Io *io, PHYSFS_sint64 *len)

   538 {

   539     PHYSFS_uint8 buf[256];

   540     PHYSFS_uint8 extra[4] = { 0, 0, 0, 0 };

   541     PHYSFS_sint32 i = 0;

   542     PHYSFS_sint64 filelen;

   543     PHYSFS_sint64 filepos;

   544     PHYSFS_sint32 maxread;

   545     PHYSFS_sint32 totalread = 0;

   546     int found = 0;

   547 

   548     filelen = io->length(io);

   549     BAIL_IF_MACRO(filelen == -1, ERRPASS, -1);

   550 

   551     /*

   552      * Jump to the end of the file and start reading backwards.

   553      *  The last thing in the file is the zipfile comment, which is variable

   554      *  length, and the field that specifies its size is before it in the

   555      *  file (argh!)...this means that we need to scan backwards until we

   556      *  hit the end-of-central-dir signature. We can then sanity check that

   557      *  the comment was as big as it should be to make sure we're in the

   558      *  right place. The comment length field is 16 bits, so we can stop

   559      *  searching for that signature after a little more than 64k at most,

   560      *  and call it a corrupted zipfile.

   561      */

   562 

   563     if (sizeof (buf) < filelen)

   564     {

   565         filepos = filelen - sizeof (buf);

   566         maxread = sizeof (buf);

   567     } /* if */

   568     else

   569     {

   570         filepos = 0;

   571         maxread = (PHYSFS_uint32) filelen;

   572     } /* else */

   573 

   574     while ((totalread < filelen) && (totalread < 65557))

   575     {

   576         BAIL_IF_MACRO(!io->seek(io, filepos), ERRPASS, -1);

   577 

   578         /* make sure we catch a signature between buffers. */

   579         if (totalread != 0)

   580         {

   581             if (!__PHYSFS_readAll(io, buf, maxread - 4))

   582                 return -1;

   583             memcpy(&buf[maxread - 4], &extra, sizeof (extra));

   584             totalread += maxread - 4;

   585         } /* if */

   586         else

   587         {

   588             if (!__PHYSFS_readAll(io, buf, maxread))

   589                 return -1;

   590             totalread += maxread;

   591         } /* else */

   592 

   593         memcpy(&extra, buf, sizeof (extra));

   594 

   595         for (i = maxread - 4; i > 0; i--)

   596         {

   597             if ((buf[i + 0] == 0x50) &&

   598                 (buf[i + 1] == 0x4B) &&

   599                 (buf[i + 2] == 0x05) &&

   600                 (buf[i + 3] == 0x06) )

   601             {

   602                 found = 1;  /* that's the signature! */

   603                 break;  

   604             } /* if */

   605         } /* for */

   606 

   607         if (found)

   608             break;

   609 

   610         filepos -= (maxread - 4);

   611         if (filepos < 0)

   612             filepos = 0;

   613     } /* while */

   614 

   615     BAIL_IF_MACRO(!found, PHYSFS_ERR_UNSUPPORTED, -1);

   616 

   617     if (len != NULL)

   618         *len = filelen;

   619 

   620     return (filepos + i);

   621 } /* zip_find_end_of_central_dir */

   622 

   623 

   624 static int isZip(PHYSFS_Io *io)

   625 {

   626     PHYSFS_uint32 sig = 0;

   627     int retval = 0;

   628 

   629     /*

   630      * The first thing in a zip file might be the signature of the

   631      *  first local file record, so it makes for a quick determination.

   632      */

   633     if (readui32(io, &sig))

   634     {

   635         retval = (sig == ZIP_LOCAL_FILE_SIG);

   636         if (!retval)

   637         {

   638             /*

   639              * No sig...might be a ZIP with data at the start

   640              *  (a self-extracting executable, etc), so we'll have to do

   641              *  it the hard way...

   642              */

   643             retval = (zip_find_end_of_central_dir(io, NULL) != -1);

   644         } /* if */

   645     } /* if */

   646 

   647     return retval;

   648 } /* isZip */

   649 

   650 

   651 /* Find the ZIPentry for a path in platform-independent notation. */

   652 static ZIPentry *zip_find_entry(ZIPinfo *info, const char *path)

   653 {

   654     PHYSFS_uint32 hashval;

   655     ZIPentry *prev = NULL;

   656     ZIPentry *retval;

   657 

   658     if (*path == '\0')

   659         return &info->root;

   660 

   661     hashval = zip_hash_string(info, path);

   662     for (retval = info->hash[hashval]; retval; retval = retval->hashnext)

   663     {

   664         if (strcmp(retval->name, path) == 0)

   665         {

   666             if (prev != NULL)  /* move this to the front of the list */

   667             {

   668                 prev->hashnext = retval->hashnext;

   669                 retval->hashnext = info->hash[hashval];

   670                 info->hash[hashval] = retval;

   671             } /* if */

   672 

   673             return retval;

   674         } /* if */

   675 

   676         prev = retval;

   677     } /* for */

   678 

   679     BAIL_MACRO(PHYSFS_ERR_NOT_FOUND, NULL);

   680 } /* zip_find_entry */

   681 

   682 

   683 /* Convert paths from old, buggy DOS zippers... */

   684 static void zip_convert_dos_path(ZIPentry *entry, char *path)

   685 {

   686     PHYSFS_uint8 hosttype = (PHYSFS_uint8) ((entry->version >> 8) & 0xFF);

   687     if (hosttype == 0)  /* FS_FAT_ */

   688     {

   689         while (*path)

   690         {

   691             if (*path == '\\')

   692                 *path = '/';

   693             path++;

   694         } /* while */

   695     } /* if */

   696 } /* zip_convert_dos_path */

   697 

   698 

   699 static void zip_expand_symlink_path(char *path)

   700 {

   701     char *ptr = path;

   702     char *prevptr = path;

   703 

   704     while (1)

   705     {

   706         ptr = strchr(ptr, '/');

   707         if (ptr == NULL)

   708             break;

   709 

   710         if (*(ptr + 1) == '.')

   711         {

   712             if (*(ptr + 2) == '/')

   713             {

   714                 /* current dir in middle of string: ditch it. */

   715                 memmove(ptr, ptr + 2, strlen(ptr + 2) + 1);

   716             } /* else if */

   717 

   718             else if (*(ptr + 2) == '\0')

   719             {

   720                 /* current dir at end of string: ditch it. */

   721                 *ptr = '\0';

   722             } /* else if */

   723 

   724             else if (*(ptr + 2) == '.')

   725             {

   726                 if (*(ptr + 3) == '/')

   727                 {

   728                     /* parent dir in middle: move back one, if possible. */

   729                     memmove(prevptr, ptr + 4, strlen(ptr + 4) + 1);

   730                     ptr = prevptr;

   731                     while (prevptr != path)

   732                     {

   733                         prevptr--;

   734                         if (*prevptr == '/')

   735                         {

   736                             prevptr++;

   737                             break;

   738                         } /* if */

   739                     } /* while */

   740                 } /* if */

   741 

   742                 if (*(ptr + 3) == '\0')

   743                 {

   744                     /* parent dir at end: move back one, if possible. */

   745                     *prevptr = '\0';

   746                 } /* if */

   747             } /* if */

   748         } /* if */

   749         else

   750         {

   751             prevptr = ptr;

   752             ptr++;

   753         } /* else */

   754     } /* while */

   755 } /* zip_expand_symlink_path */

   756 

   757 /* (forward reference: zip_follow_symlink and zip_resolve call each other.) */

   758 static int zip_resolve(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry);

   759 

   760 /*

   761  * Look for the entry named by (path). If it exists, resolve it, and return

   762  *  a pointer to that entry. If it's another symlink, keep resolving until you

   763  *  hit a real file and then return a pointer to the final non-symlink entry.

   764  *  If there's a problem, return NULL.

   765  */

   766 static ZIPentry *zip_follow_symlink(PHYSFS_Io *io, ZIPinfo *info, char *path)

   767 {

   768     ZIPentry *entry;

   769 

   770     zip_expand_symlink_path(path);

   771     entry = zip_find_entry(info, path);

   772     if (entry != NULL)

   773     {

   774         if (!zip_resolve(io, info, entry))  /* recursive! */

   775             entry = NULL;

   776         else

   777         {

   778             if (entry->symlink != NULL)

   779                 entry = entry->symlink;

   780         } /* else */

   781     } /* if */

   782 

   783     return entry;

   784 } /* zip_follow_symlink */

   785 

   786 

   787 static int zip_resolve_symlink(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)

   788 {

   789     const PHYSFS_uint64 size = entry->uncompressed_size;

   790     char *path = NULL;

   791     int rc = 0;

   792 

   793     /*

   794      * We've already parsed the local file header of the symlink at this

   795      *  point. Now we need to read the actual link from the file data and

   796      *  follow it.

   797      */

   798 

   799     BAIL_IF_MACRO(!io->seek(io, entry->offset), ERRPASS, 0);

   800 

   801     path = (char *) __PHYSFS_smallAlloc(size + 1);

   802     BAIL_IF_MACRO(!path, PHYSFS_ERR_OUT_OF_MEMORY, 0);

   803     

   804     if (entry->compression_method == COMPMETH_NONE)

   805         rc = __PHYSFS_readAll(io, path, size);

   806 

   807     else  /* symlink target path is compressed... */

   808     {

   809         z_stream stream;

   810         const PHYSFS_uint64 complen = entry->compressed_size;

   811         PHYSFS_uint8 *compressed = (PHYSFS_uint8*) __PHYSFS_smallAlloc(complen);

   812         if (compressed != NULL)

   813         {

   814             if (__PHYSFS_readAll(io, compressed, complen))

   815             {

   816                 initializeZStream(&stream);

   817                 stream.next_in = compressed;

   818                 stream.avail_in = complen;

   819                 stream.next_out = (unsigned char *) path;

   820                 stream.avail_out = size;

   821                 if (zlib_err(inflateInit2(&stream, -MAX_WBITS)) == Z_OK)

   822                 {

   823                     rc = zlib_err(inflate(&stream, Z_FINISH));

   824                     inflateEnd(&stream);

   825 

   826                     /* both are acceptable outcomes... */

   827                     rc = ((rc == Z_OK) || (rc == Z_STREAM_END));

   828                 } /* if */

   829             } /* if */

   830             __PHYSFS_smallFree(compressed);

   831         } /* if */

   832     } /* else */

   833 

   834     if (rc)

   835     {

   836         path[entry->uncompressed_size] = '\0';    /* null-terminate it. */

   837         zip_convert_dos_path(entry, path);

   838         entry->symlink = zip_follow_symlink(io, info, path);

   839     } /* else */

   840 

   841     __PHYSFS_smallFree(path);

   842 

   843     return (entry->symlink != NULL);

   844 } /* zip_resolve_symlink */

   845 

   846 

   847 /*

   848  * Parse the local file header of an entry, and update entry->offset.

   849  */

   850 static int zip_parse_local(PHYSFS_Io *io, ZIPentry *entry)

   851 {

   852     PHYSFS_uint32 ui32;

   853     PHYSFS_uint16 ui16;

   854     PHYSFS_uint16 fnamelen;

   855     PHYSFS_uint16 extralen;

   856 

   857     /*

   858      * crc and (un)compressed_size are always zero if this is a "JAR"

   859      *  archive created with Sun's Java tools, apparently. We only

   860      *  consider this archive corrupted if those entries don't match and

   861      *  aren't zero. That seems to work well.

   862      * We also ignore a mismatch if the value is 0xFFFFFFFF here, since it's

   863      *  possible that's a Zip64 thing.

   864      */

   865 

   866     /* !!! FIXME: apparently these are zero if general purpose bit 3 is set,

   867        !!! FIXME:  which is probably true for Jar files, fwiw, but we don't

   868        !!! FIXME:  care about these values anyhow. */

   869 

   870     BAIL_IF_MACRO(!io->seek(io, entry->offset), ERRPASS, 0);

   871     BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);

   872     BAIL_IF_MACRO(ui32 != ZIP_LOCAL_FILE_SIG, PHYSFS_ERR_CORRUPT, 0);

   873     BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);

   874     BAIL_IF_MACRO(ui16 != entry->version_needed, PHYSFS_ERR_CORRUPT, 0);

   875     BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);  /* general bits. */

   876     BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);

   877     BAIL_IF_MACRO(ui16 != entry->compression_method, PHYSFS_ERR_CORRUPT, 0);

   878     BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);  /* date/time */

   879     BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);

   880     BAIL_IF_MACRO(ui32 && (ui32 != entry->crc), PHYSFS_ERR_CORRUPT, 0);

   881 

   882     BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);

   883     BAIL_IF_MACRO(ui32 && (ui32 != 0xFFFFFFFF) &&

   884                   (ui32 != entry->compressed_size), PHYSFS_ERR_CORRUPT, 0);

   885 

   886     BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);

   887     BAIL_IF_MACRO(ui32 && (ui32 != 0xFFFFFFFF) &&

   888                  (ui32 != entry->uncompressed_size), PHYSFS_ERR_CORRUPT, 0);

   889 

   890     BAIL_IF_MACRO(!readui16(io, &fnamelen), ERRPASS, 0);

   891     BAIL_IF_MACRO(!readui16(io, &extralen), ERRPASS, 0);

   892 

   893     entry->offset += fnamelen + extralen + 30;

   894     return 1;

   895 } /* zip_parse_local */

   896 

   897 

   898 static int zip_resolve(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)

   899 {

   900     int retval = 1;

   901     const ZipResolveType resolve_type = entry->resolved;

   902 

   903     if (resolve_type == ZIP_DIRECTORY)

   904         return 1;   /* we're good. */

   905 

   906     /* Don't bother if we've failed to resolve this entry before. */

   907     BAIL_IF_MACRO(resolve_type == ZIP_BROKEN_FILE, PHYSFS_ERR_CORRUPT, 0);

   908     BAIL_IF_MACRO(resolve_type == ZIP_BROKEN_SYMLINK, PHYSFS_ERR_CORRUPT, 0);

   909 

   910     /* uhoh...infinite symlink loop! */

   911     BAIL_IF_MACRO(resolve_type == ZIP_RESOLVING, PHYSFS_ERR_SYMLINK_LOOP, 0);

   912 

   913     /*

   914      * We fix up the offset to point to the actual data on the

   915      *  first open, since we don't want to seek across the whole file on

   916      *  archive open (can be SLOW on large, CD-stored files), but we

   917      *  need to check the local file header...not just for corruption,

   918      *  but since it stores offset info the central directory does not.

   919      */

   920     if (resolve_type != ZIP_RESOLVED)

   921     {

   922         entry->resolved = ZIP_RESOLVING;

   923 

   924         retval = zip_parse_local(io, entry);

   925         if (retval)

   926         {

   927             /*

   928              * If it's a symlink, find the original file. This will cause

   929              *  resolution of other entries (other symlinks and, eventually,

   930              *  the real file) if all goes well.

   931              */

   932             if (resolve_type == ZIP_UNRESOLVED_SYMLINK)

   933                 retval = zip_resolve_symlink(io, info, entry);

   934         } /* if */

   935 

   936         if (resolve_type == ZIP_UNRESOLVED_SYMLINK)

   937             entry->resolved = ((retval) ? ZIP_RESOLVED : ZIP_BROKEN_SYMLINK);

   938         else if (resolve_type == ZIP_UNRESOLVED_FILE)

   939             entry->resolved = ((retval) ? ZIP_RESOLVED : ZIP_BROKEN_FILE);

   940     } /* if */

   941 

   942     return retval;

   943 } /* zip_resolve */

   944 

   945 

   946 static int zip_hash_entry(ZIPinfo *info, ZIPentry *entry);

   947 

   948 /* Fill in missing parent directories. */

   949 static ZIPentry *zip_hash_ancestors(ZIPinfo *info, char *name)

   950 {

   951     ZIPentry *retval = &info->root;

   952     char *sep = strrchr(name, '/');

   953 

   954     if (sep)

   955     {

   956         const size_t namelen = (sep - name) + 1;

   957 

   958         *sep = '\0';  /* chop off last piece. */

   959         retval = zip_find_entry(info, name);

   960         *sep = '/';

   961 

   962         if (retval != NULL)

   963         {

   964             if (retval->resolved != ZIP_DIRECTORY)

   965                 BAIL_MACRO(PHYSFS_ERR_CORRUPT, NULL);

   966             return retval;  /* already hashed. */

   967         } /* if */

   968 

   969         /* okay, this is a new dir. Build and hash us. */

   970         retval = (ZIPentry *) allocator.Malloc(sizeof (ZIPentry) + namelen);

   971         BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   972         memset(retval, '\0', sizeof (*retval));

   973         retval->name = ((char *) retval) + sizeof (ZIPentry);

   974         memcpy(retval->name, name, namelen - 1);

   975         retval->name[namelen - 1] = '\0';

   976         retval->resolved = ZIP_DIRECTORY;

   977         if (!zip_hash_entry(info, retval))

   978         {

   979             allocator.Free(retval);

   980             return NULL;

   981         } /* if */

   982     } /* else */

   983 

   984     return retval;

   985 } /* zip_hash_ancestors */

   986 

   987 

   988 static int zip_hash_entry(ZIPinfo *info, ZIPentry *entry)

   989 {

   990     PHYSFS_uint32 hashval;

   991     ZIPentry *parent;

   992 

   993     assert(!zip_find_entry(info, entry->name));  /* checked elsewhere */

   994 

   995     parent = zip_hash_ancestors(info, entry->name);

   996     if (!parent)

   997         return 0;

   998 

   999     hashval = zip_hash_string(info, entry->name);

  1000     entry->hashnext = info->hash[hashval];

  1001     info->hash[hashval] = entry;

  1002 

  1003     entry->sibling = parent->children;

  1004     parent->children = entry;

  1005     return 1;

  1006 } /* zip_hash_entry */

  1007 

  1008 

  1009 static int zip_entry_is_symlink(const ZIPentry *entry)

  1010 {

  1011     return ((entry->resolved == ZIP_UNRESOLVED_SYMLINK) ||

  1012             (entry->resolved == ZIP_BROKEN_SYMLINK) ||

  1013             (entry->symlink));

  1014 } /* zip_entry_is_symlink */

  1015 

  1016 

  1017 static int zip_version_does_symlinks(PHYSFS_uint32 version)

  1018 {

  1019     int retval = 0;

  1020     PHYSFS_uint8 hosttype = (PHYSFS_uint8) ((version >> 8) & 0xFF);

  1021 

  1022     switch (hosttype)

  1023     {

  1024             /*

  1025              * These are the platforms that can NOT build an archive with

  1026              *  symlinks, according to the Info-ZIP project.

  1027              */

  1028         case 0:  /* FS_FAT_  */

  1029         case 1:  /* AMIGA_   */

  1030         case 2:  /* VMS_     */

  1031         case 4:  /* VM_CSM_  */

  1032         case 6:  /* FS_HPFS_ */

  1033         case 11: /* FS_NTFS_ */

  1034         case 14: /* FS_VFAT_ */

  1035         case 13: /* ACORN_   */

  1036         case 15: /* MVS_     */

  1037         case 18: /* THEOS_   */

  1038             break;  /* do nothing. */

  1039 

  1040         default:  /* assume the rest to be unix-like. */

  1041             retval = 1;

  1042             break;

  1043     } /* switch */

  1044 

  1045     return retval;

  1046 } /* zip_version_does_symlinks */

  1047 

  1048 

  1049 static int zip_has_symlink_attr(ZIPentry *entry, PHYSFS_uint32 extern_attr)

  1050 {

  1051     PHYSFS_uint16 xattr = ((extern_attr >> 16) & 0xFFFF);

  1052     return ( (zip_version_does_symlinks(entry->version)) &&

  1053              (entry->uncompressed_size > 0) &&

  1054              ((xattr & UNIX_FILETYPE_MASK) == UNIX_FILETYPE_SYMLINK) );

  1055 } /* zip_has_symlink_attr */

  1056 

  1057 

  1058 static PHYSFS_sint64 zip_dos_time_to_physfs_time(PHYSFS_uint32 dostime)

  1059 {

  1060     PHYSFS_uint32 dosdate;

  1061     struct tm unixtime;

  1062     memset(&unixtime, '\0', sizeof (unixtime));

  1063 

  1064     dosdate = (PHYSFS_uint32) ((dostime >> 16) & 0xFFFF);

  1065     dostime &= 0xFFFF;

  1066 

  1067     /* dissect date */

  1068     unixtime.tm_year = ((dosdate >> 9) & 0x7F) + 80;

  1069     unixtime.tm_mon  = ((dosdate >> 5) & 0x0F) - 1;

  1070     unixtime.tm_mday = ((dosdate     ) & 0x1F);

  1071 

  1072     /* dissect time */

  1073     unixtime.tm_hour = ((dostime >> 11) & 0x1F);

  1074     unixtime.tm_min  = ((dostime >>  5) & 0x3F);

  1075     unixtime.tm_sec  = ((dostime <<  1) & 0x3E);

  1076 

  1077     /* let mktime calculate daylight savings time. */

  1078     unixtime.tm_isdst = -1;

  1079 

  1080     return ((PHYSFS_sint64) mktime(&unixtime));

  1081 } /* zip_dos_time_to_physfs_time */

  1082 

  1083 

  1084 static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,

  1085                                 const PHYSFS_uint64 ofs_fixup)

  1086 {

  1087     ZIPentry entry;

  1088     ZIPentry *retval = NULL;

  1089     PHYSFS_uint16 fnamelen, extralen, commentlen;

  1090     PHYSFS_uint32 external_attr;

  1091     PHYSFS_uint32 starting_disk;

  1092     PHYSFS_uint64 offset;

  1093     PHYSFS_uint16 ui16;

  1094     PHYSFS_uint32 ui32;

  1095     PHYSFS_sint64 si64;

  1096 

  1097     memset(&entry, '\0', sizeof (entry));

  1098 

  1099     /* sanity check with central directory signature... */

  1100     if (!readui32(io, &ui32)) return NULL;

  1101     BAIL_IF_MACRO(ui32 != ZIP_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, NULL);

  1102 

  1103     /* Get the pertinent parts of the record... */

  1104     if (!readui16(io, &entry.version)) return NULL;

  1105     if (!readui16(io, &entry.version_needed)) return NULL;

  1106     if (!readui16(io, &entry.general_bits)) return NULL;  /* general bits */

  1107     if (!readui16(io, &entry.compression_method)) return NULL;

  1108     if (!readui32(io, &entry.dos_mod_time)) return NULL;

  1109     entry.last_mod_time = zip_dos_time_to_physfs_time(entry.dos_mod_time);

  1110     if (!readui32(io, &entry.crc)) return NULL;

  1111     if (!readui32(io, &ui32)) return NULL;

  1112     entry.compressed_size = (PHYSFS_uint64) ui32;

  1113     if (!readui32(io, &ui32)) return NULL;

  1114     entry.uncompressed_size = (PHYSFS_uint64) ui32;

  1115     if (!readui16(io, &fnamelen)) return NULL;

  1116     if (!readui16(io, &extralen)) return NULL;

  1117     if (!readui16(io, &commentlen)) return NULL;

  1118     if (!readui16(io, &ui16)) return NULL;

  1119     starting_disk = (PHYSFS_uint32) ui16;

  1120     if (!readui16(io, &ui16)) return NULL;  /* internal file attribs */

  1121     if (!readui32(io, &external_attr)) return NULL;

  1122     if (!readui32(io, &ui32)) return NULL;

  1123     offset = (PHYSFS_uint64) ui32;

  1124 

  1125     retval = (ZIPentry *) allocator.Malloc(sizeof (ZIPentry) + fnamelen + 1);

  1126     BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, 0);

  1127     memcpy(retval, &entry, sizeof (*retval));

  1128     retval->name = ((char *) retval) + sizeof (ZIPentry);

  1129 

  1130     if (!__PHYSFS_readAll(io, retval->name, fnamelen))

  1131         goto zip_load_entry_puked;

  1132 

  1133     retval->name[fnamelen] = '\0';  /* null-terminate the filename. */

  1134     zip_convert_dos_path(retval, retval->name);