/*

 * ZIP support routines for PhysicsFS.

 *

 * Please see the file LICENSE.txt in the source's root directory.

 *

 *  This file written by Ryan C. Gordon, with some peeking at "unzip.c"

 *   by Gilles Vollant.

 */

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

#if PHYSFS_SUPPORTS_ZIP

#include <errno.h>

#include <time.h>

#define USE_MINIZ 1

#if USE_MINIZ

#include "physfs_miniz.h"

#else

#include <zlib.h>

#endif

/*

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

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

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

 *  PHYSFS_read().

 *

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

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

 *

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

 *  value.

 */

#define ZIP_READBUFSIZE   (16 * 1024)

/*

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

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

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

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

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

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

 */

typedef enum

{

    ZIP_UNRESOLVED_FILE,

    ZIP_UNRESOLVED_SYMLINK,

    ZIP_RESOLVING,

    ZIP_RESOLVED,

    ZIP_BROKEN_FILE,

    ZIP_BROKEN_SYMLINK

} ZipResolveType;

/*

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

 */

typedef struct _ZIPentry

{

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

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

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

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

    PHYSFS_uint16 version;              /* version made by                */

    PHYSFS_uint16 version_needed;       /* version needed to extract      */

    PHYSFS_uint16 compression_method;   /* compression method             */

    PHYSFS_uint32 crc;                  /* crc-32                         */

    PHYSFS_uint64 compressed_size;      /* compressed size                */

    PHYSFS_uint64 uncompressed_size;    /* uncompressed size              */

    PHYSFS_sint64 last_mod_time;        /* last file mod time             */

} ZIPentry;

/*

 * One ZIPinfo is kept for each open ZIP archive.

 */

typedef struct

{

    PHYSFS_Io *io;

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

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

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

} ZIPinfo;

/*

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

 */

typedef struct

{

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

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

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

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

    PHYSFS_uint8 *buffer;                 /* decompression buffer.      */

    z_stream stream;                      /* zlib stream state.         */

} ZIPfileinfo;

/* Magic numbers... */

#define ZIP_LOCAL_FILE_SIG                          0x04034b50

#define ZIP_CENTRAL_DIR_SIG                         0x02014b50

#define ZIP_END_OF_CENTRAL_DIR_SIG                  0x06054b50

#define ZIP64_END_OF_CENTRAL_DIR_SIG                0x06064b50

#define ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG  0x07064b50

#define ZIP64_EXTENDED_INFO_EXTRA_FIELD_SIG         0x0001

/* compression methods... */

#define COMPMETH_NONE 0

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

#define UNIX_FILETYPE_MASK    0170000

#define UNIX_FILETYPE_SYMLINK 0120000

/*

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

 */

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

{

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

} /* zlibPhysfsAlloc */

/*

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

 */

static void zlibPhysfsFree(voidpf opaque, voidpf address)

{

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

} /* zlibPhysfsFree */

/*

 * Construct a new z_stream to a sane state.

 */

static void initializeZStream(z_stream *pstr)

{

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

    pstr->zalloc = zlibPhysfsAlloc;

    pstr->zfree = zlibPhysfsFree;

    pstr->opaque = &allocator;

} /* initializeZStream */

static PHYSFS_ErrorCode zlib_error_code(int rc)

{

    switch (rc)

    {

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

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

        case Z_ERRNO: return PHYSFS_ERR_IO;

        case Z_MEM_ERROR: return PHYSFS_ERR_OUT_OF_MEMORY;

        default: return PHYSFS_ERR_CORRUPT;

    } /* switch */

} /* zlib_error_string */

/*

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

 */

static int zlib_err(const int rc)

{

    __PHYSFS_setError(zlib_error_code(rc));

    return rc;

} /* zlib_err */

/*

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

 */

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

{

    PHYSFS_uint64 v;

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

    *val = PHYSFS_swapULE64(v);

    return 1;

} /* readui64 */

/*

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

 */

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

{

    PHYSFS_uint32 v;

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

    *val = PHYSFS_swapULE32(v);

    return 1;

} /* readui32 */

/*

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

 */

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

{

    PHYSFS_uint16 v;

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

    *val = PHYSFS_swapULE16(v);

    return 1;

} /* readui16 */

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

{

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

    PHYSFS_Io *io = finfo->io;

    ZIPentry *entry = finfo->entry;

    PHYSFS_sint64 retval = 0;

    PHYSFS_sint64 maxread = (PHYSFS_sint64) len;

    PHYSFS_sint64 avail = entry->uncompressed_size -

                          finfo->uncompressed_position;

    if (avail < maxread)

        maxread = avail;

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

    if (entry->compression_method == COMPMETH_NONE)

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

    else

    {

        finfo->stream.next_out = buf;

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

        while (retval < maxread)

        {

            PHYSFS_uint32 before = finfo->stream.total_out;

            int rc;

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

            {

                PHYSFS_sint64 br;

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

                if (br > 0)

                {

                    if (br > ZIP_READBUFSIZE)

                        br = ZIP_READBUFSIZE;

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

                    if (br <= 0)

                        break;

                    finfo->compressed_position += (PHYSFS_uint32) br;

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

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

                } /* if */

            } /* if */

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

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

            if (rc != Z_OK)

                break;

        } /* while */

    } /* else */

    if (retval > 0)

        finfo->uncompressed_position += (PHYSFS_uint32) retval;

    return retval;

} /* ZIP_read */

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

{

    BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);

} /* ZIP_write */

static PHYSFS_sint64 ZIP_tell(PHYSFS_Io *io)

{

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

} /* ZIP_tell */

static int ZIP_seek(PHYSFS_Io *_io, PHYSFS_uint64 offset)

{

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

    ZIPentry *entry = finfo->entry;

    PHYSFS_Io *io = finfo->io;

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

    if (entry->compression_method == COMPMETH_NONE)

    {

        const PHYSFS_sint64 newpos = offset + entry->offset;

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

        finfo->uncompressed_position = (PHYSFS_uint32) offset;

    } /* if */

    else

    {

        /*

         * If seeking backwards, we need to redecode the file

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

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

         *  decode, but we don't rewind first.

         */

        if (offset < finfo->uncompressed_position)

        {

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

            z_stream str;

            initializeZStream(&str);

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

                return 0;

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

                return 0;

            inflateEnd(&finfo->stream);

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

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

        } /* if */

        while (finfo->uncompressed_position != offset)

        {

            PHYSFS_uint8 buf[512];

            PHYSFS_uint32 maxread;

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

            if (maxread > sizeof (buf))

                maxread = sizeof (buf);

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

                return 0;

        } /* while */

    } /* else */

    return 1;

} /* ZIP_seek */

static PHYSFS_sint64 ZIP_length(PHYSFS_Io *io)

{

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

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

} /* ZIP_length */

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

static PHYSFS_Io *ZIP_duplicate(PHYSFS_Io *io)

{

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

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

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

    GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);

    GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);

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

    finfo->entry = origfinfo->entry;

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

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

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

    {

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

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

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

            goto failed;

    } /* if */

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

    retval->opaque = finfo;

    return retval;

failed:

    if (finfo != NULL)

    {

        if (finfo->io != NULL)

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

        if (finfo->buffer != NULL)

        {

            allocator.Free(finfo->buffer);

            inflateEnd(&finfo->stream);

        } /* if */

        allocator.Free(finfo);

    } /* if */

    if (retval != NULL)

        allocator.Free(retval);

    return NULL;

} /* ZIP_duplicate */

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

static void ZIP_destroy(PHYSFS_Io *io)

{

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

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

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

        inflateEnd(&finfo->stream);

    if (finfo->buffer != NULL)

        allocator.Free(finfo->buffer);

    allocator.Free(finfo);

    allocator.Free(io);

} /* ZIP_destroy */

static const PHYSFS_Io ZIP_Io =

{

    CURRENT_PHYSFS_IO_API_VERSION, NULL,

    ZIP_read,

    ZIP_write,

    ZIP_seek,

    ZIP_tell,

    ZIP_length,

    ZIP_duplicate,

    ZIP_flush,

    ZIP_destroy

};

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

{

    PHYSFS_uint8 buf[256];

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

    PHYSFS_sint32 i = 0;

    PHYSFS_sint64 filelen;

    PHYSFS_sint64 filepos;

    PHYSFS_sint32 maxread;

    PHYSFS_sint32 totalread = 0;

    int found = 0;

    filelen = io->length(io);

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

    /*

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

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

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

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

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

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

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

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

     *  and call it a corrupted zipfile.

     */

    if (sizeof (buf) < filelen)

    {

        filepos = filelen - sizeof (buf);

        maxread = sizeof (buf);

    } /* if */

    else

    {

        filepos = 0;

        maxread = (PHYSFS_uint32) filelen;

    } /* else */

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

    {

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

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

        if (totalread != 0)

        {

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

                return -1;

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

            totalread += maxread - 4;

        } /* if */

        else

        {

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

                return -1;

            totalread += maxread;

        } /* else */

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

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

        {

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

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

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

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

            {

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

                break;

            } /* if */

        } /* for */

        if (found)

            break;

        filepos -= (maxread - 4);

        if (filepos < 0)

            filepos = 0;

    } /* while */

    BAIL_IF_MACRO(!found, PHYSFS_ERR_UNSUPPORTED, -1);

    if (len != NULL)

        *len = filelen;

    return (filepos + i);

} /* zip_find_end_of_central_dir */

static int isZip(PHYSFS_Io *io)

{

    PHYSFS_uint32 sig = 0;

    int retval = 0;

    /*

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

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

     */

    if (readui32(io, &sig))

    {

        retval = (sig == ZIP_LOCAL_FILE_SIG);

        if (!retval)

        {

            /*

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

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