/**

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

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <errno.h>

#include <assert.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

typedef struct __PHYSFS_ERRMSGTYPE__

{

    int tid;

    int errorAvailable;

    char errorString[80];

    struct __PHYSFS_ERRMSGTYPE__ *next;

} ErrMsg;

typedef struct __PHYSFS_DIRINFO__

{

    char *dirName;

    DirHandle *dirHandle;

    struct __PHYSFS_DIRINFO__ *next;

} DirInfo;

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 DirInfo *searchPath = NULL;

static DirInfo *writeDir = NULL;

static FileHandleList *openWriteList = NULL;

static FileHandleList *openReadList = NULL;

static char *baseDir = NULL;

static char *userDir = NULL;

static int allowSymLinks = 0;

/* functions ... */

static ErrMsg *findErrorForCurrentThread(void)

{

    ErrMsg *i;

    int tid;

    if (errorMessages != NULL)

    {

        tid = __PHYSFS_platformGetThreadID();

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

        {

            if (i->tid == tid)

                return(i);

        } /* for */

    } /* if */

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

        err->next = errorMessages;

        errorMessages = err;

    } /* if */

    err->errorAvailable = 1;

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

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

} /* __PHYSFS_setError */

static void freeErrorMessages(void)

{

    ErrMsg *i;

    ErrMsg *next;

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

    {

        next = i->next;

        free(i);

    } /* for */

} /* freeErrorMessages */

const char *PHYSFS_getLastError(void)

{

    ErrMsg *err = findErrorForCurrentThread();

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

        return(NULL);

    err->errorAvailable = 0;

    return(err->errorString);

} /* PHYSFS_getLastError */

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 DirInfo *buildDirInfo(const char *newDir, int forWriting)

{

    DirHandle *dirHandle = NULL;

    DirInfo *di = NULL;

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

    dirHandle = openDirectory(newDir, forWriting);

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

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

    if (di == NULL)

        dirHandle->funcs->dirClose(dirHandle);

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

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

    if (di->dirName == NULL)

    {

        free(di);

        dirHandle->funcs->dirClose(dirHandle);

        __PHYSFS_setError(ERR_OUT_OF_MEMORY);

        return(0);

    } /* if */

    di->next = NULL;

    di->dirHandle = dirHandle;

    strcpy(di->dirName, newDir);

    return(di);

} /* buildDirInfo */

static int freeDirInfo(DirInfo *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) * 2) + 6);

        if (retval == NULL)

            __PHYSFS_setError(ERR_OUT_OF_MEMORY);

        else

            sprintf(retval, "%s%susers%s%s", baseDir, dirsep, 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);  /* !!! is this portable? */

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

     */

    return(__PHYSFS_platformCurrentDir());

} /* calculateBaseDir */

int PHYSFS_init(const char *argv0)

{

    char *ptr;

    BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0);

    BAIL_IF_MACRO(argv0 == NULL, ERR_INVALID_ARGUMENT, 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;

    return(1);

} /* PHYSFS_init */

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

static void freeSearchPath(void)

{

    DirInfo *i;

    DirInfo *next = NULL;

    closeFileHandleList(&openReadList);

    if (searchPath != NULL)

    {

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

        {

            next = i->next;

            freeDirInfo(i, openReadList);

        } /* for */

        searchPath = NULL;

    } /* if */

} /* freeSearchPath */

int PHYSFS_deinit(void)

{

    BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0);

    closeFileHandleList(&openWriteList);

    BAIL_IF_MACRO(!PHYSFS_setWriteDir(NULL), ERR_FILES_STILL_OPEN, 0);

    freeSearchPath();

    freeErrorMessages();

    if (baseDir != NULL)

    {

        free(baseDir);

        baseDir = NULL;

    } /* if */

    if (userDir != NULL)

    {

        free(userDir);

        userDir = NULL;

    } /* if */

    allowSymLinks = 0;

    initialized = 0;

    return(1);

} /* PHYSFS_deinit */

const PHYSFS_ArchiveInfo **PHYSFS_supportedArchiveTypes(void)

{

    return(supported_types);

} /* PHYSFS_supportedArchiveTypes */

void PHYSFS_freeList(void *list)

{

    void **i;

    for (i = (void **) list; *i != NULL; i++)

        free(*i);

    free(list);

} /* PHYSFS_freeList */

const char *PHYSFS_getDirSeparator(void)

{

    return(__PHYSFS_platformDirSeparator);

} /* PHYSFS_getDirSeparator */

char **PHYSFS_getCdRomDirs(void)

{

    return(__PHYSFS_platformDetectAvailableCDs());

} /* PHYSFS_getCdRomDirs */

const char *PHYSFS_getBaseDir(void)

{

    return(baseDir);   /* this is calculated in PHYSFS_init()... */

} /* PHYSFS_getBaseDir */

const char *PHYSFS_getUserDir(void)

{

    return(userDir);   /* this is calculated in PHYSFS_init()... */

} /* PHYSFS_getUserDir */

const char *PHYSFS_getWriteDir(void)

{

    if (writeDir == NULL)

        return(NULL);