/**

 * 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

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#include <assert.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

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

    NULL

};

static const DirFunctions *dirFunctions[] =

{

#if (defined PHYSFS_SUPPORTS_ZIP)

    &__PHYSFS_DirFunctions_ZIP,

#endif

#if (defined PHYSFS_SUPPORTS_GRP)

    &__PHYSFS_DirFunctions_GRP,

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

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

{

    const DirFunctions **i;

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

    for (i = dirFunctions; *i != NULL; i++)

    {

        if ((*i)->isArchive(d, forWriting))

            return( (*i)->openArchive(d, forWriting) );

    } /* for */

    __PHYSFS_setError(ERR_UNSUPPORTED_ARCHIVE);

    return(NULL);

} /* openDirectory */

static PhysDirInfo *buildDirInfo(const char *newDir, int forWriting)

{

    DirHandle *dirHandle = NULL;

    PhysDirInfo *di = NULL;

    BAIL_IF_MACRO(newDir == NULL, ERR_INVALID_ARGUMENT, 0);

    dirHandle = openDirectory(newDir, forWriting);

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

    di = (PhysDirInfo *) malloc(sizeof (PhysDirInfo));

    if (di == NULL)

    {

        dirHandle->funcs->dirClose(dirHandle);

        BAIL_IF_MACRO(di == NULL, ERR_OUT_OF_MEMORY, 0);

    } /* if */

    di->dirName = (char *) malloc(strlen(newDir) + 1);

    if (di->dirName == NULL)

    {

        free(di);

        dirHandle->funcs->dirClose(dirHandle);

        BAIL_MACRO(ERR_OUT_OF_MEMORY, 0);

    } /* if */

    di->next = NULL;

    di->dirHandle = dirHandle;

    strcpy(di->dirName, newDir);

    return(di);

} /* buildDirInfo */

/* MAKE SURE you've got the stateLock held before calling this! */

static int freeDirInfo(PhysDirInfo *di, FileHandleList *openList)

{

    FileHandleList *i;

    if (di == NULL)

        return(1);

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

    {

        const DirHandle *h = ((FileHandle *) &(i->handle.opaque))->dirHandle;

        BAIL_IF_MACRO(h == di->dirHandle, ERR_FILES_STILL_OPEN, 0);

    } /* for */

    di->dirHandle->funcs->dirClose(di->dirHandle);

    free(di->dirName);

    free(di);

    return(1);

} /* freeDirInfo */

static char *calculateUserDir(void)

{

    char *retval = NULL;

    const char *str = NULL;

    str = __PHYSFS_platformGetUserDir();

    if (str != NULL)

        retval = (char *) str;

    else

    {

        const char *dirsep = PHYSFS_getDirSeparator();

        const char *uname = __PHYSFS_platformGetUserName();

        str = (uname != NULL) ? uname : "default";

        retval = (char *) malloc(strlen(baseDir) + strlen(str) +

                                 strlen(dirsep) + 6);

        if (retval == NULL)

            __PHYSFS_setError(ERR_OUT_OF_MEMORY);

        else

            sprintf(retval, "%susers%s%s", baseDir, dirsep, str);

        if (uname != NULL)

            free((void *) uname);

    } /* else */

    return(retval);

} /* calculateUserDir */

static int appendDirSep(char **dir)

{

    const char *dirsep = PHYSFS_getDirSeparator();

    char *ptr;

    if (strcmp((*dir + strlen(*dir)) - strlen(dirsep), dirsep) == 0)

        return(1);

    ptr = realloc(*dir, strlen(*dir) + strlen(dirsep) + 1);

    if (!ptr)

    {

        free(*dir);

        return(0);

    } /* if */

    strcat(ptr, dirsep);

    *dir = ptr;

    return(1);

} /* appendDirSep */

static char *calculateBaseDir(const char *argv0)

{

    const char *dirsep = PHYSFS_getDirSeparator();

    char *retval;

    char *ptr;

    /*

     * See if the platform driver wants to handle this for us...

     */

    retval = __PHYSFS_platformCalcBaseDir(argv0);

    if (retval != NULL)

        return(retval);

    /*

     * Determine if there's a path on argv0. If there is, that's the base dir.

     */

    ptr = strstr(argv0, dirsep);

    if (ptr != NULL)

    {

        char *p = ptr;

        size_t size;

        while (p != NULL)

        {

            ptr = p;

            p = strstr(p + 1, dirsep);

        } /* while */

        size = (size_t) (ptr - argv0);

        retval = (char *) malloc(size + 1);

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

        memcpy(retval, argv0, size);

        retval[size] = '\0';

        return(retval);

    } /* if */

    /*

     * Last ditch effort: it's the current working directory. (*shrug*)

     */

    retval = __PHYSFS_platformCurrentDir();

    if(retval != NULL) {

	return(retval);

    }

    /*

     * Ok, current directory doesn't exist, use the root directory.

     * Not a good alternative, but it only happens if the current

     * directory was deleted from under the program.

     */

    retval = (char *) malloc(strlen(dirsep) + 1);

    strcpy(retval, dirsep);

    return(retval);

} /* calculateBaseDir */

static int initializeMutexes(void)

{

    errorLock = __PHYSFS_platformCreateMutex();

    if (errorLock == NULL)

        goto initializeMutexes_failed;

    stateLock = __PHYSFS_platformCreateMutex();

    if (stateLock == NULL)

        goto initializeMutexes_failed;

    return(1);  /* success. */

initializeMutexes_failed:

    if (errorLock != NULL)

        __PHYSFS_platformDestroyMutex(errorLock);

    if (stateLock != NULL)

        __PHYSFS_platformDestroyMutex(stateLock);

    errorLock = stateLock = NULL;

    return(0);  /* failed. */

} /* initializeMutexes */

int PHYSFS_init(const char *argv0)

{

    char *ptr;

    BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0);

    BAIL_IF_MACRO(!__PHYSFS_platformInit(), NULL, 0);

    BAIL_IF_MACRO(!initializeMutexes(), NULL, 0);

    baseDir = calculateBaseDir(argv0);

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

    ptr = __PHYSFS_platformRealPath(baseDir);

    free(baseDir);

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

    baseDir = ptr;

    BAIL_IF_MACRO(!appendDirSep(&baseDir), NULL, 0);

    userDir = calculateUserDir();

    if (userDir != NULL)

    {

        ptr = __PHYSFS_platformRealPath(userDir);

        free(userDir);

        userDir = ptr;

    } /* if */

    if ((userDir == NULL) || (!appendDirSep(&userDir)))

    {

        free(baseDir);

        baseDir = NULL;

        return(0);

    } /* if */

    initialized = 1;

    /* This makes sure that the error subsystem is initialized. */

    __PHYSFS_setError(PHYSFS_getLastError());

    return(1);

} /* PHYSFS_init */

/* MAKE SURE you hold stateLock before calling this! */

static int closeFileHandleList(FileHandleList **list)

{

    FileHandleList *i;

    FileHandleList *next = NULL;

    FileHandle *h;

    for (i = *list; i != NULL; i = next)

    {

        next = i->next;

        h = (FileHandle *) (i->handle.opaque);

        if (!h->funcs->fileClose(h))

        {

            *list = i;

            return(0);

        } /* if */

        free(i);

    } /* for */

    *list = NULL;

    return(1);

} /* closeFileHandleList */

/* MAKE SURE you hold the stateLock before calling this! */

static void freeSearchPath(void)

{

    PhysDirInfo *i;

    PhysDirInfo *next = NULL;

    closeFileHandleList(&openReadList);

    if (searchPath != NULL)

    {

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

        {

            next = i->next;

            freeDirInfo(i, openReadList);

        } /* for */

        searchPath = NULL;