/**

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

 */

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

{

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

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

    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__

{

    PHYSFS_uint64 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;

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

    NULL

};

static const PHYSFS_Archiver *archivers[] =

{

    &__PHYSFS_Archiver_DIR,

#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

    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;

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

{

    EnumStringListCallbackData ecd;

    memset(&ecd, '\0', sizeof (ecd));

    ecd.list = (char **) allocator.Malloc(sizeof (char *));

    BAIL_IF_MACRO(ecd.list == NULL, ERR_OUT_OF_MEMORY, NULL);

    func(enumStringListCallback, &ecd);

    BAIL_IF_MACRO(ecd.errorstr != NULL, ecd.errorstr, NULL);

    ecd.list[ecd.size] = NULL;

    return(ecd.list);

} /* doEnumStringList */

static void __PHYSFS_bubble_sort(void *a, PHYSFS_uint32 lo, PHYSFS_uint32 hi,

                         int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32),

                         void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32))

{

    PHYSFS_uint32 i;

    int sorted;

    do

    {

        sorted = 1;

        for (i = lo; i < hi; i++)

        {

            if (cmpfn(a, i, i + 1) > 0)

            {

                swapfn(a, i, i + 1);

                sorted = 0;

            } /* if */

        } /* for */

    } while (!sorted);

} /* __PHYSFS_bubble_sort */

static void __PHYSFS_quick_sort(void *a, PHYSFS_uint32 lo, PHYSFS_uint32 hi,

                         int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32),

                         void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32))

{

    PHYSFS_uint32 i;

    PHYSFS_uint32 j;

    PHYSFS_uint32 v;

    if ((hi - lo) <= PHYSFS_QUICKSORT_THRESHOLD)

        __PHYSFS_bubble_sort(a, lo, hi, cmpfn, swapfn);

    else

    {

        i = (hi + lo) / 2;

        if (cmpfn(a, lo, i) > 0) swapfn(a, lo, i);

        if (cmpfn(a, lo, hi) > 0) swapfn(a, lo, hi);

        if (cmpfn(a, i, hi) > 0) swapfn(a, i, hi);

        j = hi - 1;

        swapfn(a, i, j);

        i = lo;

        v = j;

        while (1)

        {

            while(cmpfn(a, ++i, v) < 0) { /* do nothing */ }

            while(cmpfn(a, --j, v) > 0) { /* do nothing */ }

            if (j < i)

                break;

            swapfn(a, i, j);

        } /* while */

        swapfn(a, i, hi-1);

        __PHYSFS_quick_sort(a, lo, j, cmpfn, swapfn);

        __PHYSFS_quick_sort(a, i+1, hi, cmpfn, swapfn);

    } /* else */

} /* __PHYSFS_quick_sort */

void __PHYSFS_sort(void *entries, PHYSFS_uint32 max,

                   int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32),

                   void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32))

{

    /*

     * Quicksort w/ Bubblesort fallback algorithm inspired by code from here:

     *   http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html

     */

    __PHYSFS_quick_sort(entries, 0, max - 1, cmpfn, swapfn);

} /* __PHYSFS_sort */

static ErrMsg *findErrorForCurrentThread(void)

{

    ErrMsg *i;

    PHYSFS_uint64 tid;

    if (errorLock != NULL)

        __PHYSFS_platformGrabMutex(errorLock);

    if (errorMessages != NULL)

    {

        tid = __PHYSFS_platformGetThreadID();

        for (i = errorMessages; i != NULL; i = i->next)

        {

            if (i->tid == tid)

            {

                if (errorLock != NULL)

                    __PHYSFS_platformReleaseMutex(errorLock);

                return(i);

            } /* if */

        } /* for */

    } /* if */

    if (errorLock != NULL)

        __PHYSFS_platformReleaseMutex(errorLock);

    return(NULL);   /* no error available. */

} /* findErrorForCurrentThread */

void __PHYSFS_setError(const char *str)

{

    ErrMsg *err;

    if (str == NULL)

        return;

    err = findErrorForCurrentThread();

    if (err == NULL)

    {

        err = (ErrMsg *) allocator.Malloc(sizeof (ErrMsg));

        if (err == NULL)

            return;   /* uhh...? */

        memset((void *) err, '\0', sizeof (ErrMsg));

        err->tid = __PHYSFS_platformGetThreadID();

        if (errorLock != NULL)

            __PHYSFS_platformGrabMutex(errorLock);

        err->next = errorMessages;

        errorMessages = err;

        if (errorLock != NULL)

            __PHYSFS_platformReleaseMutex(errorLock);

    } /* if */

    err->errorAvailable = 1;

    strncpy(err->errorString, str, sizeof (err->errorString));

    err->errorString[sizeof (err->errorString) - 1] = '\0';

} /* __PHYSFS_setError */

const char *PHYSFS_getLastError(void)

{

    ErrMsg *err = findErrorForCurrentThread();

    if ((err == NULL) || (!err->errorAvailable))

        return(NULL);

    err->errorAvailable = 0;

    return(err->errorString);

} /* PHYSFS_getLastError */

/* MAKE SURE that errorLock is held before calling this! */

static void freeErrorMessages(void)

{

    ErrMsg *i;

    ErrMsg *next;

    for (i = errorMessages; i != NULL; i = next)

    {

        next = i->next;

        allocator.Free(i);

    } /* for */

    errorMessages = NULL;

} /* freeErrorMessages */

void PHYSFS_getLinkedVersion(PHYSFS_Version *ver)

{

    if (ver != NULL)

    {

        ver->major = PHYSFS_VER_MAJOR;

        ver->minor = PHYSFS_VER_MINOR;

        ver->patch = PHYSFS_VER_PATCH;

    } /* if */

} /* PHYSFS_getLinkedVersion */

static const char *find_filename_extension(const char *fname)

{

    const char *retval = strchr(fname, '.');

    const char *p = retval;

    while (p != NULL)

    {

        p = strchr(p + 1, '.');

        if (p != NULL)

            retval = p;

    } /* while */

    if (retval != NULL)

        retval++;  /* skip '.' */

    return(retval);

} /* find_filename_extension */

static DirHandle *tryOpenDir(const PHYSFS_Archiver *funcs,

                             const char *d, int forWriting)

{

    DirHandle *retval = NULL;

    if (funcs->isArchive(d, forWriting))

    {

        void *opaque = funcs->openArchive(d, forWriting);

        if (opaque != NULL)

        {

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

            if (retval == NULL)

                funcs->dirClose(opaque);

            else

            {

                memset(retval, '\0', sizeof (DirHandle));

                retval->mountPoint = NULL;

                retval->funcs = funcs;

                retval->opaque = opaque;

            } /* else */

        } /* if */

    } /* if */

    return(retval);

} /* tryOpenDir */

static DirHandle *openDirectory(const char *d, int forWriting)

{

    DirHandle *retval = NULL;

    const PHYSFS_Archiver **i;

    const char *ext;

    BAIL_IF_MACRO(!__PHYSFS_platformExists(d), ERR_NO_SUCH_FILE, NULL);

    ext = find_filename_extension(d);

    if (ext != NULL)

    {

        /* Look for archivers with matching file extensions first... */

        for (i = archivers; (*i != NULL) && (retval == NULL); i++)

        {

            if (__PHYSFS_stricmpASCII(ext, (*i)->info->extension) == 0)

                retval = tryOpenDir(*i, d, forWriting);

        } /* for */

        /* failing an exact file extension match, try all the others... */

        for (i = archivers; (*i != NULL) && (retval == NULL); i++)

        {

            if (__PHYSFS_stricmpASCII(ext, (*i)->info->extension) != 0)

                retval = tryOpenDir(*i, d, forWriting);

        } /* for */

    } /* if */

    else  /* no extension? Try them all. */

    {

        for (i = archivers; (*i != NULL) && (retval == NULL); i++)

            retval = tryOpenDir(*i, d, forWriting);

    } /* else */

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

    return(retval);

} /* openDirectory */

/*

 * Make a platform-independent path string sane. Doesn't actually check the

 *  file hierarchy, it just cleans up the string.

 *  (dst) must be a buffer at least as big as (src), as this is where the

 *  cleaned up string is deposited.

 * If there are illegal bits in the path (".." entries, etc) then we

 *  return zero and (dst) is undefined. Non-zero if the path was sanitized.

 */

static int sanitizePlatformIndependentPath(const char *src, char *dst)

{

    char *prev;

    char ch;

    while (*src == '/')  /* skip initial '/' chars... */

        src++;

    prev = dst;

    do

    {

        ch = *(src++);

        if ((ch == ':') || (ch == '\\'))  /* illegal chars in a physfs path. */

            BAIL_MACRO(ERR_INSECURE_FNAME, 0);

        if (ch == '/')   /* path separator. */

        {

            *dst = '\0';  /* "." and ".." are illegal pathnames. */

            if ((strcmp(prev, ".") == 0) || (strcmp(prev, "..") == 0))

                BAIL_MACRO(ERR_INSECURE_FNAME, 0);

            while (*src == '/')   /* chop out doubles... */

                src++;

            if (*src == '\0') /* ends with a pathsep? */

                break;  /* we're done, don't add final pathsep to dst. */

            prev = dst + 1;

        } /* if */