/**

 * PhysicsFS; a portable, flexible file i/o abstraction.

 *

 * Documentation is in physfs.h. It's verbose, honest.  :)

 *

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

 *

 *  This file written by Ryan C. Gordon.

 */

/* !!! FIXME: ERR_PAST_EOF shouldn't trigger for reads. Just return zero. */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

typedef struct __PHYSFS_DIRHANDLE__

{

    void *opaque;  /* Instance data unique to the archiver. */

    char *dirName;  /* Path to archive in platform-dependent notation. */

    char *mountPoint; /* Mountpoint in virtual file tree. */

    const PHYSFS_Archiver *funcs;  /* Ptr to archiver info for this handle. */

    struct __PHYSFS_DIRHANDLE__ *next;  /* linked list stuff. */

} DirHandle;

typedef struct __PHYSFS_FILEHANDLE__

{

    PHYSFS_Io *io;  /* Instance data unique to the archiver for this file. */

    PHYSFS_uint8 forReading; /* Non-zero if reading, zero if write/append */

    const DirHandle *dirHandle;  /* Archiver instance that created this */

    PHYSFS_uint8 *buffer;  /* Buffer, if set (NULL otherwise). Don't touch! */

    PHYSFS_uint32 bufsize;  /* Bufsize, if set (0 otherwise). Don't touch! */

    PHYSFS_uint32 buffill;  /* Buffer fill size. Don't touch! */

    PHYSFS_uint32 bufpos;  /* Buffer position. Don't touch! */

    struct __PHYSFS_FILEHANDLE__ *next;  /* linked list stuff. */

} FileHandle;

typedef struct __PHYSFS_ERRMSGTYPE__

{

    void *tid;

    int errorAvailable;

    char errorString[80];

    struct __PHYSFS_ERRMSGTYPE__ *next;

} ErrMsg;

/* The various i/o drivers...some of these may not be compiled in. */

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_ZIP;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_ZIP;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_LZMA;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_LZMA;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_GRP;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_GRP;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_QPAK;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_QPAK;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_HOG;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_HOG;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_MVL;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_MVL;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_WAD;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_WAD;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_DIR;

extern const PHYSFS_ArchiveInfo    __PHYSFS_ArchiveInfo_ISO9660;

extern const PHYSFS_Archiver       __PHYSFS_Archiver_ISO9660;

static const PHYSFS_ArchiveInfo *supported_types[] =

{

#if (defined PHYSFS_SUPPORTS_ZIP)

    &__PHYSFS_ArchiveInfo_ZIP,

#endif

#if (defined PHYSFS_SUPPORTS_7Z)

    &__PHYSFS_ArchiveInfo_LZMA,

#endif

#if (defined PHYSFS_SUPPORTS_GRP)

    &__PHYSFS_ArchiveInfo_GRP,

#endif

#if (defined PHYSFS_SUPPORTS_QPAK)

    &__PHYSFS_ArchiveInfo_QPAK,

#endif

#if (defined PHYSFS_SUPPORTS_HOG)

    &__PHYSFS_ArchiveInfo_HOG,

#endif

#if (defined PHYSFS_SUPPORTS_MVL)

    &__PHYSFS_ArchiveInfo_MVL,

#endif

#if (defined PHYSFS_SUPPORTS_WAD)

    &__PHYSFS_ArchiveInfo_WAD,

#endif

#if (defined PHYSFS_SUPPORTS_ISO9660)

    &__PHYSFS_ArchiveInfo_ISO9660,

#endif

    NULL

};

static const PHYSFS_Archiver *archivers[] =

{

#if (defined PHYSFS_SUPPORTS_ZIP)

    &__PHYSFS_Archiver_ZIP,

#endif

#if (defined PHYSFS_SUPPORTS_7Z)

    &__PHYSFS_Archiver_LZMA,

#endif

#if (defined PHYSFS_SUPPORTS_GRP)

    &__PHYSFS_Archiver_GRP,

#endif

#if (defined PHYSFS_SUPPORTS_QPAK)

    &__PHYSFS_Archiver_QPAK,

#endif

#if (defined PHYSFS_SUPPORTS_HOG)

    &__PHYSFS_Archiver_HOG,

#endif

#if (defined PHYSFS_SUPPORTS_MVL)

    &__PHYSFS_Archiver_MVL,

#endif

#if (defined PHYSFS_SUPPORTS_WAD)

    &__PHYSFS_Archiver_WAD,

#endif

#if (defined PHYSFS_SUPPORTS_ISO9660)

    &__PHYSFS_Archiver_ISO9660,

#endif

    NULL

};

/* General PhysicsFS state ... */

static int initialized = 0;

static ErrMsg *errorMessages = NULL;

static DirHandle *searchPath = NULL;

static DirHandle *writeDir = NULL;

static FileHandle *openWriteList = NULL;

static FileHandle *openReadList = NULL;

static char *baseDir = NULL;

static char *userDir = NULL;

static int allowSymLinks = 0;

/* mutexes ... */

static void *errorLock = NULL;     /* protects error message list.        */

static void *stateLock = NULL;     /* protects other PhysFS static state. */

/* allocator ... */

static int externalAllocator = 0;

PHYSFS_Allocator allocator;

/* PHYSFS_Io implementation for i/o to physical filesystem... */

/* !!! FIXME: maybe refcount the paths in a string pool? */

typedef struct __PHYSFS_NativeIoInfo

{

    void *handle;

    const char *path;

    int mode;   /* 'r', 'w', or 'a' */

} NativeIoInfo;

static PHYSFS_sint64 nativeIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_platformRead(info->handle, buf, len);

} /* nativeIo_read */

static PHYSFS_sint64 nativeIo_write(PHYSFS_Io *io, const void *buffer,

                                    PHYSFS_uint64 len)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_platformWrite(info->handle, buffer, len);

} /* nativeIo_write */

static int nativeIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_platformSeek(info->handle, offset);

} /* nativeIo_seek */

static PHYSFS_sint64 nativeIo_tell(PHYSFS_Io *io)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_platformTell(info->handle);

} /* nativeIo_tell */

static PHYSFS_sint64 nativeIo_length(PHYSFS_Io *io)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_platformFileLength(info->handle);

} /* nativeIo_length */

static PHYSFS_Io *nativeIo_duplicate(PHYSFS_Io *io)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    return __PHYSFS_createNativeIo(info->path, info->mode);

} /* nativeIo_duplicate */

static int nativeIo_flush(PHYSFS_Io *io)

{

    return __PHYSFS_platformFlush(io->opaque);

} /* nativeIo_flush */

static void nativeIo_destroy(PHYSFS_Io *io)

{

    NativeIoInfo *info = (NativeIoInfo *) io->opaque;

    __PHYSFS_platformClose(info->handle);

    allocator.Free((void *) info->path);

    allocator.Free(info);

    allocator.Free(io);

} /* nativeIo_destroy */

static const PHYSFS_Io __PHYSFS_nativeIoInterface =

{

    nativeIo_read,

    nativeIo_write,

    nativeIo_seek,

    nativeIo_tell,

    nativeIo_length,

    nativeIo_duplicate,

    nativeIo_flush,

    nativeIo_destroy,

    NULL

};

PHYSFS_Io *__PHYSFS_createNativeIo(const char *path, const int mode)

{

    PHYSFS_Io *io = NULL;

    NativeIoInfo *info = NULL;

    void *handle = NULL;

    char *pathdup = NULL;

    assert((mode == 'r') || (mode == 'w') || (mode == 'a'));

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

    GOTO_IF_MACRO(io == NULL, ERR_OUT_OF_MEMORY, createNativeIo_failed);

    info = (NativeIoInfo *) allocator.Malloc(sizeof (NativeIoInfo));

    GOTO_IF_MACRO(info == NULL, ERR_OUT_OF_MEMORY, createNativeIo_failed);

    pathdup = (char *) allocator.Malloc(strlen(path) + 1);

    GOTO_IF_MACRO(info == NULL, ERR_OUT_OF_MEMORY, createNativeIo_failed);

    if (mode == 'r')

        handle = __PHYSFS_platformOpenRead(path);

    else if (mode == 'w')

        handle = __PHYSFS_platformOpenWrite(path);

    else if (mode == 'a')

        handle = __PHYSFS_platformOpenAppend(path);

    GOTO_IF_MACRO(handle == NULL, NULL, createNativeIo_failed);

    strcpy(pathdup, path);

    info->handle = handle;

    info->path = pathdup;

    info->mode = mode;

    memcpy(io, &__PHYSFS_nativeIoInterface, sizeof (*io));

    io->opaque = info;

    return io;

createNativeIo_failed:

    if (handle != NULL) __PHYSFS_platformClose(handle);

    if (pathdup != NULL) allocator.Free(pathdup);

    if (info != NULL) allocator.Free(info);

    if (io != NULL) allocator.Free(io);

    return NULL;

} /* __PHYSFS_createNativeIo */

/* PHYSFS_Io implementation for i/o to a memory buffer... */

typedef struct __PHYSFS_MemoryIoInfo

{

    const PHYSFS_uint8 *buf;

    PHYSFS_uint64 len;

    PHYSFS_uint64 pos;

    PHYSFS_Io *parent;

    volatile PHYSFS_uint32 refcount;

    void (*destruct)(void *);

} MemoryIoInfo;

static PHYSFS_sint64 memoryIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

{

    MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    const PHYSFS_uint64 avail = info->len - info->pos;

    assert(avail <= info->len);

    if (avail == 0)

        return 0;  /* we're at EOF; nothing to do. */

    if (len > avail)

        len = avail;

    memcpy(buf, info->buf + info->pos, len);

    info->pos += len;

    return len;

} /* memoryIo_read */

static PHYSFS_sint64 memoryIo_write(PHYSFS_Io *io, const void *buffer,

                                    PHYSFS_uint64 len)

{

    BAIL_MACRO(ERR_NOT_SUPPORTED, -1);

} /* memoryIo_write */

static int memoryIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

{

    MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    BAIL_IF_MACRO(offset > info->len, ERR_PAST_EOF, 0);

    info->pos = offset;

    return 1;

} /* memoryIo_seek */

static PHYSFS_sint64 memoryIo_tell(PHYSFS_Io *io)

{

    const MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    return (PHYSFS_sint64) info->pos;

} /* memoryIo_tell */

static PHYSFS_sint64 memoryIo_length(PHYSFS_Io *io)

{

    const MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    return (PHYSFS_sint64) info->len;

} /* memoryIo_length */

static PHYSFS_Io *memoryIo_duplicate(PHYSFS_Io *io)

{

    MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    MemoryIoInfo *newinfo = NULL;

    PHYSFS_Io *parent = info->parent;

    PHYSFS_Io *retval = NULL;

    /* avoid deep copies. */

    assert((!parent) || (!((MemoryIoInfo *) parent->opaque)->parent) );

    /* share the buffer between duplicates. */

    if (parent != NULL)  /* dup the parent, increment its refcount. */

        return parent->duplicate(parent);

    /* we're the parent. */

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

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    newinfo = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));

    if (!newinfo)

    {

        allocator.Free(retval);

        BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);

    } /* if */

    /* !!! FIXME: want lockless atomic increment. */

    __PHYSFS_platformGrabMutex(stateLock);

    info->refcount++;

    __PHYSFS_platformReleaseMutex(stateLock);

    memset(newinfo, '\0', sizeof (*info));

    newinfo->buf = info->buf;

    newinfo->len = info->len;

    newinfo->pos = 0;

    newinfo->parent = io;

    newinfo->refcount = 0;

    newinfo->destruct = NULL;

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

    retval->opaque = newinfo;

    return retval;

} /* memoryIo_duplicate */

static int memoryIo_flush(PHYSFS_Io *io) { return 1;  /* it's read-only. */ }

static void memoryIo_destroy(PHYSFS_Io *io)

{

    MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

    PHYSFS_Io *parent = info->parent;

    int should_die = 0;

    if (parent != NULL)

    {

        assert(info->buf == ((MemoryIoInfo *) info->parent->opaque)->buf);

        assert(info->len == ((MemoryIoInfo *) info->parent->opaque)->len);

        assert(info->refcount == 0);

        assert(info->destruct == NULL);

        allocator.Free(info);

        allocator.Free(io);

        parent->destroy(parent);  /* decrements refcount. */

        return;

    } /* if */

    /* we _are_ the parent. */

    assert(info->refcount > 0);  /* even in a race, we hold a reference. */

    /* !!! FIXME: want lockless atomic decrement. */

    __PHYSFS_platformGrabMutex(stateLock);

    info->refcount--;

    should_die = (info->refcount == 0);

    __PHYSFS_platformReleaseMutex(stateLock);

    if (should_die)

    {

        void (*destruct)(void *) = info->destruct;

        void *buf = (void *) info->buf;

        io->opaque = NULL;  /* kill this here in case of race. */

        destruct = info->destruct;

        allocator.Free(info);

        allocator.Free(io);

        if (destruct != NULL)

        destruct(buf);

    } /* if */

} /* memoryIo_destroy */

static const PHYSFS_Io __PHYSFS_memoryIoInterface =

{

    memoryIo_read,

    memoryIo_write,

    memoryIo_seek,

    memoryIo_tell,

    memoryIo_length,

    memoryIo_duplicate,

    memoryIo_flush,

    memoryIo_destroy,

    NULL

};

PHYSFS_Io *__PHYSFS_createMemoryIo(const void *buf, PHYSFS_uint64 len,

                                   void (*destruct)(void *))

{

    PHYSFS_Io *io = NULL;

    MemoryIoInfo *info = NULL;

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

    GOTO_IF_MACRO(io == NULL, ERR_OUT_OF_MEMORY, createMemoryIo_failed);

    info = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));

    GOTO_IF_MACRO(info == NULL, ERR_OUT_OF_MEMORY, createMemoryIo_failed);

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

    info->buf = (const PHYSFS_uint8 *) buf;

    info->len = len;

    info->pos = 0;

    info->parent = NULL;

    info->refcount = 1;

    info->destruct = destruct;

    memcpy(io, &__PHYSFS_memoryIoInterface, sizeof (*io));

    io->opaque = info;

    return io;

createMemoryIo_failed:

    if (info != NULL) allocator.Free(info);

    if (io != NULL) allocator.Free(io);

    return NULL;

} /* __PHYSFS_createMemoryIo */

/* functions ... */

typedef struct

{

    char **list;

    PHYSFS_uint32 size;

    const char *errorstr;

} EnumStringListCallbackData;

static void enumStringListCallback(void *data, const char *str)

{

    void *ptr;

    char *newstr;

    EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data;

    if (pecd->errorstr)

        return;

    ptr = allocator.Realloc(pecd->list, (pecd->size + 2) * sizeof (char *));

    newstr = (char *) allocator.Malloc(strlen(str) + 1);

    if (ptr != NULL)

        pecd->list = (char **) ptr;

    if ((ptr == NULL) || (newstr == NULL))

    {

        pecd->errorstr = ERR_OUT_OF_MEMORY;

        pecd->list[pecd->size] = NULL;

        PHYSFS_freeList(pecd->list);

        return;

    } /* if */

    strcpy(newstr, str);

    pecd->list[pecd->size] = newstr;

    pecd->size++;

} /* enumStringListCallback */

static char **doEnumStringList(void (*func)(PHYSFS_StringCallback, void *))