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

 *   by Gilles Vollant.

#include <errno.h>

#include "zlib.h"

/*

 * A buffer of ZIP_READBUFSIZE is malloc() for each compressed file opened,

 *  and is free()'d 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)

/*

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

 */

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

    char *symlink;                      /* NULL or file we link to   */

    int fixed_up;                       /* Have we updated offset?   */

    PHYSFS_uint32 offset;               /* offset of data in file    */

    PHYSFS_uint16 version;              /* version made by           */

    PHYSFS_uint16 version_needed;       /* version needed to extract */

    PHYSFS_uint16 flag;                 /* general purpose bit flag  */

    PHYSFS_uint16 compression_method;   /* compression method        */

    PHYSFS_uint32 crc;                  /* crc-32                    */

    PHYSFS_uint32 compressed_size;      /* compressed size           */

    PHYSFS_uint32 uncompressed_size;    /* uncompressed size         */

    PHYSFS_sint64 last_mod_time;        /* last file mod time        */

/*

 * One ZIPinfo is kept for each open ZIP archive.

 */

typedef struct

{

    char *archiveName;        /* path to ZIP in platform-dependent notation. */

    PHYSFS_uint16 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.

 */

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

    void *handle;                         /* 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

/* compression methods... */

#define COMPMETH_NONE 0

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

#define MAXZIPENTRYSIZE 256  /* !!! FIXME: get rid of this. */

static char *get_zip_realpath(void *in, ZIPentry *entry);

/*

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

 */

static int zlib_err(int rc)

{

    const char *err = NULL;

    switch (rc)

    {

        case Z_OK:

        case Z_STREAM_END:

            break;   /* not errors. */

        case Z_ERRNO:

            err = strerror(errno);

            break;

        case Z_NEED_DICT:

            err = "zlib: need dictionary";

            break;

        case Z_DATA_ERROR:

            err = "zlib: need dictionary";

            break;

        case Z_MEM_ERROR:

            err = "zlib: memory error";

            break;

        case Z_BUF_ERROR:

            err = "zlib: buffer error";

            break;

        case Z_VERSION_ERROR:

            err = "zlib: version error";

            break;

        default:

            err = "unknown zlib error";

            break;

    } /* switch */

    if (err != NULL)

        __PHYSFS_setError(err);

    return(rc);

} /* zlib_err */

/*

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

 */

static int readui32(void *in, PHYSFS_uint32 *val)

{

    PHYSFS_uint32 v;

    BAIL_IF_MACRO(__PHYSFS_platformRead(in, &v, sizeof (v), 1) != 1, NULL, 0);

    *val = PHYSFS_swapULE32(v);

    return(1);

} /* readui32 */

/*

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

 */

static int readui16(void *in, PHYSFS_uint16 *val)

{

    PHYSFS_uint16 v;

    BAIL_IF_MACRO(__PHYSFS_platformRead(in, &v, sizeof (v), 1) != 1, NULL, 0);

    *val = PHYSFS_swapULE16(v);

    return(1);

} /* readui16 */

static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buf,

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

    ZIPentry *entry = finfo->entry;

    PHYSFS_sint64 retval = 0;

    PHYSFS_sint64 maxread = ((PHYSFS_sint64) objSize) * objCount;

    PHYSFS_sint64 avail = entry->uncompressed_size -

                          finfo->uncompressed_position;

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

    if (avail < maxread)

    {

        maxread = avail - (avail % objSize);

        objCount = maxread / objSize;

        BAIL_IF_MACRO(objCount == 0, ERR_PAST_EOF, 0);  /* quick rejection. */

        __PHYSFS_setError(ERR_PAST_EOF);   /* this is always true here. */

    } /* if */

    if (entry->compression_method == COMPMETH_NONE)

    {

        retval = __PHYSFS_platformRead(finfo->handle, buf, objSize, objCount);

    } /* if */

    else

    {

        finfo->stream.next_out = buf;

        finfo->stream.avail_out = objSize * objCount;

        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 = __PHYSFS_platformRead(finfo->handle,

                                               finfo->buffer,

                                               1, br);

                    if (br <= 0)

                        break;

                    finfo->compressed_position += br;

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

                    finfo->stream.avail_in = br;

                } /* if */

            } /* if */

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

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

            if (rc != Z_OK)

                break;

        } /* while */

        retval /= objSize;

    } /* else */

    if (retval > 0)

        finfo->uncompressed_position += (retval * objSize);

    return(retval);

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

    return(finfo->uncompressed_position >= finfo->entry->uncompressed_size);

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

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

    ZIPentry *entry = finfo->entry;

    void *in = finfo->handle;

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

    if (entry->compression_method == COMPMETH_NONE)

    {

        PHYSFS_sint64 newpos = offset + entry->offset;

        BAIL_IF_MACRO(!__PHYSFS_platformSeek(in, newpos), NULL, 0);

        finfo->uncompressed_position = newpos;

    } /* 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

         *  redecode, 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;

            memset(&str, '\0', sizeof (z_stream));

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

                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 = offset - finfo->uncompressed_position;

            if (maxread > sizeof (buf))

                maxread = sizeof (buf);

            if (ZIP_read(handle, buf, maxread, 1) != 1)

                return(0);

        } /* while */

    } /* else */

    return(1);

    return(finfo->entry->uncompressed_size);

    __PHYSFS_platformClose(finfo->handle);

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

        inflateEnd(&finfo->stream);

    if (finfo->buffer != NULL)

        free(finfo->buffer);

static PHYSFS_sint64 find_end_of_central_dir(void *in, PHYSFS_sint64 *len)

{

    /* !!! FIXME: potential race condition! */

    /* !!! FIXME: mutex this or switch to smaller stack-based buffer. */

    static PHYSFS_uint8 buf[0xFFFF + 20];

    PHYSFS_sint32 i;

    PHYSFS_sint64 filelen;

    PHYSFS_sint64 filepos;

    PHYSFS_sint32 maxread;

    filelen = __PHYSFS_platformFileLength(in);

    BAIL_IF_MACRO(filelen == -1, NULL, 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 64k at most, and call it a

     *  corrupted zipfile.

     */

    /*

     * !!! FIXME: This was easier than reading backwards in chunks, but it's

     * !!! FIXME:  rather memory hungry.

     */

    if (sizeof (buf) < filelen)

    {

        filepos = filelen - sizeof (buf);

        maxread = sizeof (buf);

    } /* if */

    else

    {

        filepos = 0;

        maxread = filelen;

    } /* else */

    BAIL_IF_MACRO(!__PHYSFS_platformSeek(in, filepos), NULL, -1);

    BAIL_IF_MACRO(__PHYSFS_platformRead(in, buf, maxread, 1) != 1, NULL, -1);

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

    {

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

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

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

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

        {

            break;  /* that's the signature! */

        } /* if */

    } /* for */

    BAIL_IF_MACRO(i < 0, ERR_NOT_AN_ARCHIVE, -1);

    if (len != NULL)

        *len = filelen;

    return(filelen - (maxread - i));

} /* find_end_of_central_dir */

    PHYSFS_uint32 sig;

    int retval;

    void *in;

    in = __PHYSFS_platformOpenRead(filename);

    BAIL_IF_MACRO(in == NULL, NULL, 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.

     */

    BAIL_IF_MACRO(!readui32(in, &sig), NULL, 0);

    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

         *  it the hard way...

         */

        retval = (find_end_of_central_dir(in, NULL) == -1);

    __PHYSFS_platformClose(in);

static int zip_set_open_position(void *in, ZIPentry *entry)

{

    /*

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