/**

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

 *

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

 *

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

 *

 *  This file written by Ryan C. Gordon.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#if (defined PHYSFS_PROFILING)

#include <sys/time.h>

#include <unistd.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

typedef struct __PHYSFS_ERRMSGTYPE__

{

    PHYSFS_uint64 tid;

    int errorAvailable;

    char errorString[80];

    struct __PHYSFS_ERRMSGTYPE__ *next;

} ErrMsg;

typedef struct __PHYSFS_DIRINFO__

{

    char *dirName;

    DirHandle *dirHandle;

    struct __PHYSFS_DIRINFO__ *next;

} PhysDirInfo;

typedef struct __PHYSFS_FILEHANDLELIST__

{

    PHYSFS_file handle;

    struct __PHYSFS_FILEHANDLELIST__ *next;

} FileHandleList;

/* The various i/o drivers... */

#if (defined PHYSFS_SUPPORTS_ZIP)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_ZIP;

extern const DirFunctions         __PHYSFS_DirFunctions_ZIP;

#endif

#if (defined PHYSFS_SUPPORTS_GRP)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_GRP;

extern const DirFunctions         __PHYSFS_DirFunctions_GRP;

#endif

#if (defined PHYSFS_SUPPORTS_QPAK)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_QPAK;

extern const DirFunctions         __PHYSFS_DirFunctions_QPAK;

#endif

#if (defined PHYSFS_SUPPORTS_HOG)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_HOG;

extern const DirFunctions         __PHYSFS_DirFunctions_HOG;

#endif

#if (defined PHYSFS_SUPPORTS_MVL)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_MVL;

extern const DirFunctions         __PHYSFS_DirFunctions_MVL;

#endif

#if (defined PHYSFS_SUPPORTS_WAD)

extern const PHYSFS_ArchiveInfo   __PHYSFS_ArchiveInfo_WAD;

extern const DirFunctions         __PHYSFS_DirFunctions_WAD;

#endif

extern const DirFunctions  __PHYSFS_DirFunctions_DIR;

static const PHYSFS_ArchiveInfo *supported_types[] =

{

#if (defined PHYSFS_SUPPORTS_ZIP)

    &__PHYSFS_ArchiveInfo_ZIP,

#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 DirFunctions *dirFunctions[] =

{

#if (defined PHYSFS_SUPPORTS_ZIP)

    &__PHYSFS_DirFunctions_ZIP,

#endif

#if (defined PHYSFS_SUPPORTS_GRP)

    &__PHYSFS_DirFunctions_GRP,

#endif

#if (defined PHYSFS_SUPPORTS_QPAK)

    &__PHYSFS_DirFunctions_QPAK,

#endif

#if (defined PHYSFS_SUPPORTS_HOG)

    &__PHYSFS_DirFunctions_HOG,

#endif

#if (defined PHYSFS_SUPPORTS_MVL)

    &__PHYSFS_DirFunctions_MVL,

#endif

#if (defined PHYSFS_SUPPORTS_WAD)

    &__PHYSFS_DirFunctions_WAD,

#endif

    &__PHYSFS_DirFunctions_DIR,

    NULL

};

/* General PhysicsFS state ... */

static int initialized = 0;

static ErrMsg *errorMessages = NULL;

static PhysDirInfo *searchPath = NULL;

static PhysDirInfo *writeDir = NULL;

static FileHandleList *openWriteList = NULL;

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

/* functions ... */

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

#if (defined PHYSFS_PROFILING)

#define PHYSFS_TEST_SORT_ITERATIONS 150

#define PHYSFS_TEST_SORT_ELEMENTS   (64 * 1024)

static int __PHYSFS_test_sort_cmp(void *_a, PHYSFS_uint32 x, PHYSFS_uint32 y)

{

    PHYSFS_sint32 *a = (PHYSFS_sint32 *) _a;

    PHYSFS_sint32 one = a[x];

    PHYSFS_sint32 two = a[y];

    if (one < two)

        return(-1);

    else if (one > two)

        return(1);

    return(0);

} /* __PHYSFS_test_sort_cmp */

static void __PHYSFS_test_sort_swap(void *_a, PHYSFS_uint32 x, PHYSFS_uint32 y)

{

    PHYSFS_sint32 *a = (PHYSFS_sint32 *) _a;

    PHYSFS_sint32 tmp;

    tmp = a[x];

    a[x] = a[y];

    a[y] = tmp;

} /* __PHYSFS_test_sort_swap */

static int __PHYSFS_test_sort_do(PHYSFS_uint32 *timer,

                         PHYSFS_sint32 *a, PHYSFS_uint32 max,

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

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

{

    PHYSFS_uint32 i;

    struct timeval starttime, endtime;

    gettimeofday(&starttime, NULL);

    __PHYSFS_sort(a, max, cmpfn, swapfn);

    gettimeofday(&endtime, NULL);

    for (i = 1; i < max; i++)

    {

        if (a[i] < a[i - 1])

            return(0);

    } /* for */

    if (timer != NULL)

    {

        *timer = ( ((endtime.tv_sec  - starttime.tv_sec) * 1000) +

                   ((endtime.tv_usec - starttime.tv_usec) / 1000) );

    } /* if */

    return(1);

} /* __PHYSFS_test_sort_time */

static void __PHYSFS_test_sort(void)

{

    PHYSFS_uint32 elasped[PHYSFS_TEST_SORT_ITERATIONS];

    PHYSFS_sint32 iter;

    PHYSFS_sint32 a[PHYSFS_TEST_SORT_ELEMENTS];

    PHYSFS_sint32 i, x;

    int success;

    printf("Testing __PHYSFS_sort (linear presorted) ... ");

    for (iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

    {

        /* set up array to sort. */

        for (i = 0; i < PHYSFS_TEST_SORT_ELEMENTS; i++)

            a[i] = i;

        /* sort it. */

        success = __PHYSFS_test_sort_do(&elasped[iter],

                                        a, PHYSFS_TEST_SORT_ELEMENTS,

                                        __PHYSFS_test_sort_cmp,

                                        __PHYSFS_test_sort_swap);

        if (!success)

            break;

    } /* for */

    if (!success)

        printf("Failed!\n");

    else

    {

        for (x = 0, iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

            x += elasped[iter];

        x /= PHYSFS_TEST_SORT_ITERATIONS;

        printf("Average run (%lu) ms.\n", (unsigned long) x);

    } /* else */

    printf("Testing __PHYSFS_sort (linear presorted reverse) ... ");

    for (iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

    {

        /* set up array to sort. */

        for (i = 0, x = PHYSFS_TEST_SORT_ELEMENTS;

             i < PHYSFS_TEST_SORT_ELEMENTS;

             i++, x--)

        {

            a[i] = x;

        } /* for */

        /* sort it. */

        success = __PHYSFS_test_sort_do(&elasped[iter],

                                        a, PHYSFS_TEST_SORT_ELEMENTS,

                                        __PHYSFS_test_sort_cmp,

                                        __PHYSFS_test_sort_swap);

        if (!success)

            break;

    } /* for */

    if (!success)

        printf("Failed!\n");

    else

    {

        for (x = 0, iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

            x += elasped[iter];

        x /= PHYSFS_TEST_SORT_ITERATIONS;

        printf("Average run (%lu) ms.\n", (unsigned long) x);

    } /* else */

    printf("Testing __PHYSFS_sort (randomized) ... ");

    for (iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

    {

        /* set up array to sort. */

        for (i = 0; i < PHYSFS_TEST_SORT_ELEMENTS; i++)

            a[i] = (PHYSFS_uint32) rand();

        /* sort it. */

        success = __PHYSFS_test_sort_do(&elasped[iter],

                                        a, PHYSFS_TEST_SORT_ELEMENTS,

                                        __PHYSFS_test_sort_cmp,

                                        __PHYSFS_test_sort_swap);

        if (!success)

            break;

    } /* for */

    if (!success)

        printf("Failed!\n");

    else

    {

        for (x = 0, iter = 0; iter < PHYSFS_TEST_SORT_ITERATIONS; iter++)

            x += elasped[iter];

        x /= PHYSFS_TEST_SORT_ITERATIONS;

        printf("Average run (%lu) ms.\n", (unsigned long) x);

    } /* else */

    printf("__PHYSFS_test_sort() complete.\n\n");

} /* __PHYSFS_test_sort */

#endif

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

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