/**

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

/* !!! FIXME: use snprintf(), not sprintf(). */

#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_ERRSTATETYPE__

{

    void *tid;

    PHYSFS_ErrorCode code;

    struct __PHYSFS_ERRSTATETYPE__ *next;

} ErrState;

/* General PhysicsFS state ... */

static int initialized = 0;

static ErrState *errorStates = 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 char *prefDir = NULL;

static int allowSymLinks = 0;

static const PHYSFS_Archiver **archivers = NULL;

static const PHYSFS_ArchiveInfo **archiveInfo = NULL;

static volatile size_t numArchivers = 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 =

{

    CURRENT_PHYSFS_IO_API_VERSION, NULL,

    nativeIo_read,

    nativeIo_write,

    nativeIo_seek,

    nativeIo_tell,

    nativeIo_length,

    nativeIo_duplicate,

    nativeIo_flush,

    nativeIo_destroy

};

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, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

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

    GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

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

    GOTO_IF_MACRO(!pathdup, PHYSFS_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, ERRPASS, 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, (size_t) len);

    info->pos += len;

    return len;

} /* memoryIo_read */

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

                                    PHYSFS_uint64 len)

{

    BAIL_MACRO(PHYSFS_ERR_OPEN_FOR_READING, -1);

} /* memoryIo_write */

static int memoryIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

{

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

    BAIL_IF_MACRO(offset > info->len, PHYSFS_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, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

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

    if (!newinfo)

    {

        allocator.Free(retval);

        BAIL_MACRO(PHYSFS_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. */

        allocator.Free(info);

        allocator.Free(io);

        if (destruct != NULL)

            destruct(buf);

    } /* if */

} /* memoryIo_destroy */

static const PHYSFS_Io __PHYSFS_memoryIoInterface =

{

    CURRENT_PHYSFS_IO_API_VERSION, NULL,

    memoryIo_read,

    memoryIo_write,

    memoryIo_seek,

    memoryIo_tell,

    memoryIo_length,

    memoryIo_duplicate,

    memoryIo_flush,

    memoryIo_destroy

};

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, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);

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

    GOTO_IF_MACRO(!info, PHYSFS_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 */

/* PHYSFS_Io implementation for i/o to a PHYSFS_File... */

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

{

    return PHYSFS_readBytes((PHYSFS_File *) io->opaque, buf, len);

} /* handleIo_read */

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

                                    PHYSFS_uint64 len)

{

    return PHYSFS_writeBytes((PHYSFS_File *) io->opaque, buffer, len);

} /* handleIo_write */

static int handleIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

{

    return PHYSFS_seek((PHYSFS_File *) io->opaque, offset);

} /* handleIo_seek */

static PHYSFS_sint64 handleIo_tell(PHYSFS_Io *io)

{

    return PHYSFS_tell((PHYSFS_File *) io->opaque);

} /* handleIo_tell */

static PHYSFS_sint64 handleIo_length(PHYSFS_Io *io)

{

    return PHYSFS_fileLength((PHYSFS_File *) io->opaque);

} /* handleIo_length */

static PHYSFS_Io *handleIo_duplicate(PHYSFS_Io *io)

{

    /*

     * There's no duplicate at the PHYSFS_File level, so we break the

     *  abstraction. We're allowed to: we're physfs.c!

     */

    FileHandle *origfh = (FileHandle *) io->opaque;

    FileHandle *newfh = (FileHandle *) allocator.Malloc(sizeof (FileHandle));

    PHYSFS_Io *retval = NULL;

    GOTO_IF_MACRO(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

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

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

    GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

#if 0  /* we don't buffer the duplicate, at least not at the moment. */

    if (origfh->buffer != NULL)

    {

        newfh->buffer = (PHYSFS_uint8 *) allocator.Malloc(origfh->bufsize);

        if (!newfh->buffer)

            GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

        newfh->bufsize = origfh->bufsize;

    } /* if */

#endif

    newfh->io = origfh->io->duplicate(origfh->io);

    GOTO_IF_MACRO(!newfh->io, ERRPASS, handleIo_dupe_failed);

    newfh->forReading = origfh->forReading;

    newfh->dirHandle = origfh->dirHandle;

    __PHYSFS_platformGrabMutex(stateLock);

    if (newfh->forReading)

    {

        newfh->next = openReadList;

        openReadList = newfh;

    } /* if */

    else

    {

        newfh->next = openWriteList;

        openWriteList = newfh;

    } /* else */

    __PHYSFS_platformReleaseMutex(stateLock);

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

    retval->opaque = newfh;

    return retval;

handleIo_dupe_failed:

    if (newfh)

    {

        if (newfh->io != NULL) newfh->io->destroy(newfh->io);

        if (newfh->buffer != NULL) allocator.Free(newfh->buffer);

        allocator.Free(newfh);

    } /* if */

    return NULL;

} /* handleIo_duplicate */

static int handleIo_flush(PHYSFS_Io *io)

{

    return PHYSFS_flush((PHYSFS_File *) io->opaque);

} /* handleIo_flush */

static void handleIo_destroy(PHYSFS_Io *io)

{

    if (io->opaque != NULL)

        PHYSFS_close((PHYSFS_File *) io->opaque);

    allocator.Free(io);

} /* handleIo_destroy */

static const PHYSFS_Io __PHYSFS_handleIoInterface =

{

    CURRENT_PHYSFS_IO_API_VERSION, NULL,

    handleIo_read,

    handleIo_write,

    handleIo_seek,

    handleIo_tell,

    handleIo_length,

    handleIo_duplicate,

    handleIo_flush,

    handleIo_destroy

};

static PHYSFS_Io *__PHYSFS_createHandleIo(PHYSFS_File *f)

{

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

    BAIL_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

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

    io->opaque = f;

    return io;

} /* __PHYSFS_createHandleIo */

/* functions ... */

typedef struct

{

    char **list;

    PHYSFS_uint32 size;

    PHYSFS_ErrorCode errcode;

} EnumStringListCallbackData;

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

{

    void *ptr;

    char *newstr;

    EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data;

    if (pecd->errcode)

        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->errcode = PHYSFS_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++;