/*

 * LZMA support routines for PhysicsFS.

 *

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

 *

 *  This file written by Dennis Schridde, with some peeking at "7zMain.c"

 *   by Igor Pavlov.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#if (defined PHYSFS_SUPPORTS_LZMA)

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

{

    ISzInStream InStream;

    void *File;

} CFileInStream;

{

    struct _LZMAentry *lastEntry;

} LZMAarchive;

typedef struct _LZMAentry

{

    struct _LZMAentry *previous;

} LZMAentry;

static void *SzAllocPhysicsFS(size_t size)

{

    return ((size == 0) ? NULL : allocator.Malloc(size));

} /* SzAllocPhysicsFS */

static void SzFreePhysicsFS(void *address)

{

    if (address != NULL)

        allocator.Free(address);

} /* SzFreePhysicsFS */

{

    size_t processedSizeLoc;

        *processedSize = processedSizeLoc;

    return SZ_OK;

} /* SzFileReadImp */

SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)

{

    CFileInStream *s = (CFileInStream *) object;

    if (__PHYSFS_platformSeek(s->File, (PHYSFS_uint64) pos))

        return SZ_OK;

    return SZE_FAIL;

} /* SzFileSeekImp */

{

    {

    } /* for */

} /* lzma_find_entry */

static PHYSFS_sint32 lzma_find_start_of_dir(LZMAarchive *archive,

                                            const char *path,

                                            int stop_on_first_find)

{

    PHYSFS_sint32 lo = 0;

    PHYSFS_sint32 hi = (PHYSFS_sint32) (archive->db.Database.NumFiles - 1);

    PHYSFS_sint32 middle;

    PHYSFS_uint32 dlen = strlen(path);

    PHYSFS_sint32 retval = -1;

    const char *name;

    int rc;

    if (*path == '\0')  /* root dir? */

        return(0);

    if ((dlen > 0) && (path[dlen - 1] == '/')) /* ignore trailing slash. */

        dlen--;

    while (lo <= hi)

    {

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

        name = archive->db.Database.Files[middle].Name;

        rc = strncmp(path, name, dlen);

        if (rc == 0)

        {

            char ch = name[dlen];

            if ('/' < ch) /* make sure this isn't just a substr match. */

                rc = -1;

            else if ('/' > ch)

                rc = 1;

            else

            {

                if (stop_on_first_find) /* Just checking dir's existance? */

                    return(middle);

                if (name[dlen + 1] == '\0') /* Skip initial dir entry. */

                    return(middle + 1);

                /* there might be more entries earlier in the list. */

                retval = middle;

                hi = middle - 1;

            } /* else */

        } /* if */

        if (rc > 0)

            lo = middle + 1;

        else

            hi = middle - 1;

    } /* while */

    return(retval);

} /* lzma_find_start_of_dir */

/*

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

 */

static int lzma_err(SZ_RESULT rc)

{

    switch (rc)

    {

        case SZ_OK: /* Same as LZMA_RESULT_OK */

            break;

        case SZE_DATA_ERROR: /* Same as LZMA_RESULT_DATA_ERROR */

            __PHYSFS_setError(ERR_DATA_ERROR);

            break;

        case SZE_OUTOFMEMORY:

            __PHYSFS_setError(ERR_OUT_OF_MEMORY);

            break;

        case SZE_CRC_ERROR:

            __PHYSFS_setError(ERR_CORRUPTED);

            break;

        case SZE_NOTIMPL:

            __PHYSFS_setError(ERR_NOT_IMPLEMENTED);

            break;

        case SZE_FAIL:

            __PHYSFS_setError(ERR_UNKNOWN_ERROR);  /* !!! FIXME: right? */

            break;

        case SZE_ARCHIVE_ERROR:

            __PHYSFS_setError(ERR_CORRUPTED);  /* !!! FIXME: right? */

            break;

        default:

            __PHYSFS_setError(ERR_UNKNOWN_ERROR);

    } /* switch */

    return(rc);

} /* lzma_err */

static PHYSFS_sint64 LZMA_read(fvoid *opaque, void *outBuffer,

                               PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)

{

    LZMAentry *entry = (LZMAentry *) opaque;

    {

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

    } /* if */

} /* LZMA_read */

static PHYSFS_sint64 LZMA_write(fvoid *opaque, const void *buf,

                               PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)

{

    BAIL_MACRO(ERR_NOT_SUPPORTED, -1);

} /* LZMA_write */

static int LZMA_eof(fvoid *opaque)

{

    LZMAentry *entry = (LZMAentry *) opaque;

} /* LZMA_eof */

static PHYSFS_sint64 LZMA_tell(fvoid *opaque)

{

    LZMAentry *entry = (LZMAentry *) opaque;

    return (entry->position);

} /* LZMA_tell */

static int LZMA_seek(fvoid *opaque, PHYSFS_uint64 offset)

{

    LZMAentry *entry = (LZMAentry *) opaque;

    BAIL_IF_MACRO(offset < 0, ERR_SEEK_OUT_OF_RANGE, 0);

    BAIL_IF_MACRO(offset > entry->file->Size, ERR_PAST_EOF, 0);

} /* LZMA_seek */

static PHYSFS_sint64 LZMA_fileLength(fvoid *opaque)

{

} /* LZMA_fileLength */

static int LZMA_fileClose(fvoid *opaque)

{

    LZMAentry *entry = (LZMAentry *) opaque;

    /* Fix archive */

    if (entry == entry->archive->firstEntry)

        entry->archive->firstEntry = entry->next;

    if (entry == entry->archive->lastEntry)

        entry->archive->lastEntry = entry->previous;

    /* Fix neighbours */

    if (entry->previous != NULL)

        entry->previous->next = entry->next;

    if (entry->next != NULL)

        entry->next->previous = entry->previous;

    return(1);

} /* LZMA_fileClose */

static int LZMA_isArchive(const char *filename, int forWriting)

{

    PHYSFS_uint8 sig[k7zSignatureSize];

    PHYSFS_uint8 res;

    void *in;

    BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, 0);

    in = __PHYSFS_platformOpenRead(filename);

    BAIL_IF_MACRO(in == NULL, NULL, 0);

    if (__PHYSFS_platformRead(in, sig, k7zSignatureSize, 1) != 1)

        BAIL_MACRO(NULL, 0);

    res = TestSignatureCandidate(sig);

    __PHYSFS_platformClose(in);

    return res;

} /* LZMA_isArchive */

static void *LZMA_openArchive(const char *name, int forWriting)

{

    LZMAarchive *archive;

    ISzAlloc allocImp;

    ISzAlloc allocTempImp;

    BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, NULL);

    if ((archive->stream.File = __PHYSFS_platformOpenRead(name)) == NULL)

    {

        allocator.Free(archive);

        return NULL;

    } /* if */

    archive->stream.InStream.Read = SzFileReadImp;

    archive->stream.InStream.Seek = SzFileSeekImp;

    allocImp.Alloc = SzAllocPhysicsFS;

    allocImp.Free = SzFreePhysicsFS;

    allocTempImp.Alloc = SzAllocPhysicsFS;

    allocTempImp.Free = SzFreePhysicsFS;

    InitCrcTable();

    SzArDbExInit(&archive->db);

    if (lzma_err(SzArchiveOpen(&archive->stream.InStream, &archive->db,

                               &allocImp, &allocTempImp)) != SZ_OK)

    {

        __PHYSFS_platformClose(archive->stream.File);

        allocator.Free(archive);

        return NULL;

    } /* if */

    return(archive);

} /* LZMA_openArchive */

/*

 * Moved to seperate function so we can use alloca then immediately throw

 *  away the allocated stack space...

 */

static void doEnumCallback(PHYSFS_EnumFilesCallback cb, void *callbackdata,

                           const char *odir, const char *str, PHYSFS_sint32 ln)

{

    char *newstr = alloca(ln + 1);

    if (newstr == NULL)

        return;

    memcpy(newstr, str, ln);

    newstr[ln] = '\0';

    cb(callbackdata, odir, newstr);

} /* doEnumCallback */

static void LZMA_enumerateFiles(dvoid *opaque, const char *dname,

                                int omitSymLinks, PHYSFS_EnumFilesCallback cb,

                                const char *origdir, void *callbackdata)

{

    LZMAarchive *archive = (LZMAarchive *) opaque;

    PHYSFS_sint32 dlen;

    PHYSFS_sint32 dlen_inc;

    PHYSFS_sint32 max;

    PHYSFS_sint32 i;

    i = lzma_find_start_of_dir(archive, dname, 0);

    if (i == -1)  /* no such directory. */

        return;

    dlen = strlen(dname);

    if ((dlen > 0) && (dname[dlen - 1] == '/')) /* ignore trailing slash. */

        dlen--;

    dlen_inc = ((dlen > 0) ? 1 : 0) + dlen;

    max = (PHYSFS_sint32) archive->db.Database.NumFiles;

    while (i < max)

    {

        char *add;

        char *ptr;

        PHYSFS_sint32 ln;

        char *e = archive->db.Database.Files[i].Name;

        if ((dlen) && ((strncmp(e, dname, dlen)) || (e[dlen] != '/')))

            break;  /* past end of this dir; we're done. */

        add = e + dlen_inc;

        ptr = strchr(add, '/');

        ln = (PHYSFS_sint32) ((ptr) ? ptr-add : strlen(add));

        doEnumCallback(cb, callbackdata, origdir, add, ln);

        ln += dlen_inc;  /* point past entry to children... */

        /* increment counter and skip children of subdirs... */

        while ((++i < max) && (ptr != NULL))

        {

            char *e_new = archive->db.Database.Files[i].Name;

            if ((strncmp(e, e_new, ln) != 0) || (e_new[ln] != '/'))

                break;

        } /* while */

    } /* while */

} /* LZMA_enumerateFiles */

static int LZMA_exists(dvoid *opaque, const char *name)

{

} /* LZMA_exists */

static PHYSFS_sint64 LZMA_getLastModTime(dvoid *opaque,

{

} /* LZMA_getLastModTime */

static int LZMA_isDirectory(dvoid *opaque, const char *name, int *fileExists)

{