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 #define USE_MINIZ 1

    19 #if USE_MINIZ

    20 #include "physfs_miniz.h"

    21 #else

    22 #include <zlib.h>

    23 #endif

    24 

    25 /*

    26  * A buffer of ZIP_READBUFSIZE is allocated for each compressed file opened,

    27  *  and is freed when you close the file; compressed data is read into

    28  *  this buffer, and then is decompressed into the buffer passed to

    29  *  PHYSFS_read().

    30  *

    31  * Uncompressed entries in a zipfile do not allocate this buffer; they just

    32  *  read data directly into the buffer passed to PHYSFS_read().

    33  *

    34  * Depending on your speed and memory requirements, you should tweak this

    35  *  value.

    36  */

    37 #define ZIP_READBUFSIZE   (16 * 1024)

    38 

    39 

    40 /*

    41  * Entries are "unresolved" until they are first opened. At that time,

    42  *  local file headers parsed/validated, data offsets will be updated to look

    43  *  at the actual file data instead of the header, and symlinks will be

    44  *  followed and optimized. This means that we don't seek and read around the

    45  *  archive until forced to do so, and after the first time, we had to do

    46  *  less reading and parsing, which is very CD-ROM friendly.

    47  */

    48 typedef enum

    49 {

    50     ZIP_UNRESOLVED_FILE,

    51     ZIP_UNRESOLVED_SYMLINK,

    52     ZIP_RESOLVING,

    53     ZIP_RESOLVED,

    54     ZIP_BROKEN_FILE,

    55     ZIP_BROKEN_SYMLINK

    56 } ZipResolveType;

    57 

    58 

    59 /*

    60  * One ZIPentry is kept for each file in an open ZIP archive.

    61  */

    62 typedef struct _ZIPentry

    63 {

    64     char *name;                         /* Name of file in archive        */

    65     struct _ZIPentry *symlink;          /* NULL or file we symlink to     */

    66     ZipResolveType resolved;            /* Have we resolved file/symlink? */

    67     PHYSFS_uint64 offset;               /* offset of data in archive      */

    68     PHYSFS_uint16 version;              /* version made by                */

    69     PHYSFS_uint16 version_needed;       /* version needed to extract      */

    70     PHYSFS_uint16 compression_method;   /* compression method             */

    71     PHYSFS_uint32 crc;                  /* crc-32                         */

    72     PHYSFS_uint64 compressed_size;      /* compressed size                */

    73     PHYSFS_uint64 uncompressed_size;    /* uncompressed size              */

    74     PHYSFS_sint64 last_mod_time;        /* last file mod time             */

    75 } ZIPentry;

    76 

    77 /*

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

    79  */

    80 typedef struct

    81 {

    82     PHYSFS_Io *io;

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

    84     PHYSFS_uint64 entryCount; /* Number of files in ZIP.              */

    85     ZIPentry *entries;        /* info on all files in ZIP.            */

    86 } ZIPinfo;

    87 

    88 /*

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

    90  */

    91 typedef struct

    92 {

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

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

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

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

    97     PHYSFS_uint8 *buffer;                 /* decompression buffer.      */

    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 

   119 /*

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

   121  */

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

   123 {

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

   125 } /* zlibPhysfsAlloc */

   126 

   127 /*

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

   129  */

   130 static void zlibPhysfsFree(voidpf opaque, voidpf address)

   131 {

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

   133 } /* zlibPhysfsFree */

   134 

   135 

   136 /*

   137  * Construct a new z_stream to a sane state.

   138  */

   139 static void initializeZStream(z_stream *pstr)

   140 {

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

   142     pstr->zalloc = zlibPhysfsAlloc;

   143     pstr->zfree = zlibPhysfsFree;

   144     pstr->opaque = &allocator;

   145 } /* initializeZStream */

   146 

   147 

   148 static PHYSFS_ErrorCode zlib_error_code(int rc)

   149 {

   150     switch (rc)

   151     {

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

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

   154         case Z_ERRNO: return PHYSFS_ERR_IO;

   155         case Z_MEM_ERROR: return PHYSFS_ERR_OUT_OF_MEMORY;

   156         default: return PHYSFS_ERR_CORRUPT;

   157     } /* switch */

   158 } /* zlib_error_string */

   159 

   160 

   161 /*

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

   163  */

   164 static int zlib_err(const int rc)

   165 {

   166     __PHYSFS_setError(zlib_error_code(rc));

   167     return rc;

   168 } /* zlib_err */

   169 

   170 

   171 /*

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

   173  */

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

   175 {

   176     PHYSFS_uint64 v;

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

   178     *val = PHYSFS_swapULE64(v);

   179     return 1;

   180 } /* readui64 */

   181 

   182 /*

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

   184  */

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

   186 {

   187     PHYSFS_uint32 v;

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

   189     *val = PHYSFS_swapULE32(v);

   190     return 1;

   191 } /* readui32 */

   192 

   193 

   194 /*

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

   196  */

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

   198 {

   199     PHYSFS_uint16 v;

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

   201     *val = PHYSFS_swapULE16(v);

   202     return 1;

   203 } /* readui16 */

   204 

   205 

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

   207 {

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

   209     PHYSFS_Io *io = finfo->io;

   210     ZIPentry *entry = finfo->entry;

   211     PHYSFS_sint64 retval = 0;

   212     PHYSFS_sint64 maxread = (PHYSFS_sint64) len;

   213     PHYSFS_sint64 avail = entry->uncompressed_size -

   214                           finfo->uncompressed_position;

   215 

   216     if (avail < maxread)

   217         maxread = avail;

   218 

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

   220 

   221     if (entry->compression_method == COMPMETH_NONE)

   222         retval = io->read(io, buf, maxread);

   223     else

   224     {

   225         finfo->stream.next_out = buf;

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

   227 

   228         while (retval < maxread)

   229         {

   230             PHYSFS_uint32 before = finfo->stream.total_out;

   231             int rc;

   232 

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

   234             {

   235                 PHYSFS_sint64 br;

   236 

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

   238                 if (br > 0)

   239                 {

   240                     if (br > ZIP_READBUFSIZE)

   241                         br = ZIP_READBUFSIZE;

   242 

   243                     br = io->read(io, finfo->buffer, (PHYSFS_uint64) br);

   244                     if (br <= 0)

   245                         break;

   246 

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

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

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

   250                 } /* if */

   251             } /* if */

   252 

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

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

   255 

   256             if (rc != Z_OK)

   257                 break;

   258         } /* while */

   259     } /* else */

   260 

   261     if (retval > 0)

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

   263 

   264     return retval;

   265 } /* ZIP_read */

   266 

   267 

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

   269 {

   270     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);

   271 } /* ZIP_write */

   272 

   273 

   274 static PHYSFS_sint64 ZIP_tell(PHYSFS_Io *io)

   275 {

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

   277 } /* ZIP_tell */

   278 

   279 

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

   281 {

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

   283     ZIPentry *entry = finfo->entry;

   284     PHYSFS_Io *io = finfo->io;

   285 

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

   287 

   288     if (entry->compression_method == COMPMETH_NONE)

   289     {

   290         const PHYSFS_sint64 newpos = offset + entry->offset;

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

   292         finfo->uncompressed_position = (PHYSFS_uint32) offset;

   293     } /* if */

   294 

   295     else

   296     {

   297         /*

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

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

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

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

   302          */

   303         if (offset < finfo->uncompressed_position)

   304         {

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

   306             z_stream str;

   307             initializeZStream(&str);

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

   309                 return 0;

   310 

   311             if (!io->seek(io, entry->offset))

   312                 return 0;

   313 

   314             inflateEnd(&finfo->stream);

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

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

   317         } /* if */

   318 

   319         while (finfo->uncompressed_position != offset)

   320         {

   321             PHYSFS_uint8 buf[512];

   322             PHYSFS_uint32 maxread;

   323 

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

   325             if (maxread > sizeof (buf))

   326                 maxread = sizeof (buf);

   327 

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

   329                 return 0;

   330         } /* while */

   331     } /* else */

   332 

   333     return 1;

   334 } /* ZIP_seek */

   335 

   336 

   337 static PHYSFS_sint64 ZIP_length(PHYSFS_Io *io)

   338 {

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

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

   341 } /* ZIP_length */

   342 

   343 

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

   345 

   346 static PHYSFS_Io *ZIP_duplicate(PHYSFS_Io *io)

   347 {

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

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

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

   351     GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);

   352     GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);

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

   354 

   355     finfo->entry = origfinfo->entry;

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

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

   358 

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

   360     {

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

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

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

   364             goto failed;

   365     } /* if */

   366 

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

   368     retval->opaque = finfo;

   369     return retval;

   370 

   371 failed:

   372     if (finfo != NULL)

   373     {

   374         if (finfo->io != NULL)

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

   376 

   377         if (finfo->buffer != NULL)

   378         {

   379             allocator.Free(finfo->buffer);

   380             inflateEnd(&finfo->stream);

   381         } /* if */

   382 

   383         allocator.Free(finfo);

   384     } /* if */

   385 

   386     if (retval != NULL)

   387         allocator.Free(retval);

   388 

   389     return NULL;

   390 } /* ZIP_duplicate */

   391 

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

   393 

   394 static void ZIP_destroy(PHYSFS_Io *io)

   395 {

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

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

   398 

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

   400         inflateEnd(&finfo->stream);

   401 

   402     if (finfo->buffer != NULL)

   403         allocator.Free(finfo->buffer);

   404 

   405     allocator.Free(finfo);

   406     allocator.Free(io);

   407 } /* ZIP_destroy */

   408 

   409 

   410 static const PHYSFS_Io ZIP_Io =

   411 {

   412     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   413     ZIP_read,

   414     ZIP_write,

   415     ZIP_seek,

   416     ZIP_tell,

   417     ZIP_length,

   418     ZIP_duplicate,

   419     ZIP_flush,

   420     ZIP_destroy

   421 };

   422 

   423 

   424 

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

   426 {

   427     PHYSFS_uint8 buf[256];

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

   429     PHYSFS_sint32 i = 0;

   430     PHYSFS_sint64 filelen;

   431     PHYSFS_sint64 filepos;

   432     PHYSFS_sint32 maxread;

   433     PHYSFS_sint32 totalread = 0;

   434     int found = 0;

   435 

   436     filelen = io->length(io);

   437     BAIL_IF_MACRO(filelen == -1, ERRPASS, 0);

   438 

   439     /*

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

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

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

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

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

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

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

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

   448      *  and call it a corrupted zipfile.

   449      */

   450 

   451     if (sizeof (buf) < filelen)

   452     {

   453         filepos = filelen - sizeof (buf);

   454         maxread = sizeof (buf);

   455     } /* if */

   456     else

   457     {

   458         filepos = 0;

   459         maxread = (PHYSFS_uint32) filelen;

   460     } /* else */

   461 

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

   463     {

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

   465 

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

   467         if (totalread != 0)

   468         {

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

   470                 return -1;

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

   472             totalread += maxread - 4;

   473         } /* if */

   474         else

   475         {

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

   477                 return -1;

   478             totalread += maxread;

   479         } /* else */

   480 

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

   482 

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

   484         {

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

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

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

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

   489             {

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

   491                 break;  

   492             } /* if */

   493         } /* for */

   494 

   495         if (found)

   496             break;

   497 

   498         filepos -= (maxread - 4);

   499         if (filepos < 0)

   500             filepos = 0;

   501     } /* while */

   502 

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

   504 

   505     if (len != NULL)

   506         *len = filelen;

   507 

   508     return (filepos + i);

   509 } /* zip_find_end_of_central_dir */

   510 

   511 

   512 static int isZip(PHYSFS_Io *io)

   513 {

   514     PHYSFS_uint32 sig = 0;

   515     int retval = 0;

   516 

   517     /*

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

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

   520      */

   521     if (readui32(io, &sig))

   522     {

   523         retval = (sig == ZIP_LOCAL_FILE_SIG);

   524         if (!retval)

   525         {

   526             /*

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

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

   529              *  it the hard way...

   530              */

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

   532         } /* if */

   533     } /* if */

   534 

   535     return retval;

   536 } /* isZip */

   537 

   538 

   539 static void zip_free_entries(ZIPentry *entries, PHYSFS_uint64 max)

   540 {

   541     PHYSFS_uint64 i;

   542     for (i = 0; i < max; i++)

   543     {

   544         ZIPentry *entry = &entries[i];

   545         if (entry->name != NULL)

   546             allocator.Free(entry->name);

   547     } /* for */

   548 

   549     allocator.Free(entries);

   550 } /* zip_free_entries */

   551 

   552 

   553 /*

   554  * This will find the ZIPentry associated with a path in platform-independent

   555  *  notation. Directories don't have ZIPentries associated with them, but 

   556  *  (*isDir) will be set to non-zero if a dir was hit.

   557  */

   558 static ZIPentry *zip_find_entry(const ZIPinfo *info, const char *path,

   559                                 int *isDir)

   560 {

   561     ZIPentry *a = info->entries;

   562     PHYSFS_sint32 pathlen = (PHYSFS_sint32) strlen(path);

   563     PHYSFS_sint64 lo = 0;

   564     PHYSFS_sint64 hi = (PHYSFS_sint64) (info->entryCount - 1);

   565     PHYSFS_sint64 middle;

   566     const char *thispath = NULL;

   567     int rc;

   568 

   569     while (lo <= hi)

   570     {

   571         middle = lo + ((hi - lo) / 2);

   572         thispath = a[middle].name;

   573         rc = strncmp(path, thispath, pathlen);

   574 

   575         if (rc > 0)

   576             lo = middle + 1;

   577 

   578         else if (rc < 0)

   579             hi = middle - 1;

   580 

   581         else /* substring match...might be dir or entry or nothing. */

   582         {

   583             if (isDir != NULL)

   584             {

   585                 *isDir = (thispath[pathlen] == '/');

   586                 if (*isDir)

   587                     return NULL;

   588             } /* if */

   589 

   590             if (thispath[pathlen] == '\0') /* found entry? */

   591                 return &a[middle];

   592             /* adjust search params, try again. */

   593             else if (thispath[pathlen] > '/')

   594                 hi = middle - 1;

   595             else

   596                 lo = middle + 1;

   597         } /* if */

   598     } /* while */

   599 

   600     if (isDir != NULL)

   601         *isDir = 0;

   602 

   603     BAIL_MACRO(PHYSFS_ERR_NO_SUCH_PATH, NULL);

   604 } /* zip_find_entry */

   605 

   606 

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

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

   609 {

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

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

   612     {

   613         while (*path)

   614         {

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

   616                 *path = '/';

   617             path++;

   618         } /* while */

   619     } /* if */

   620 } /* zip_convert_dos_path */

   621 

   622 

   623 static void zip_expand_symlink_path(char *path)

   624 {

   625     char *ptr = path;

   626     char *prevptr = path;

   627 

   628     while (1)

   629     {

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

   631         if (ptr == NULL)

   632             break;

   633 

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

   635         {

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

   637             {

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

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

   640             } /* else if */

   641 

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

   643             {

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

   645                 *ptr = '\0';

   646             } /* else if */

   647 

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

   649             {

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

   651                 {

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

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

   654                     ptr = prevptr;

   655                     while (prevptr != path)

   656                     {

   657                         prevptr--;

   658                         if (*prevptr == '/')

   659                         {

   660                             prevptr++;

   661                             break;

   662                         } /* if */

   663                     } /* while */

   664                 } /* if */

   665 

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

   667                 {

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

   669                     *prevptr = '\0';

   670                 } /* if */

   671             } /* if */

   672         } /* if */

   673         else

   674         {

   675             prevptr = ptr;

   676             ptr++;

   677         } /* else */

   678     } /* while */

   679 } /* zip_expand_symlink_path */

   680 

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

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

   683 

   684 /*

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

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

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

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

   689  */

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

   691 {

   692     ZIPentry *entry;

   693 

   694     zip_expand_symlink_path(path);

   695     entry = zip_find_entry(info, path, NULL);

   696     if (entry != NULL)

   697     {

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

   699             entry = NULL;

   700         else

   701         {

   702             if (entry->symlink != NULL)

   703                 entry = entry->symlink;

   704         } /* else */

   705     } /* if */

   706 

   707     return entry;

   708 } /* zip_follow_symlink */

   709 

   710 

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

   712 {

   713     const PHYSFS_uint64 size = entry->uncompressed_size;

   714     char *path = NULL;

   715     int rc = 0;

   716 

   717     /*

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

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

   720      *  follow it.

   721      */

   722 

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

   724 

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

   726     BAIL_IF_MACRO(!path, PHYSFS_ERR_OUT_OF_MEMORY, 0);

   727     

   728     if (entry->compression_method == COMPMETH_NONE)

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

   730 

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

   732     {

   733         z_stream stream;

   734         const PHYSFS_uint64 complen = entry->compressed_size;

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

   736         if (compressed != NULL)

   737         {

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

   739             {

   740                 initializeZStream(&stream);

   741                 stream.next_in = compressed;

   742                 stream.avail_in = complen;

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

   744                 stream.avail_out = size;

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

   746                 {

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

   748                     inflateEnd(&stream);

   749 

   750                     /* both are acceptable outcomes... */

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

   752                 } /* if */

   753             } /* if */

   754             __PHYSFS_smallFree(compressed);

   755         } /* if */

   756     } /* else */

   757 

   758     if (rc)

   759     {

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

   761         zip_convert_dos_path(entry, path);

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

   763     } /* else */

   764 

   765     __PHYSFS_smallFree(path);

   766 

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

   768 } /* zip_resolve_symlink */

   769 

   770 

   771 /*

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

   773  */

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

   775 {

   776     PHYSFS_uint32 ui32;

   777     PHYSFS_uint16 ui16;

   778     PHYSFS_uint16 fnamelen;

   779     PHYSFS_uint16 extralen;

   780 

   781     /*

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

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

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

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

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

   787      *  possible that's a Zip64 thing.

   788      */

   789 

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

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

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

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

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

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

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

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

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

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

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

   801 

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

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

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

   805 

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

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

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

   809 

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

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

   812 

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

   814     return 1;

   815 } /* zip_parse_local */

   816 

   817 

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

   819 {

   820     int retval = 1;

   821     ZipResolveType resolve_type = entry->resolved;

   822 

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

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

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

   826 

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

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

   829 

   830     /*

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

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

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

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

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

   836      */

   837     if (resolve_type != ZIP_RESOLVED)

   838     {

   839         entry->resolved = ZIP_RESOLVING;

   840 

   841         retval = zip_parse_local(io, entry);

   842         if (retval)

   843         {

   844             /*

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

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

   847              *  the real file) if all goes well.

   848              */

   849             if (resolve_type == ZIP_UNRESOLVED_SYMLINK)

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

   851         } /* if */

   852 

   853         if (resolve_type == ZIP_UNRESOLVED_SYMLINK)

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

   855         else if (resolve_type == ZIP_UNRESOLVED_FILE)

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

   857     } /* if */

   858 

   859     return retval;

   860 } /* zip_resolve */

   861 

   862 

   863 static int zip_version_does_symlinks(PHYSFS_uint32 version)

   864 {

   865     int retval = 0;

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

   867 

   868     switch (hosttype)

   869     {

   870             /*

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

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

   873              */

   874         case 0:  /* FS_FAT_  */

   875         case 1:  /* AMIGA_   */

   876         case 2:  /* VMS_     */

   877         case 4:  /* VM_CSM_  */

   878         case 6:  /* FS_HPFS_ */

   879         case 11: /* FS_NTFS_ */

   880         case 14: /* FS_VFAT_ */

   881         case 13: /* ACORN_   */

   882         case 15: /* MVS_     */

   883         case 18: /* THEOS_   */

   884             break;  /* do nothing. */

   885 

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

   887             retval = 1;

   888             break;

   889     } /* switch */

   890 

   891     return retval;

   892 } /* zip_version_does_symlinks */

   893 

   894 

   895 static int zip_entry_is_symlink(const ZIPentry *entry)

   896 {

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

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

   899             (entry->symlink));

   900 } /* zip_entry_is_symlink */

   901 

   902 

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

   904 {

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

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

   907              (entry->uncompressed_size > 0) &&

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

   909 } /* zip_has_symlink_attr */

   910 

   911 

   912 static PHYSFS_sint64 zip_dos_time_to_physfs_time(PHYSFS_uint32 dostime)

   913 {

   914     PHYSFS_uint32 dosdate;

   915     struct tm unixtime;

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

   917 

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

   919     dostime &= 0xFFFF;

   920 

   921     /* dissect date */

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

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

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

   925 

   926     /* dissect time */

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

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

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

   930 

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

   932     unixtime.tm_isdst = -1;

   933 

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

   935 } /* zip_dos_time_to_physfs_time */

   936 

   937 

   938 static int zip_load_entry(PHYSFS_Io *io, const int zip64, ZIPentry *entry,

   939                           PHYSFS_uint64 ofs_fixup)

   940 {

   941     PHYSFS_uint16 fnamelen, extralen, commentlen;

   942     PHYSFS_uint32 external_attr;

   943     PHYSFS_uint32 starting_disk;

   944     PHYSFS_uint64 offset;

   945     PHYSFS_uint16 ui16;

   946     PHYSFS_uint32 ui32;

   947     PHYSFS_sint64 si64;

   948 

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

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

   951     BAIL_IF_MACRO(ui32 != ZIP_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);

   952 

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

   954     BAIL_IF_MACRO(!readui16(io, &entry->version), ERRPASS, 0);

   955     BAIL_IF_MACRO(!readui16(io, &entry->version_needed), ERRPASS, 0);

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

   957     BAIL_IF_MACRO(!readui16(io, &entry->compression_method), ERRPASS, 0);

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

   959     entry->last_mod_time = zip_dos_time_to_physfs_time(ui32);

   960     BAIL_IF_MACRO(!readui32(io, &entry->crc), ERRPASS, 0);

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

   962     entry->compressed_size = (PHYSFS_uint64) ui32;

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

   964     entry->uncompressed_size = (PHYSFS_uint64) ui32;

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

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

   967     BAIL_IF_MACRO(!readui16(io, &commentlen), ERRPASS, 0);

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

   969     starting_disk = (PHYSFS_uint32) ui16;

   970     BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);  /* internal file attribs */

   971     BAIL_IF_MACRO(!readui32(io, &external_attr), ERRPASS, 0);

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

   973     offset = (PHYSFS_uint64) ui32;

   974 

   975     entry->symlink = NULL;  /* will be resolved later, if necessary. */

   976     entry->resolved = (zip_has_symlink_attr(entry, external_attr)) ?

   977                             ZIP_UNRESOLVED_SYMLINK : ZIP_UNRESOLVED_FILE;

   978 

   979     entry->name = (char *) allocator.Malloc(fnamelen + 1);

   980     BAIL_IF_MACRO(entry->name == NULL, PHYSFS_ERR_OUT_OF_MEMORY, 0);

   981     if (!__PHYSFS_readAll(io, entry->name, fnamelen))

   982         goto zip_load_entry_puked;

   983 

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

   985     zip_convert_dos_path(entry, entry->name);

   986 

   987     si64 = io->tell(io);

   988     if (si64 == -1)

   989         goto zip_load_entry_puked;

   990 

   991     /*

   992      * The actual sizes didn't fit in 32-bits; look for the Zip64

   993      *  extended information extra field...

   994      */

   995     if ( (zip64) &&

   996          ((offset == 0xFFFFFFFF) ||

   997           (starting_disk == 0xFFFFFFFF) ||

   998           (entry->compressed_size == 0xFFFFFFFF) ||

   999           (entry->uncompressed_size == 0xFFFFFFFF)) )

  1000     {

  1001         int found = 0;

  1002         PHYSFS_uint16 sig, len;

  1003         while (extralen > 4)

  1004         {

  1005             if (!readui16(io, &sig))

  1006                 goto zip_load_entry_puked;

  1007             else if (!readui16(io, &len))

  1008                 goto zip_load_entry_puked;

  1009 

  1010             si64 += 4 + len;

  1011             extralen -= 4 + len;

  1012             if (sig != ZIP64_EXTENDED_INFO_EXTRA_FIELD_SIG)

  1013             {

  1014                 if (!io->seek(io, si64))

  1015                     goto zip_load_entry_puked;

  1016                 continue;

  1017             } /* if */

  1018 

  1019             found = 1;

  1020             break;

  1021         } /* while */

  1022 

  1023         GOTO_IF_MACRO(!found, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1024 

  1025         if (entry->uncompressed_size == 0xFFFFFFFF)

  1026         {

  1027             GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1028             if (!readui64(io, &entry->uncompressed_size))

  1029                 goto zip_load_entry_puked;

  1030             len -= 8;

  1031         } /* if */

  1032 

  1033         if (entry->compressed_size == 0xFFFFFFFF)

  1034         {

  1035             GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1036             if (!readui64(io, &entry->compressed_size))

  1037                 goto zip_load_entry_puked;

  1038             len -= 8;

  1039         } /* if */

  1040 

  1041         if (offset == 0xFFFFFFFF)

  1042         {

  1043             GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1044             if (!readui64(io, &offset))

  1045                 goto zip_load_entry_puked;

  1046             len -= 8;

  1047         } /* if */

  1048 

  1049         if (starting_disk == 0xFFFFFFFF)

  1050         {

  1051             GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1052             if (!readui32(io, &starting_disk))

  1053                 goto zip_load_entry_puked;

  1054             len -= 4;

  1055         } /* if */

  1056 

  1057         GOTO_IF_MACRO(len != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1058     } /* if */

  1059 

  1060     GOTO_IF_MACRO(starting_disk != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);

  1061 

  1062     entry->offset = offset + ofs_fixup;

  1063 

  1064     /* seek to the start of the next entry in the central directory... */

  1065     if (!io->seek(io, si64 + extralen + commentlen))

  1066         goto zip_load_entry_puked;

  1067 

  1068     return 1;  /* success. */

  1069 

  1070 zip_load_entry_puked:

  1071     allocator.Free(entry->name);

  1072     return 0;  /* failure. */

  1073 } /* zip_load_entry */

  1074 

  1075 

  1076 static int zip_entry_cmp(void *_a, size_t one, size_t two)

  1077 {

  1078     if (one != two)

  1079     {

  1080         const ZIPentry *a = (const ZIPentry *) _a;

  1081         return strcmp(a[one].name, a[two].name);

  1082     } /* if */

  1083 

  1084     return 0;

  1085 } /* zip_entry_cmp */

  1086 

  1087 

  1088 static void zip_entry_swap(void *_a, size_t one, size_t two)

  1089 {

  1090     if (one != two)

  1091     {

  1092         ZIPentry tmp;

  1093         ZIPentry *first = &(((ZIPentry *) _a)[one]);

  1094         ZIPentry *second = &(((ZIPentry *) _a)[two]);

  1095         memcpy(&tmp, first, sizeof (ZIPentry));

  1096         memcpy(first, second, sizeof (ZIPentry));

  1097         memcpy(second, &tmp, sizeof (ZIPentry));

  1098     } /* if */

  1099 } /* zip_entry_swap */

  1100 

  1101 

  1102 static int zip_load_entries(PHYSFS_Io *io, ZIPinfo *info,

  1103                             const PHYSFS_uint64 data_ofs,

  1104                             const PHYSFS_uint64 central_ofs)

  1105 {

  1106     const PHYSFS_uint64 max = info->entryCount;

  1107     const int zip64 = info->zip64;

  1108     PHYSFS_uint64 i;

  1109 

  1110     BAIL_IF_MACRO(!io->seek(io, central_ofs), ERRPASS, 0);

  1111 

  1112     info->entries = (ZIPentry *) allocator.Malloc(sizeof (ZIPentry) * max);

  1113     BAIL_IF_MACRO(!info->entries, PHYSFS_ERR_OUT_OF_MEMORY, 0);

  1114 

  1115     for (i = 0; i < max; i++)

  1116     {

  1117         if (!zip_load_entry(io, zip64, &info->entries[i], data_ofs))

  1118         {

  1119             zip_free_entries(info->entries, i);

  1120             return 0;

  1121         } /* if */

  1122     } /* for */

  1123 

  1124     __PHYSFS_sort(info->entries, (size_t) max, zip_entry_cmp, zip_entry_swap);

  1125     return 1;

  1126 } /* zip_load_entries */

  1127 

  1128 

  1129 static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,

  1130                                                    PHYSFS_sint64 _pos,

  1131                                                    PHYSFS_uint64 offset)

  1132 {

  1133     /*

  1134      * Naturally, the offset is useless to us; it is the offset from the