diff options
Diffstat (limited to 'Source/3rdParty/physfs/physfs.c')
| -rw-r--r-- | Source/3rdParty/physfs/physfs.c | 3302 |
1 files changed, 0 insertions, 3302 deletions
diff --git a/Source/3rdParty/physfs/physfs.c b/Source/3rdParty/physfs/physfs.c deleted file mode 100644 index 19148ad..0000000 --- a/Source/3rdParty/physfs/physfs.c +++ /dev/null @@ -1,3302 +0,0 @@ -/** - * 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. - */ - -#define __PHYSICSFS_INTERNAL__ -#include "physfs_internal.h" - -#if defined(_MSC_VER) -#include <stdarg.h> - -/* this code came from https://stackoverflow.com/a/8712996 */ -int __PHYSFS_msvc_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) -{ - int count = -1; - - if (size != 0) - count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); - if (count == -1) - count = _vscprintf(format, ap); - - return count; -} - -int __PHYSFS_msvc_snprintf(char *outBuf, size_t size, const char *format, ...) -{ - int count; - va_list ap; - - va_start(ap, format); - count = __PHYSFS_msvc_vsnprintf(outBuf, size, format, ap); - va_end(ap); - - return count; -} -#endif - - -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! */ - size_t bufsize; /* Bufsize, if set (0 otherwise). Don't touch! */ - size_t buffill; /* Buffer fill size. Don't touch! */ - size_t 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 PHYSFS_Archiver **archivers = NULL; -static 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; - - -#ifdef PHYSFS_NEED_ATOMIC_OP_FALLBACK -static inline int __PHYSFS_atomicAdd(int *ptrval, const int val) -{ - int retval; - __PHYSFS_platformGrabMutex(stateLock); - retval = *ptrval; - *ptrval = retval + val; - __PHYSFS_platformReleaseMutex(stateLock); - return retval; -} /* __PHYSFS_atomicAdd */ - -int __PHYSFS_ATOMIC_INCR(int *ptrval) -{ - return __PHYSFS_atomicAdd(ptrval, 1); -} /* __PHYSFS_ATOMIC_INCR */ - -int __PHYSFS_ATOMIC_DECR(int *ptrval) -{ - return __PHYSFS_atomicAdd(ptrval, -1); -} /* __PHYSFS_ATOMIC_DECR */ -#endif - - - -/* 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) -{ - NativeIoInfo *info = (NativeIoInfo *) io->opaque; - return __PHYSFS_platformFlush(info->handle); -} /* 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(!io, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed); - info = (NativeIoInfo *) allocator.Malloc(sizeof (NativeIoInfo)); - GOTO_IF(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed); - pathdup = (char *) allocator.Malloc(strlen(path) + 1); - GOTO_IF(!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_ERRPASS(!handle, 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; - int 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(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(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(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - newinfo = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo)); - if (!newinfo) - { - allocator.Free(retval); - BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL); - } /* if */ - - __PHYSFS_ATOMIC_INCR(&info->refcount); - - 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; - - 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. */ - - if (__PHYSFS_ATOMIC_DECR(&info->refcount) == 0) - { - 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(!io, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed); - info = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo)); - GOTO_IF(!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(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed); - memset(newfh, '\0', sizeof (*newfh)); - - retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io)); - GOTO_IF(!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(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed); - newfh->bufsize = origfh->bufsize; - } /* if */ -#endif - - newfh->io = origfh->io->duplicate(origfh->io); - GOTO_IF_ERRPASS(!newfh->io, 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(!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++; -} /* 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(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - func(enumStringListCallback, &ecd); - - if (ecd.errcode) - { - PHYSFS_setErrorCode(ecd.errcode); - return NULL; - } /* if */ - - ecd.list[ecd.size] = NULL; - return ecd.list; -} /* doEnumStringList */ - - -static void __PHYSFS_bubble_sort(void *a, size_t lo, size_t hi, - int (*cmpfn)(void *, size_t, size_t), - void (*swapfn)(void *, size_t, size_t)) -{ - size_t 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, size_t lo, size_t hi, - int (*cmpfn)(void *, size_t, size_t), - void (*swapfn)(void *, size_t, size_t)) -{ - size_t i; - size_t j; - size_t 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 */ - if (i != (hi-1)) - 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, size_t max, - int (*cmpfn)(void *, size_t, size_t), - void (*swapfn)(void *, size_t, size_t)) -{ - /* - * Quicksort w/ Bubblesort fallback algorithm inspired by code from here: - * https://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html - */ - if (max > 0) - __PHYSFS_quick_sort(entries, 0, max - 1, cmpfn, swapfn); -} /* __PHYSFS_sort */ - - -static ErrState *findErrorForCurrentThread(void) -{ - ErrState *i; - void *tid; - - if (errorLock != NULL) - __PHYSFS_platformGrabMutex(errorLock); - - if (errorStates != NULL) - { - tid = __PHYSFS_platformGetThreadID(); - - for (i = errorStates; 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 */ - - -/* this doesn't reset the error state. */ -static inline PHYSFS_ErrorCode currentErrorCode(void) -{ - const ErrState *err = findErrorForCurrentThread(); - return err ? err->code : PHYSFS_ERR_OK; -} /* currentErrorCode */ - - -PHYSFS_ErrorCode PHYSFS_getLastErrorCode(void) -{ - ErrState *err = findErrorForCurrentThread(); - const PHYSFS_ErrorCode retval = (err) ? err->code : PHYSFS_ERR_OK; - if (err) - err->code = PHYSFS_ERR_OK; - return retval; -} /* PHYSFS_getLastErrorCode */ - - -PHYSFS_DECL const char *PHYSFS_getErrorByCode(PHYSFS_ErrorCode code) -{ - switch (code) - { - case PHYSFS_ERR_OK: return "no error"; - case PHYSFS_ERR_OTHER_ERROR: return "unknown error"; - case PHYSFS_ERR_OUT_OF_MEMORY: return "out of memory"; - case PHYSFS_ERR_NOT_INITIALIZED: return "not initialized"; - case PHYSFS_ERR_IS_INITIALIZED: return "already initialized"; - case PHYSFS_ERR_ARGV0_IS_NULL: return "argv[0] is NULL"; - case PHYSFS_ERR_UNSUPPORTED: return "unsupported"; - case PHYSFS_ERR_PAST_EOF: return "past end of file"; - case PHYSFS_ERR_FILES_STILL_OPEN: return "files still open"; - case PHYSFS_ERR_INVALID_ARGUMENT: return "invalid argument"; - case PHYSFS_ERR_NOT_MOUNTED: return "not mounted"; - case PHYSFS_ERR_NOT_FOUND: return "not found"; - case PHYSFS_ERR_SYMLINK_FORBIDDEN: return "symlinks are forbidden"; - case PHYSFS_ERR_NO_WRITE_DIR: return "write directory is not set"; - case PHYSFS_ERR_OPEN_FOR_READING: return "file open for reading"; - case PHYSFS_ERR_OPEN_FOR_WRITING: return "file open for writing"; - case PHYSFS_ERR_NOT_A_FILE: return "not a file"; - case PHYSFS_ERR_READ_ONLY: return "read-only filesystem"; - case PHYSFS_ERR_CORRUPT: return "corrupted"; - case PHYSFS_ERR_SYMLINK_LOOP: return "infinite symbolic link loop"; - case PHYSFS_ERR_IO: return "i/o error"; - case PHYSFS_ERR_PERMISSION: return "permission denied"; - case PHYSFS_ERR_NO_SPACE: return "no space available for writing"; - case PHYSFS_ERR_BAD_FILENAME: return "filename is illegal or insecure"; - case PHYSFS_ERR_BUSY: return "tried to modify a file the OS needs"; - case PHYSFS_ERR_DIR_NOT_EMPTY: return "directory isn't empty"; - case PHYSFS_ERR_OS_ERROR: return "OS reported an error"; - case PHYSFS_ERR_DUPLICATE: return "duplicate resource"; - case PHYSFS_ERR_BAD_PASSWORD: return "bad password"; - case PHYSFS_ERR_APP_CALLBACK: return "app callback reported error"; - } /* switch */ - - return NULL; /* don't know this error code. */ -} /* PHYSFS_getErrorByCode */ - - -void PHYSFS_setErrorCode(PHYSFS_ErrorCode errcode) -{ - ErrState *err; - - if (!errcode) - return; - - err = findErrorForCurrentThread(); - if (err == NULL) - { - err = (ErrState *) allocator.Malloc(sizeof (ErrState)); - if (err == NULL) - return; /* uhh...? */ - - memset(err, '\0', sizeof (ErrState)); - err->tid = __PHYSFS_platformGetThreadID(); - - if (errorLock != NULL) - __PHYSFS_platformGrabMutex(errorLock); - - err->next = errorStates; - errorStates = err; - - if (errorLock != NULL) - __PHYSFS_platformReleaseMutex(errorLock); - } /* if */ - - err->code = errcode; -} /* PHYSFS_setErrorCode */ - - -const char *PHYSFS_getLastError(void) -{ - const PHYSFS_ErrorCode err = PHYSFS_getLastErrorCode(); - return (err) ? PHYSFS_getErrorByCode(err) : NULL; -} /* PHYSFS_getLastError */ - - -/* MAKE SURE that errorLock is held before calling this! */ -static void freeErrorStates(void) -{ - ErrState *i; - ErrState *next; - - for (i = errorStates; i != NULL; i = next) - { - next = i->next; - allocator.Free(i); - } /* for */ - - errorStates = NULL; -} /* freeErrorStates */ - - -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 = NULL; - if (fname != NULL) - { - const char *p = strchr(fname, '.'); - retval = p; - - while (p != NULL) - { - p = strchr(p + 1, '.'); - if (p != NULL) - retval = p; - } /* while */ - - if (retval != NULL) - retval++; /* skip '.' */ - } /* if */ - - return retval; -} /* find_filename_extension */ - - -static DirHandle *tryOpenDir(PHYSFS_Io *io, const PHYSFS_Archiver *funcs, - const char *d, int forWriting, int *_claimed) -{ - DirHandle *retval = NULL; - void *opaque = NULL; - - if (io != NULL) - BAIL_IF_ERRPASS(!io->seek(io, 0), NULL); - - opaque = funcs->openArchive(io, d, forWriting, _claimed); - if (opaque != NULL) - { - retval = (DirHandle *) allocator.Malloc(sizeof (DirHandle)); - if (retval == NULL) - funcs->closeArchive(opaque); - else - { - memset(retval, '\0', sizeof (DirHandle)); - retval->mountPoint = NULL; - retval->funcs = funcs; - retval->opaque = opaque; - } /* else */ - } /* if */ - - return retval; -} /* tryOpenDir */ - - -static DirHandle *openDirectory(PHYSFS_Io *io, const char *d, int forWriting) -{ - DirHandle *retval = NULL; - PHYSFS_Archiver **i; - const char *ext; - int created_io = 0; - int claimed = 0; - PHYSFS_ErrorCode errcode; - - assert((io != NULL) || (d != NULL)); - - if (io == NULL) - { - /* DIR gets first shot (unlike the rest, it doesn't deal with files). */ - retval = tryOpenDir(io, &__PHYSFS_Archiver_DIR, d, forWriting, &claimed); - if (retval || claimed) - return retval; - - io = __PHYSFS_createNativeIo(d, forWriting ? 'w' : 'r'); - BAIL_IF_ERRPASS(!io, 0); - created_io = 1; - } /* if */ - - ext = find_filename_extension(d); - if (ext != NULL) - { - /* Look for archivers with matching file extensions first... */ - for (i = archivers; (*i != NULL) && (retval == NULL) && !claimed; i++) - { - if (PHYSFS_utf8stricmp(ext, (*i)->info.extension) == 0) - retval = tryOpenDir(io, *i, d, forWriting, &claimed); - } /* for */ - - /* failing an exact file extension match, try all the others... */ - for (i = archivers; (*i != NULL) && (retval == NULL) && !claimed; i++) - { - if (PHYSFS_utf8stricmp(ext, (*i)->info.extension) != 0) - retval = tryOpenDir(io, *i, d, forWriting, &claimed); - } /* for */ - } /* if */ - - else /* no extension? Try them all. */ - { - for (i = archivers; (*i != NULL) && (retval == NULL) && !claimed; i++) - retval = tryOpenDir(io, *i, d, forWriting, &claimed); - } /* else */ - - errcode = currentErrorCode(); - - if ((!retval) && (created_io)) - io->destroy(io); - - BAIL_IF(!retval, claimed ? errcode : PHYSFS_ERR_UNSUPPORTED, 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++; - - /* Make sure the entire string isn't "." or ".." */ - if ((strcmp(src, ".") == 0) || (strcmp(src, "..") == 0)) - BAIL(PHYSFS_ERR_BAD_FILENAME, 0); - - prev = dst; - do - { - ch = *(src++); - - if ((ch == ':') || (ch == '\\')) /* illegal chars in a physfs path. */ - BAIL(PHYSFS_ERR_BAD_FILENAME, 0); - - if (ch == '/') /* path separator. */ - { - *dst = '\0'; /* "." and ".." are illegal pathnames. */ - if ((strcmp(prev, ".") == 0) || (strcmp(prev, "..") == 0)) - BAIL(PHYSFS_ERR_BAD_FILENAME, 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 */ - - *(dst++) = ch; - } while (ch != '\0'); - - return 1; -} /* sanitizePlatformIndependentPath */ - - -/* - * Figure out if (fname) is part of (h)'s mountpoint. (fname) must be an - * output from sanitizePlatformIndependentPath(), so that it is in a known - * state. - * - * This only finds legitimate segments of a mountpoint. If the mountpoint is - * "/a/b/c" and (fname) is "/a/b/c", "/", or "/a/b/c/d", then the results are - * all zero. "/a/b" will succeed, though. - */ -static int partOfMountPoint(DirHandle *h, char *fname) -{ - int rc; - size_t len, mntpntlen; - - if (h->mountPoint == NULL) - return 0; - else if (*fname == '\0') - return 1; - - len = strlen(fname); - mntpntlen = strlen(h->mountPoint); - if (len > mntpntlen) /* can't be a subset of mountpoint. */ - return 0; - - /* if true, must be not a match or a complete match, but not a subset. */ - if ((len + 1) == mntpntlen) - return 0; - - rc = strncmp(fname, h->mountPoint, len); /* !!! FIXME: case insensitive? */ - if (rc != 0) - return 0; /* not a match. */ - - /* make sure /a/b matches /a/b/ and not /a/bc ... */ - return h->mountPoint[len] == '/'; -} /* partOfMountPoint */ - - -static DirHandle *createDirHandle(PHYSFS_Io *io, const char *newDir, - const char *mountPoint, int forWriting) -{ - DirHandle *dirHandle = NULL; - char *tmpmntpnt = NULL; - - assert(newDir != NULL); /* should have caught this higher up. */ - - if (mountPoint != NULL) - { - const size_t len = strlen(mountPoint) + 1; - tmpmntpnt = (char *) __PHYSFS_smallAlloc(len); - GOTO_IF(!tmpmntpnt, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle); - if (!sanitizePlatformIndependentPath(mountPoint, tmpmntpnt)) - goto badDirHandle; - mountPoint = tmpmntpnt; /* sanitized version. */ - } /* if */ - - dirHandle = openDirectory(io, newDir, forWriting); - GOTO_IF_ERRPASS(!dirHandle, badDirHandle); - - dirHandle->dirName = (char *) allocator.Malloc(strlen(newDir) + 1); - GOTO_IF(!dirHandle->dirName, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle); - strcpy(dirHandle->dirName, newDir); - - if ((mountPoint != NULL) && (*mountPoint != '\0')) - { - dirHandle->mountPoint = (char *)allocator.Malloc(strlen(mountPoint)+2); - if (!dirHandle->mountPoint) - GOTO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle); - strcpy(dirHandle->mountPoint, mountPoint); - strcat(dirHandle->mountPoint, "/"); - } /* if */ - - __PHYSFS_smallFree(tmpmntpnt); - return dirHandle; - -badDirHandle: - if (dirHandle != NULL) - { - dirHandle->funcs->closeArchive(dirHandle->opaque); - allocator.Free(dirHandle->dirName); - allocator.Free(dirHandle->mountPoint); - allocator.Free(dirHandle); - } /* if */ - - __PHYSFS_smallFree(tmpmntpnt); - return NULL; -} /* createDirHandle */ - - -/* MAKE SURE you've got the stateLock held before calling this! */ -static int freeDirHandle(DirHandle *dh, FileHandle *openList) -{ - FileHandle *i; - - if (dh == NULL) - return 1; - - for (i = openList; i != NULL; i = i->next) - BAIL_IF(i->dirHandle == dh, PHYSFS_ERR_FILES_STILL_OPEN, 0); - - dh->funcs->closeArchive(dh->opaque); - allocator.Free(dh->dirName); - allocator.Free(dh->mountPoint); - allocator.Free(dh); - return 1; -} /* freeDirHandle */ - - -static char *calculateBaseDir(const char *argv0) -{ - const char dirsep = __PHYSFS_platformDirSeparator; - char *retval = NULL; - char *ptr = NULL; - - /* Give the platform layer first shot at this. */ - retval = __PHYSFS_platformCalcBaseDir(argv0); - if (retval != NULL) - return retval; - - /* We need argv0 to go on. */ - BAIL_IF(argv0 == NULL, PHYSFS_ERR_ARGV0_IS_NULL, NULL); - - ptr = strrchr(argv0, dirsep); - if (ptr != NULL) - { - const size_t size = ((size_t) (ptr - argv0)) + 1; - retval = (char *) allocator.Malloc(size + 1); - BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - memcpy(retval, argv0, size); - retval[size] = '\0'; - return retval; - } /* if */ - - /* argv0 wasn't helpful. */ - BAIL(PHYSFS_ERR_INVALID_ARGUMENT, NULL); -} /* 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 */ - - -static int doRegisterArchiver(const PHYSFS_Archiver *_archiver); - -static int initStaticArchivers(void) -{ - #define REGISTER_STATIC_ARCHIVER(arc) { \ - if (!doRegisterArchiver(&__PHYSFS_Archiver_##arc)) { \ - return 0; \ - } \ - } - - #if PHYSFS_SUPPORTS_ZIP - REGISTER_STATIC_ARCHIVER(ZIP); - #endif - #if PHYSFS_SUPPORTS_7Z - SZIP_global_init(); - REGISTER_STATIC_ARCHIVER(7Z); - #endif - #if PHYSFS_SUPPORTS_GRP - REGISTER_STATIC_ARCHIVER(GRP); - #endif - #if PHYSFS_SUPPORTS_QPAK - REGISTER_STATIC_ARCHIVER(QPAK); - #endif - #if PHYSFS_SUPPORTS_HOG - REGISTER_STATIC_ARCHIVER(HOG); - #endif - #if PHYSFS_SUPPORTS_MVL - REGISTER_STATIC_ARCHIVER(MVL); - #endif - #if PHYSFS_SUPPORTS_WAD - REGISTER_STATIC_ARCHIVER(WAD); - #endif - #if PHYSFS_SUPPORTS_SLB - REGISTER_STATIC_ARCHIVER(SLB); - #endif - #if PHYSFS_SUPPORTS_ISO9660 - REGISTER_STATIC_ARCHIVER(ISO9660); - #endif - #if PHYSFS_SUPPORTS_VDF - REGISTER_STATIC_ARCHIVER(VDF) - #endif - - #undef REGISTER_STATIC_ARCHIVER - - return 1; -} /* initStaticArchivers */ - - -static void setDefaultAllocator(void); -static int doDeinit(void); - -int PHYSFS_init(const char *argv0) -{ - BAIL_IF(initialized, PHYSFS_ERR_IS_INITIALIZED, 0); - - if (!externalAllocator) - setDefaultAllocator(); - - if ((allocator.Init != NULL) && (!allocator.Init())) return 0; - - if (!__PHYSFS_platformInit()) - { - if (allocator.Deinit != NULL) allocator.Deinit(); - return 0; - } /* if */ - - /* everything below here can be cleaned up safely by doDeinit(). */ - - if (!initializeMutexes()) goto initFailed; - - baseDir = calculateBaseDir(argv0); - if (!baseDir) goto initFailed; - - userDir = __PHYSFS_platformCalcUserDir(); - if (!userDir) goto initFailed; - - /* Platform layer is required to append a dirsep. */ - assert(baseDir[strlen(baseDir) - 1] == __PHYSFS_platformDirSeparator); - assert(userDir[strlen(userDir) - 1] == __PHYSFS_platformDirSeparator); - - if (!initStaticArchivers()) goto initFailed; - - initialized = 1; - - /* This makes sure that the error subsystem is initialized. */ - PHYSFS_setErrorCode(PHYSFS_getLastErrorCode()); - - return 1; - -initFailed: - doDeinit(); - return 0; -} /* PHYSFS_init */ - - -/* MAKE SURE you hold stateLock before calling this! */ -static int closeFileHandleList(FileHandle **list) -{ - FileHandle *i; - FileHandle *next = NULL; - - for (i = *list; i != NULL; i = next) - { - PHYSFS_Io *io = i->io; - next = i->next; - - if (io->flush && !io->flush(io)) - { - *list = i; - return 0; - } /* if */ - - io->destroy(io); - allocator.Free(i); - } /* for */ - - *list = NULL; - return 1; -} /* closeFileHandleList */ - - -/* MAKE SURE you hold the stateLock before calling this! */ -static void freeSearchPath(void) -{ - DirHandle *i; - DirHandle *next = NULL; - - closeFileHandleList(&openReadList); - - if (searchPath != NULL) - { - for (i = searchPath; i != NULL; i = next) - { - next = i->next; - freeDirHandle(i, openReadList); - } /* for */ - searchPath = NULL; - } /* if */ -} /* freeSearchPath */ - - -/* MAKE SURE you hold stateLock before calling this! */ -static int archiverInUse(const PHYSFS_Archiver *arc, const DirHandle *list) -{ - const DirHandle *i; - for (i = list; i != NULL; i = i->next) - { - if (i->funcs == arc) - return 1; - } /* for */ - - return 0; /* not in use */ -} /* archiverInUse */ - - -/* MAKE SURE you hold stateLock before calling this! */ -static int doDeregisterArchiver(const size_t idx) -{ - const size_t len = (numArchivers - idx) * sizeof (void *); - PHYSFS_ArchiveInfo *info = archiveInfo[idx]; - PHYSFS_Archiver *arc = archivers[idx]; - - /* make sure nothing is still using this archiver */ - if (archiverInUse(arc, searchPath) || archiverInUse(arc, writeDir)) - BAIL(PHYSFS_ERR_FILES_STILL_OPEN, 0); - - allocator.Free((void *) info->extension); - allocator.Free((void *) info->description); - allocator.Free((void *) info->author); - allocator.Free((void *) info->url); - allocator.Free((void *) arc); - - memmove(&archiveInfo[idx], &archiveInfo[idx+1], len); - memmove(&archivers[idx], &archivers[idx+1], len); - - assert(numArchivers > 0); - numArchivers--; - - return 1; -} /* doDeregisterArchiver */ - - -/* Does NOT hold the state lock; we're shutting down. */ -static void freeArchivers(void) -{ - while (numArchivers > 0) - { - if (!doDeregisterArchiver(numArchivers - 1)) - assert(!"nothing should be mounted during shutdown."); - } /* while */ - - allocator.Free(archivers); - allocator.Free(archiveInfo); - archivers = NULL; - archiveInfo = NULL; -} /* freeArchivers */ - - -static int doDeinit(void) -{ - closeFileHandleList(&openWriteList); - BAIL_IF(!PHYSFS_setWriteDir(NULL), PHYSFS_ERR_FILES_STILL_OPEN, 0); - - freeSearchPath(); - freeArchivers(); - freeErrorStates(); - - if (baseDir != NULL) - { - allocator.Free(baseDir); - baseDir = NULL; - } /* if */ - - if (userDir != NULL) - { - allocator.Free(userDir); - userDir = NULL; - } /* if */ - - if (prefDir != NULL) - { - allocator.Free(prefDir); - prefDir = NULL; - } /* if */ - - if (archiveInfo != NULL) - { - allocator.Free(archiveInfo); - archiveInfo = NULL; - } /* if */ - - if (archivers != NULL) - { - allocator.Free(archivers); - archivers = NULL; - } /* if */ - - allowSymLinks = 0; - initialized = 0; - - if (errorLock) __PHYSFS_platformDestroyMutex(errorLock); - if (stateLock) __PHYSFS_platformDestroyMutex(stateLock); - - if (allocator.Deinit != NULL) - allocator.Deinit(); - - errorLock = stateLock = NULL; - - __PHYSFS_platformDeinit(); - - return 1; -} /* doDeinit */ - - -int PHYSFS_deinit(void) -{ - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0); - return doDeinit(); -} /* PHYSFS_deinit */ - - -int PHYSFS_isInit(void) -{ - return initialized; -} /* PHYSFS_isInit */ - - -char *__PHYSFS_strdup(const char *str) -{ - char *retval = (char *) allocator.Malloc(strlen(str) + 1); - if (retval) - strcpy(retval, str); - return retval; -} /* __PHYSFS_strdup */ - - -PHYSFS_uint32 __PHYSFS_hashString(const char *str, size_t len) -{ - PHYSFS_uint32 hash = 5381; - while (len--) - hash = ((hash << 5) + hash) ^ *(str++); - return hash; -} /* __PHYSFS_hashString */ - - -/* MAKE SURE you hold stateLock before calling this! */ -static int doRegisterArchiver(const PHYSFS_Archiver *_archiver) -{ - const PHYSFS_uint32 maxver = CURRENT_PHYSFS_ARCHIVER_API_VERSION; - const size_t len = (numArchivers + 2) * sizeof (void *); - PHYSFS_Archiver *archiver = NULL; - PHYSFS_ArchiveInfo *info = NULL; - const char *ext = NULL; - void *ptr = NULL; - size_t i; - - BAIL_IF(!_archiver, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(_archiver->version > maxver, PHYSFS_ERR_UNSUPPORTED, 0); - BAIL_IF(!_archiver->info.extension, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->info.description, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->info.author, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->info.url, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->openArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->enumerate, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->openRead, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->openWrite, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->openAppend, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->remove, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->mkdir, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->closeArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!_archiver->stat, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - ext = _archiver->info.extension; - for (i = 0; i < numArchivers; i++) - { - if (PHYSFS_utf8stricmp(archiveInfo[i]->extension, ext) == 0) - BAIL(PHYSFS_ERR_DUPLICATE, 0); - } /* for */ - - /* make a copy of the data. */ - archiver = (PHYSFS_Archiver *) allocator.Malloc(sizeof (*archiver)); - GOTO_IF(!archiver, PHYSFS_ERR_OUT_OF_MEMORY, regfailed); - - /* Must copy sizeof (OLD_VERSION_OF_STRUCT) when version changes! */ - memcpy(archiver, _archiver, sizeof (*archiver)); - - info = (PHYSFS_ArchiveInfo *) &archiver->info; - memset(info, '\0', sizeof (*info)); /* NULL in case an alloc fails. */ - #define CPYSTR(item) \ - info->item = __PHYSFS_strdup(_archiver->info.item); \ - GOTO_IF(!info->item, PHYSFS_ERR_OUT_OF_MEMORY, regfailed); - CPYSTR(extension); - CPYSTR(description); - CPYSTR(author); - CPYSTR(url); - info->supportsSymlinks = _archiver->info.supportsSymlinks; - #undef CPYSTR - - ptr = allocator.Realloc(archiveInfo, len); - GOTO_IF(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed); - archiveInfo = (PHYSFS_ArchiveInfo **) ptr; - - ptr = allocator.Realloc(archivers, len); - GOTO_IF(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed); - archivers = (PHYSFS_Archiver **) ptr; - - archiveInfo[numArchivers] = info; - archiveInfo[numArchivers + 1] = NULL; - - archivers[numArchivers] = archiver; - archivers[numArchivers + 1] = NULL; - - numArchivers++; - - return 1; - -regfailed: - if (info != NULL) - { - allocator.Free((void *) info->extension); - allocator.Free((void *) info->description); - allocator.Free((void *) info->author); - allocator.Free((void *) info->url); - } /* if */ - allocator.Free(archiver); - - return 0; -} /* doRegisterArchiver */ - - -int PHYSFS_registerArchiver(const PHYSFS_Archiver *archiver) -{ - int retval; - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0); - __PHYSFS_platformGrabMutex(stateLock); - retval = doRegisterArchiver(archiver); - __PHYSFS_platformReleaseMutex(stateLock); - return retval; -} /* PHYSFS_registerArchiver */ - - -int PHYSFS_deregisterArchiver(const char *ext) -{ - size_t i; - - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0); - BAIL_IF(!ext, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - __PHYSFS_platformGrabMutex(stateLock); - for (i = 0; i < numArchivers; i++) - { - if (PHYSFS_utf8stricmp(archiveInfo[i]->extension, ext) == 0) - { - const int retval = doDeregisterArchiver(i); - __PHYSFS_platformReleaseMutex(stateLock); - return retval; - } /* if */ - } /* for */ - __PHYSFS_platformReleaseMutex(stateLock); - - BAIL(PHYSFS_ERR_NOT_FOUND, 0); -} /* PHYSFS_deregisterArchiver */ - - -const PHYSFS_ArchiveInfo **PHYSFS_supportedArchiveTypes(void) -{ - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL); - return (const PHYSFS_ArchiveInfo **) archiveInfo; -} /* PHYSFS_supportedArchiveTypes */ - - -void PHYSFS_freeList(void *list) -{ - void **i; - if (list != NULL) - { - for (i = (void **) list; *i != NULL; i++) - allocator.Free(*i); - - allocator.Free(list); - } /* if */ -} /* PHYSFS_freeList */ - - -const char *PHYSFS_getDirSeparator(void) -{ - static char retval[2] = { __PHYSFS_platformDirSeparator, '\0' }; - return retval; -} /* PHYSFS_getDirSeparator */ - - -char **PHYSFS_getCdRomDirs(void) -{ - return doEnumStringList(__PHYSFS_platformDetectAvailableCDs); -} /* PHYSFS_getCdRomDirs */ - - -void PHYSFS_getCdRomDirsCallback(PHYSFS_StringCallback callback, void *data) -{ - __PHYSFS_platformDetectAvailableCDs(callback, data); -} /* PHYSFS_getCdRomDirsCallback */ - - -const char *PHYSFS_getPrefDir(const char *org, const char *app) -{ - const char dirsep = __PHYSFS_platformDirSeparator; - PHYSFS_Stat statbuf; - char *ptr = NULL; - char *endstr = NULL; - - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0); - BAIL_IF(!org, PHYSFS_ERR_INVALID_ARGUMENT, NULL); - BAIL_IF(*org == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL); - BAIL_IF(!app, PHYSFS_ERR_INVALID_ARGUMENT, NULL); - BAIL_IF(*app == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL); - - allocator.Free(prefDir); - prefDir = __PHYSFS_platformCalcPrefDir(org, app); - BAIL_IF_ERRPASS(!prefDir, NULL); - - assert(strlen(prefDir) > 0); - endstr = prefDir + (strlen(prefDir) - 1); - assert(*endstr == dirsep); - *endstr = '\0'; /* mask out the final dirsep for now. */ - - if (!__PHYSFS_platformStat(prefDir, &statbuf, 1)) - { - for (ptr = strchr(prefDir, dirsep); ptr; ptr = strchr(ptr+1, dirsep)) - { - *ptr = '\0'; - __PHYSFS_platformMkDir(prefDir); - *ptr = dirsep; - } /* for */ - - if (!__PHYSFS_platformMkDir(prefDir)) - { - allocator.Free(prefDir); - prefDir = NULL; - } /* if */ - } /* if */ - - *endstr = dirsep; /* readd the final dirsep. */ - - return prefDir; -} /* PHYSFS_getPrefDir */ - - -const char *PHYSFS_getBaseDir(void) -{ - return baseDir; /* this is calculated in PHYSFS_init()... */ -} /* PHYSFS_getBaseDir */ - - -const char *__PHYSFS_getUserDir(void) /* not deprecated internal version. */ -{ - return userDir; /* this is calculated in PHYSFS_init()... */ -} /* __PHYSFS_getUserDir */ - - -const char *PHYSFS_getUserDir(void) -{ - return __PHYSFS_getUserDir(); -} /* PHYSFS_getUserDir */ - - -const char *PHYSFS_getWriteDir(void) -{ - const char *retval = NULL; - - __PHYSFS_platformGrabMutex(stateLock); - if (writeDir != NULL) - retval = writeDir->dirName; - __PHYSFS_platformReleaseMutex(stateLock); - - return retval; -} /* PHYSFS_getWriteDir */ - - -int PHYSFS_setWriteDir(const char *newDir) -{ - int retval = 1; - - __PHYSFS_platformGrabMutex(stateLock); - - if (writeDir != NULL) - { - BAIL_IF_MUTEX_ERRPASS(!freeDirHandle(writeDir, openWriteList), - stateLock, 0); - writeDir = NULL; - } /* if */ - - if (newDir != NULL) - { - writeDir = createDirHandle(NULL, newDir, NULL, 1); - retval = (writeDir != NULL); - } /* if */ - - __PHYSFS_platformReleaseMutex(stateLock); - - return retval; -} /* PHYSFS_setWriteDir */ - - -static int doMount(PHYSFS_Io *io, const char *fname, - const char *mountPoint, int appendToPath) -{ - DirHandle *dh; - DirHandle *prev = NULL; - DirHandle *i; - - BAIL_IF(!fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - if (mountPoint == NULL) - mountPoint = "/"; - - __PHYSFS_platformGrabMutex(stateLock); - - for (i = searchPath; i != NULL; i = i->next) - { - /* already in search path? */ - if ((i->dirName != NULL) && (strcmp(fname, i->dirName) == 0)) - BAIL_MUTEX_ERRPASS(stateLock, 1); - prev = i; - } /* for */ - - dh = createDirHandle(io, fname, mountPoint, 0); - BAIL_IF_MUTEX_ERRPASS(!dh, stateLock, 0); - - if (appendToPath) - { - if (prev == NULL) - searchPath = dh; - else - prev->next = dh; - } /* if */ - else - { - dh->next = searchPath; - searchPath = dh; - } /* else */ - - __PHYSFS_platformReleaseMutex(stateLock); - return 1; -} /* doMount */ - - -int PHYSFS_mountIo(PHYSFS_Io *io, const char *fname, - const char *mountPoint, int appendToPath) -{ - BAIL_IF(!io, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(io->version != 0, PHYSFS_ERR_UNSUPPORTED, 0); - return doMount(io, fname, mountPoint, appendToPath); -} /* PHYSFS_mountIo */ - - -int PHYSFS_mountMemory(const void *buf, PHYSFS_uint64 len, void (*del)(void *), - const char *fname, const char *mountPoint, - int appendToPath) -{ - int retval = 0; - PHYSFS_Io *io = NULL; - - BAIL_IF(!buf, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - io = __PHYSFS_createMemoryIo(buf, len, del); - BAIL_IF_ERRPASS(!io, 0); - retval = doMount(io, fname, mountPoint, appendToPath); - if (!retval) - { - /* docs say not to call (del) in case of failure, so cheat. */ - MemoryIoInfo *info = (MemoryIoInfo *) io->opaque; - info->destruct = NULL; - io->destroy(io); - } /* if */ - - return retval; -} /* PHYSFS_mountMemory */ - - -int PHYSFS_mountHandle(PHYSFS_File *file, const char *fname, - const char *mountPoint, int appendToPath) -{ - int retval = 0; - PHYSFS_Io *io = NULL; - - BAIL_IF(!file, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - io = __PHYSFS_createHandleIo(file); - BAIL_IF_ERRPASS(!io, 0); - retval = doMount(io, fname, mountPoint, appendToPath); - if (!retval) - { - /* docs say not to destruct in case of failure, so cheat. */ - io->opaque = NULL; - io->destroy(io); - } /* if */ - - return retval; -} /* PHYSFS_mountHandle */ - - -int PHYSFS_mount(const char *newDir, const char *mountPoint, int appendToPath) -{ - BAIL_IF(!newDir, PHYSFS_ERR_INVALID_ARGUMENT, 0); - return doMount(NULL, newDir, mountPoint, appendToPath); -} /* PHYSFS_mount */ - - -int PHYSFS_addToSearchPath(const char *newDir, int appendToPath) -{ - return PHYSFS_mount(newDir, NULL, appendToPath); -} /* PHYSFS_addToSearchPath */ - - -int PHYSFS_removeFromSearchPath(const char *oldDir) -{ - return PHYSFS_unmount(oldDir); -} /* PHYSFS_removeFromSearchPath */ - - -int PHYSFS_unmount(const char *oldDir) -{ - DirHandle *i; - DirHandle *prev = NULL; - DirHandle *next = NULL; - - BAIL_IF(oldDir == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - __PHYSFS_platformGrabMutex(stateLock); - for (i = searchPath; i != NULL; i = i->next) - { - if (strcmp(i->dirName, oldDir) == 0) - { - next = i->next; - BAIL_IF_MUTEX_ERRPASS(!freeDirHandle(i, openReadList), - stateLock, 0); - - if (prev == NULL) - searchPath = next; - else - prev->next = next; - - BAIL_MUTEX_ERRPASS(stateLock, 1); - } /* if */ - prev = i; - } /* for */ - - BAIL_MUTEX(PHYSFS_ERR_NOT_MOUNTED, stateLock, 0); -} /* PHYSFS_unmount */ - - -char **PHYSFS_getSearchPath(void) -{ - return doEnumStringList(PHYSFS_getSearchPathCallback); -} /* PHYSFS_getSearchPath */ - - -const char *PHYSFS_getMountPoint(const char *dir) -{ - DirHandle *i; - __PHYSFS_platformGrabMutex(stateLock); - for (i = searchPath; i != NULL; i = i->next) - { - if (strcmp(i->dirName, dir) == 0) - { - const char *retval = ((i->mountPoint) ? i->mountPoint : "/"); - __PHYSFS_platformReleaseMutex(stateLock); - return retval; - } /* if */ - } /* for */ - __PHYSFS_platformReleaseMutex(stateLock); - - BAIL(PHYSFS_ERR_NOT_MOUNTED, NULL); -} /* PHYSFS_getMountPoint */ - - -void PHYSFS_getSearchPathCallback(PHYSFS_StringCallback callback, void *data) -{ - DirHandle *i; - - __PHYSFS_platformGrabMutex(stateLock); - - for (i = searchPath; i != NULL; i = i->next) - callback(data, i->dirName); - - __PHYSFS_platformReleaseMutex(stateLock); -} /* PHYSFS_getSearchPathCallback */ - - -typedef struct setSaneCfgEnumData -{ - const char *archiveExt; - size_t archiveExtLen; - int archivesFirst; - PHYSFS_ErrorCode errcode; -} setSaneCfgEnumData; - -static PHYSFS_EnumerateCallbackResult setSaneCfgEnumCallback(void *_data, - const char *dir, const char *f) -{ - setSaneCfgEnumData *data = (setSaneCfgEnumData *) _data; - const size_t extlen = data->archiveExtLen; - const size_t l = strlen(f); - const char *ext; - - if ((l > extlen) && (f[l - extlen - 1] == '.')) - { - ext = f + (l - extlen); - if (PHYSFS_utf8stricmp(ext, data->archiveExt) == 0) - { - const char dirsep = __PHYSFS_platformDirSeparator; - const char *d = PHYSFS_getRealDir(f); - const size_t allocsize = strlen(d) + l + 2; - char *str = (char *) __PHYSFS_smallAlloc(allocsize); - if (str == NULL) - data->errcode = PHYSFS_ERR_OUT_OF_MEMORY; - else - { - snprintf(str, allocsize, "%s%c%s", d, dirsep, f); - if (!PHYSFS_mount(str, NULL, data->archivesFirst == 0)) - data->errcode = currentErrorCode(); - __PHYSFS_smallFree(str); - } /* else */ - } /* if */ - } /* if */ - - /* !!! FIXME: if we want to abort on errors... */ - /*return (data->errcode != PHYSFS_ERR_OK) ? PHYSFS_ENUM_ERROR : PHYSFS_ENUM_OK;*/ - - return PHYSFS_ENUM_OK; /* keep going */ -} /* setSaneCfgEnumCallback */ - - -int PHYSFS_setSaneConfig(const char *organization, const char *appName, - const char *archiveExt, int includeCdRoms, - int archivesFirst) -{ - const char *basedir; - const char *prefdir; - - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0); - - prefdir = PHYSFS_getPrefDir(organization, appName); - BAIL_IF_ERRPASS(!prefdir, 0); - - basedir = PHYSFS_getBaseDir(); - BAIL_IF_ERRPASS(!basedir, 0); - - BAIL_IF(!PHYSFS_setWriteDir(prefdir), PHYSFS_ERR_NO_WRITE_DIR, 0); - - /* !!! FIXME: these can fail and we should report that... */ - - /* Put write dir first in search path... */ - PHYSFS_mount(prefdir, NULL, 0); - - /* Put base path on search path... */ - PHYSFS_mount(basedir, NULL, 1); - - /* handle CD-ROMs... */ - if (includeCdRoms) - { - char **cds = PHYSFS_getCdRomDirs(); - char **i; - for (i = cds; *i != NULL; i++) - PHYSFS_mount(*i, NULL, 1); - PHYSFS_freeList(cds); - } /* if */ - - /* Root out archives, and add them to search path... */ - if (archiveExt != NULL) - { - setSaneCfgEnumData data; - memset(&data, '\0', sizeof (data)); - data.archiveExt = archiveExt; - data.archiveExtLen = strlen(archiveExt); - data.archivesFirst = archivesFirst; - data.errcode = PHYSFS_ERR_OK; - if (!PHYSFS_enumerate("/", setSaneCfgEnumCallback, &data)) - { - /* !!! FIXME: use this if we're reporting errors. - PHYSFS_ErrorCode errcode = currentErrorCode(); - if (errcode == PHYSFS_ERR_APP_CALLBACK) - errcode = data->errcode; */ - } /* if */ - } /* if */ - - return 1; -} /* PHYSFS_setSaneConfig */ - - -void PHYSFS_permitSymbolicLinks(int allow) -{ - allowSymLinks = allow; -} /* PHYSFS_permitSymbolicLinks */ - - -int PHYSFS_symbolicLinksPermitted(void) -{ - return allowSymLinks; -} /* PHYSFS_symbolicLinksPermitted */ - - -/* - * Verify that (fname) (in platform-independent notation), in relation - * to (h) is secure. That means that each element of fname is checked - * for symlinks (if they aren't permitted). This also allows for quick - * rejection of files that exist outside an archive's mountpoint. - * - * With some exceptions (like PHYSFS_mkdir(), which builds multiple subdirs - * at a time), you should always pass zero for "allowMissing" for efficiency. - * - * (fname) must point to an output from sanitizePlatformIndependentPath(), - * since it will make sure that path names are in the right format for - * passing certain checks. It will also do checks for "insecure" pathnames - * like ".." which should be done once instead of once per archive. This also - * gives us license to treat (fname) as scratch space in this function. - * - * Returns non-zero if string is safe, zero if there's a security issue. - * PHYSFS_getLastError() will specify what was wrong. (*fname) will be - * updated to point past any mount point elements so it is prepared to - * be used with the archiver directly. - */ -static int verifyPath(DirHandle *h, char **_fname, int allowMissing) -{ - char *fname = *_fname; - int retval = 1; - char *start; - char *end; - - if (*fname == '\0') /* quick rejection. */ - return 1; - - /* !!! FIXME: This codeblock sucks. */ - if (h->mountPoint != NULL) /* NULL mountpoint means "/". */ - { - size_t mntpntlen = strlen(h->mountPoint); - size_t len = strlen(fname); - assert(mntpntlen > 1); /* root mount points should be NULL. */ - /* not under the mountpoint, so skip this archive. */ - BAIL_IF(len < mntpntlen-1, PHYSFS_ERR_NOT_FOUND, 0); - /* !!! FIXME: Case insensitive? */ - retval = strncmp(h->mountPoint, fname, mntpntlen-1); - BAIL_IF(retval != 0, PHYSFS_ERR_NOT_FOUND, 0); - if (len > mntpntlen-1) /* corner case... */ - BAIL_IF(fname[mntpntlen-1]!='/', PHYSFS_ERR_NOT_FOUND, 0); - fname += mntpntlen-1; /* move to start of actual archive path. */ - if (*fname == '/') - fname++; - *_fname = fname; /* skip mountpoint for later use. */ - retval = 1; /* may be reset, below. */ - } /* if */ - - start = fname; - if (!allowSymLinks) - { - while (1) - { - PHYSFS_Stat statbuf; - int rc = 0; - end = strchr(start, '/'); - - if (end != NULL) *end = '\0'; - rc = h->funcs->stat(h->opaque, fname, &statbuf); - if (rc) - rc = (statbuf.filetype == PHYSFS_FILETYPE_SYMLINK); - else if (currentErrorCode() == PHYSFS_ERR_NOT_FOUND) - retval = 0; - - if (end != NULL) *end = '/'; - - /* insecure path (has a disallowed symlink in it)? */ - BAIL_IF(rc, PHYSFS_ERR_SYMLINK_FORBIDDEN, 0); - - /* break out early if path element is missing. */ - if (!retval) - { - /* - * We need to clear it if it's the last element of the path, - * since this might be a non-existant file we're opening - * for writing... - */ - if ((end == NULL) || (allowMissing)) - retval = 1; - break; - } /* if */ - - if (end == NULL) - break; - - start = end + 1; - } /* while */ - } /* if */ - - return retval; -} /* verifyPath */ - - -static int doMkdir(const char *_dname, char *dname) -{ - DirHandle *h; - char *start; - char *end; - int retval = 0; - int exists = 1; /* force existance check on first path element. */ - - BAIL_IF_ERRPASS(!sanitizePlatformIndependentPath(_dname, dname), 0); - - __PHYSFS_platformGrabMutex(stateLock); - BAIL_IF_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0); - h = writeDir; - BAIL_IF_MUTEX_ERRPASS(!verifyPath(h, &dname, 1), stateLock, 0); - - start = dname; - while (1) - { - end = strchr(start, '/'); - if (end != NULL) - *end = '\0'; - - /* only check for existance if all parent dirs existed, too... */ - if (exists) - { - PHYSFS_Stat statbuf; - const int rc = h->funcs->stat(h->opaque, dname, &statbuf); - if ((!rc) && (currentErrorCode() == PHYSFS_ERR_NOT_FOUND)) - exists = 0; - retval = ((rc) && (statbuf.filetype == PHYSFS_FILETYPE_DIRECTORY)); - } /* if */ - - if (!exists) - retval = h->funcs->mkdir(h->opaque, dname); - - if (!retval) - break; - - if (end == NULL) - break; - - *end = '/'; - start = end + 1; - } /* while */ - - __PHYSFS_platformReleaseMutex(stateLock); - return retval; -} /* doMkdir */ - - -int PHYSFS_mkdir(const char *_dname) -{ - int retval = 0; - char *dname; - size_t len; - - BAIL_IF(!_dname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - len = strlen(_dname) + 1; - dname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!dname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - retval = doMkdir(_dname, dname); - __PHYSFS_smallFree(dname); - return retval; -} /* PHYSFS_mkdir */ - - -static int doDelete(const char *_fname, char *fname) -{ - int retval; - DirHandle *h; - BAIL_IF_ERRPASS(!sanitizePlatformIndependentPath(_fname, fname), 0); - - __PHYSFS_platformGrabMutex(stateLock); - - BAIL_IF_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0); - h = writeDir; - BAIL_IF_MUTEX_ERRPASS(!verifyPath(h, &fname, 0), stateLock, 0); - retval = h->funcs->remove(h->opaque, fname); - - __PHYSFS_platformReleaseMutex(stateLock); - return retval; -} /* doDelete */ - - -int PHYSFS_delete(const char *_fname) -{ - int retval; - char *fname; - size_t len; - - BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - len = strlen(_fname) + 1; - fname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - retval = doDelete(_fname, fname); - __PHYSFS_smallFree(fname); - return retval; -} /* PHYSFS_delete */ - - -static DirHandle *getRealDirHandle(const char *_fname) -{ - DirHandle *retval = NULL; - char *fname = NULL; - size_t len; - - BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, NULL); - len = strlen(_fname) + 1; - fname = __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - if (sanitizePlatformIndependentPath(_fname, fname)) - { - DirHandle *i; - __PHYSFS_platformGrabMutex(stateLock); - for (i = searchPath; i != NULL; i = i->next) - { - char *arcfname = fname; - if (partOfMountPoint(i, arcfname)) - { - retval = i; - break; - } /* if */ - else if (verifyPath(i, &arcfname, 0)) - { - PHYSFS_Stat statbuf; - if (i->funcs->stat(i->opaque, arcfname, &statbuf)) - { - retval = i; - break; - } /* if */ - } /* if */ - } /* for */ - __PHYSFS_platformReleaseMutex(stateLock); - } /* if */ - - __PHYSFS_smallFree(fname); - return retval; -} /* getRealDirHandle */ - -const char *PHYSFS_getRealDir(const char *fname) -{ - DirHandle *dh = getRealDirHandle(fname); - return dh ? dh->dirName : NULL; -} /* PHYSFS_getRealDir */ - - -static int locateInStringList(const char *str, - char **list, - PHYSFS_uint32 *pos) -{ - PHYSFS_uint32 len = *pos; - PHYSFS_uint32 half_len; - PHYSFS_uint32 lo = 0; - PHYSFS_uint32 middle; - int cmp; - - while (len > 0) - { - half_len = len >> 1; - middle = lo + half_len; - cmp = strcmp(list[middle], str); - - if (cmp == 0) /* it's in the list already. */ - return 1; - else if (cmp > 0) - len = half_len; - else - { - lo = middle + 1; - len -= half_len + 1; - } /* else */ - } /* while */ - - *pos = lo; - return 0; -} /* locateInStringList */ - - -static PHYSFS_EnumerateCallbackResult enumFilesCallback(void *data, - const char *origdir, const char *str) -{ - PHYSFS_uint32 pos; - void *ptr; - char *newstr; - EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data; - - /* - * See if file is in the list already, and if not, insert it in there - * alphabetically... - */ - pos = pecd->size; - if (locateInStringList(str, pecd->list, &pos)) - return PHYSFS_ENUM_OK; /* already in the list, but keep going. */ - - 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)) - { - if (newstr) - allocator.Free(newstr); - - pecd->errcode = PHYSFS_ERR_OUT_OF_MEMORY; - return PHYSFS_ENUM_ERROR; /* better luck next time. */ - } /* if */ - - strcpy(newstr, str); - - if (pos != pecd->size) - { - memmove(&pecd->list[pos+1], &pecd->list[pos], - sizeof (char *) * ((pecd->size) - pos)); - } /* if */ - - pecd->list[pos] = newstr; - pecd->size++; - - return PHYSFS_ENUM_OK; -} /* enumFilesCallback */ - - -char **PHYSFS_enumerateFiles(const char *path) -{ - EnumStringListCallbackData ecd; - memset(&ecd, '\0', sizeof (ecd)); - ecd.list = (char **) allocator.Malloc(sizeof (char *)); - BAIL_IF(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - if (!PHYSFS_enumerate(path, enumFilesCallback, &ecd)) - { - const PHYSFS_ErrorCode errcode = currentErrorCode(); - PHYSFS_uint32 i; - for (i = 0; i < ecd.size; i++) - allocator.Free(ecd.list[i]); - allocator.Free(ecd.list); - BAIL_IF(errcode == PHYSFS_ERR_APP_CALLBACK, ecd.errcode, NULL); - return NULL; - } /* if */ - - ecd.list[ecd.size] = NULL; - return ecd.list; -} /* PHYSFS_enumerateFiles */ - - -/* - * Broke out to seperate function so we can use stack allocation gratuitously. - */ -static PHYSFS_EnumerateCallbackResult enumerateFromMountPoint(DirHandle *i, - const char *arcfname, - PHYSFS_EnumerateCallback callback, - const char *_fname, void *data) -{ - PHYSFS_EnumerateCallbackResult retval; - const size_t len = strlen(arcfname); - char *ptr = NULL; - char *end = NULL; - const size_t slen = strlen(i->mountPoint) + 1; - char *mountPoint = (char *) __PHYSFS_smallAlloc(slen); - - BAIL_IF(!mountPoint, PHYSFS_ERR_OUT_OF_MEMORY, PHYSFS_ENUM_ERROR); - - strcpy(mountPoint, i->mountPoint); - ptr = mountPoint + ((len) ? len + 1 : 0); - end = strchr(ptr, '/'); - assert(end); /* should always find a terminating '/'. */ - *end = '\0'; - retval = callback(data, _fname, ptr); - __PHYSFS_smallFree(mountPoint); - - BAIL_IF(retval == PHYSFS_ENUM_ERROR, PHYSFS_ERR_APP_CALLBACK, retval); - return retval; -} /* enumerateFromMountPoint */ - - -typedef struct SymlinkFilterData -{ - PHYSFS_EnumerateCallback callback; - void *callbackData; - DirHandle *dirhandle; - const char *arcfname; - PHYSFS_ErrorCode errcode; -} SymlinkFilterData; - -static PHYSFS_EnumerateCallbackResult enumCallbackFilterSymLinks(void *_data, - const char *origdir, const char *fname) -{ - SymlinkFilterData *data = (SymlinkFilterData *) _data; - const DirHandle *dh = data->dirhandle; - const char *arcfname = data->arcfname; - PHYSFS_Stat statbuf; - const char *trimmedDir = (*arcfname == '/') ? (arcfname + 1) : arcfname; - const size_t slen = strlen(trimmedDir) + strlen(fname) + 2; - char *path = (char *) __PHYSFS_smallAlloc(slen); - PHYSFS_EnumerateCallbackResult retval = PHYSFS_ENUM_OK; - - if (path == NULL) - { - data->errcode = PHYSFS_ERR_OUT_OF_MEMORY; - return PHYSFS_ENUM_ERROR; - } /* if */ - - snprintf(path, slen, "%s%s%s", trimmedDir, *trimmedDir ? "/" : "", fname); - - if (!dh->funcs->stat(dh->opaque, path, &statbuf)) - { - data->errcode = currentErrorCode(); - retval = PHYSFS_ENUM_ERROR; - } /* if */ - else - { - /* Pass it on to the application if it's not a symlink. */ - if (statbuf.filetype != PHYSFS_FILETYPE_SYMLINK) - { - retval = data->callback(data->callbackData, origdir, fname); - if (retval == PHYSFS_ENUM_ERROR) - data->errcode = PHYSFS_ERR_APP_CALLBACK; - } /* if */ - } /* else */ - - __PHYSFS_smallFree(path); - - return retval; -} /* enumCallbackFilterSymLinks */ - - -int PHYSFS_enumerate(const char *_fn, PHYSFS_EnumerateCallback cb, void *data) -{ - PHYSFS_EnumerateCallbackResult retval = PHYSFS_ENUM_OK; - size_t len; - char *fname; - - BAIL_IF(!_fn, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!cb, PHYSFS_ERR_INVALID_ARGUMENT, 0); - - len = strlen(_fn) + 1; - fname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - - if (!sanitizePlatformIndependentPath(_fn, fname)) - retval = PHYSFS_ENUM_STOP; - else - { - DirHandle *i; - SymlinkFilterData filterdata; - - __PHYSFS_platformGrabMutex(stateLock); - - if (!allowSymLinks) - { - memset(&filterdata, '\0', sizeof (filterdata)); - filterdata.callback = cb; - filterdata.callbackData = data; - } /* if */ - - for (i = searchPath; (retval == PHYSFS_ENUM_OK) && i; i = i->next) - { - char *arcfname = fname; - - if (partOfMountPoint(i, arcfname)) - retval = enumerateFromMountPoint(i, arcfname, cb, _fn, data); - - else if (verifyPath(i, &arcfname, 0)) - { - PHYSFS_Stat statbuf; - if (!i->funcs->stat(i->opaque, arcfname, &statbuf)) - { - if (currentErrorCode() == PHYSFS_ERR_NOT_FOUND) - continue; /* no such dir in this archive, skip it. */ - } /* if */ - - if (statbuf.filetype != PHYSFS_FILETYPE_DIRECTORY) - continue; /* not a directory in this archive, skip it. */ - - else if ((!allowSymLinks) && (i->funcs->info.supportsSymlinks)) - { - filterdata.dirhandle = i; - filterdata.arcfname = arcfname; - filterdata.errcode = PHYSFS_ERR_OK; - retval = i->funcs->enumerate(i->opaque, arcfname, - enumCallbackFilterSymLinks, - _fn, &filterdata); - if (retval == PHYSFS_ENUM_ERROR) - { - if (currentErrorCode() == PHYSFS_ERR_APP_CALLBACK) - PHYSFS_setErrorCode(filterdata.errcode); - } /* if */ - } /* else if */ - else - { - retval = i->funcs->enumerate(i->opaque, arcfname, - cb, _fn, data); - } /* else */ - } /* else if */ - } /* for */ - - __PHYSFS_platformReleaseMutex(stateLock); - } /* if */ - - __PHYSFS_smallFree(fname); - - return (retval == PHYSFS_ENUM_ERROR) ? 0 : 1; -} /* PHYSFS_enumerate */ - - -typedef struct -{ - PHYSFS_EnumFilesCallback callback; - void *data; -} LegacyEnumFilesCallbackData; - -static PHYSFS_EnumerateCallbackResult enumFilesCallbackAlwaysSucceed(void *d, - const char *origdir, const char *fname) -{ - LegacyEnumFilesCallbackData *cbdata = (LegacyEnumFilesCallbackData *) d; - cbdata->callback(cbdata->data, origdir, fname); - return PHYSFS_ENUM_OK; -} /* enumFilesCallbackAlwaysSucceed */ - -void PHYSFS_enumerateFilesCallback(const char *fname, - PHYSFS_EnumFilesCallback callback, - void *data) -{ - LegacyEnumFilesCallbackData cbdata; - cbdata.callback = callback; - cbdata.data = data; - (void) PHYSFS_enumerate(fname, enumFilesCallbackAlwaysSucceed, &cbdata); -} /* PHYSFS_enumerateFilesCallback */ - - -int PHYSFS_exists(const char *fname) -{ - return (getRealDirHandle(fname) != NULL); -} /* PHYSFS_exists */ - - -PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname) -{ - PHYSFS_Stat statbuf; - BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), -1); - return statbuf.modtime; -} /* PHYSFS_getLastModTime */ - - -int PHYSFS_isDirectory(const char *fname) -{ - PHYSFS_Stat statbuf; - BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), 0); - return (statbuf.filetype == PHYSFS_FILETYPE_DIRECTORY); -} /* PHYSFS_isDirectory */ - - -int PHYSFS_isSymbolicLink(const char *fname) -{ - PHYSFS_Stat statbuf; - BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), 0); - return (statbuf.filetype == PHYSFS_FILETYPE_SYMLINK); -} /* PHYSFS_isSymbolicLink */ - - -static PHYSFS_File *doOpenWrite(const char *_fname, int appending) -{ - FileHandle *fh = NULL; - size_t len; - char *fname; - - BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - len = strlen(_fname) + 1; - fname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - - if (sanitizePlatformIndependentPath(_fname, fname)) - { - PHYSFS_Io *io = NULL; - DirHandle *h = NULL; - const PHYSFS_Archiver *f; - - __PHYSFS_platformGrabMutex(stateLock); - - GOTO_IF(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, doOpenWriteEnd); - - h = writeDir; - GOTO_IF_ERRPASS(!verifyPath(h, &fname, 0), doOpenWriteEnd); - - f = h->funcs; - if (appending) - io = f->openAppend(h->opaque, fname); - else - io = f->openWrite(h->opaque, fname); - - GOTO_IF_ERRPASS(!io, doOpenWriteEnd); - - fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle)); - if (fh == NULL) - { - io->destroy(io); - GOTO(PHYSFS_ERR_OUT_OF_MEMORY, doOpenWriteEnd); - } /* if */ - else - { - memset(fh, '\0', sizeof (FileHandle)); - fh->io = io; - fh->dirHandle = h; - fh->next = openWriteList; - openWriteList = fh; - } /* else */ - - doOpenWriteEnd: - __PHYSFS_platformReleaseMutex(stateLock); - } /* if */ - - __PHYSFS_smallFree(fname); - return ((PHYSFS_File *) fh); -} /* doOpenWrite */ - - -PHYSFS_File *PHYSFS_openWrite(const char *filename) -{ - return doOpenWrite(filename, 0); -} /* PHYSFS_openWrite */ - - -PHYSFS_File *PHYSFS_openAppend(const char *filename) -{ - return doOpenWrite(filename, 1); -} /* PHYSFS_openAppend */ - - -PHYSFS_File *PHYSFS_openRead(const char *_fname) -{ - FileHandle *fh = NULL; - char *fname; - size_t len; - - BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - len = strlen(_fname) + 1; - fname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - - if (sanitizePlatformIndependentPath(_fname, fname)) - { - DirHandle *i = NULL; - PHYSFS_Io *io = NULL; - - __PHYSFS_platformGrabMutex(stateLock); - - GOTO_IF(!searchPath, PHYSFS_ERR_NOT_FOUND, openReadEnd); - - for (i = searchPath; i != NULL; i = i->next) - { - char *arcfname = fname; - if (verifyPath(i, &arcfname, 0)) - { - io = i->funcs->openRead(i->opaque, arcfname); - if (io) - break; - } /* if */ - } /* for */ - - GOTO_IF_ERRPASS(!io, openReadEnd); - - fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle)); - if (fh == NULL) - { - io->destroy(io); - GOTO(PHYSFS_ERR_OUT_OF_MEMORY, openReadEnd); - } /* if */ - - memset(fh, '\0', sizeof (FileHandle)); - fh->io = io; - fh->forReading = 1; - fh->dirHandle = i; - fh->next = openReadList; - openReadList = fh; - - openReadEnd: - __PHYSFS_platformReleaseMutex(stateLock); - } /* if */ - - __PHYSFS_smallFree(fname); - return ((PHYSFS_File *) fh); -} /* PHYSFS_openRead */ - - -static int closeHandleInOpenList(FileHandle **list, FileHandle *handle) -{ - FileHandle *prev = NULL; - FileHandle *i; - int rc = 1; - - for (i = *list; i != NULL; i = i->next) - { - if (i == handle) /* handle is in this list? */ - { - PHYSFS_Io *io = handle->io; - PHYSFS_uint8 *tmp = handle->buffer; - rc = PHYSFS_flush((PHYSFS_File *) handle); - if (!rc) - return -1; - io->destroy(io); - - if (tmp != NULL) /* free any associated buffer. */ - allocator.Free(tmp); - - if (prev == NULL) - *list = handle->next; - else - prev->next = handle->next; - - allocator.Free(handle); - return 1; - } /* if */ - prev = i; - } /* for */ - - return 0; -} /* closeHandleInOpenList */ - - -int PHYSFS_close(PHYSFS_File *_handle) -{ - FileHandle *handle = (FileHandle *) _handle; - int rc; - - __PHYSFS_platformGrabMutex(stateLock); - - /* -1 == close failure. 0 == not found. 1 == success. */ - rc = closeHandleInOpenList(&openReadList, handle); - BAIL_IF_MUTEX_ERRPASS(rc == -1, stateLock, 0); - if (!rc) - { - rc = closeHandleInOpenList(&openWriteList, handle); - BAIL_IF_MUTEX_ERRPASS(rc == -1, stateLock, 0); - } /* if */ - - __PHYSFS_platformReleaseMutex(stateLock); - BAIL_IF(!rc, PHYSFS_ERR_INVALID_ARGUMENT, 0); - return 1; -} /* PHYSFS_close */ - - -static PHYSFS_sint64 doBufferedRead(FileHandle *fh, void *_buffer, size_t len) -{ - PHYSFS_uint8 *buffer = (PHYSFS_uint8 *) _buffer; - PHYSFS_sint64 retval = 0; - - while (len > 0) - { - const size_t avail = fh->buffill - fh->bufpos; - if (avail > 0) /* data available in the buffer. */ - { - const size_t cpy = (len < avail) ? len : avail; - memcpy(buffer, fh->buffer + fh->bufpos, cpy); - assert(len >= cpy); - buffer += cpy; - len -= cpy; - fh->bufpos += cpy; - retval += cpy; - } /* if */ - - else /* buffer is empty, refill it. */ - { - PHYSFS_Io *io = fh->io; - const PHYSFS_sint64 rc = io->read(io, fh->buffer, fh->bufsize); - fh->bufpos = 0; - if (rc > 0) - fh->buffill = (size_t) rc; - else - { - fh->buffill = 0; - if (retval == 0) /* report already-read data, or failure. */ - retval = rc; - break; - } /* else */ - } /* else */ - } /* while */ - - return retval; -} /* doBufferedRead */ - - -PHYSFS_sint64 PHYSFS_read(PHYSFS_File *handle, void *buffer, - PHYSFS_uint32 size, PHYSFS_uint32 count) -{ - const PHYSFS_uint64 len = ((PHYSFS_uint64) size) * ((PHYSFS_uint64) count); - const PHYSFS_sint64 retval = PHYSFS_readBytes(handle, buffer, len); - return ( (retval <= 0) ? retval : (retval / ((PHYSFS_sint64) size)) ); -} /* PHYSFS_read */ - - -PHYSFS_sint64 PHYSFS_readBytes(PHYSFS_File *handle, void *buffer, - PHYSFS_uint64 _len) -{ - const size_t len = (size_t) _len; - FileHandle *fh = (FileHandle *) handle; - -#ifdef PHYSFS_NO_64BIT_SUPPORT - const PHYSFS_uint64 maxlen = __PHYSFS_UI64(0x7FFFFFFF); -#else - const PHYSFS_uint64 maxlen = __PHYSFS_UI64(0x7FFFFFFFFFFFFFFF); -#endif - - if (!__PHYSFS_ui64FitsAddressSpace(_len)) - BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1); - - BAIL_IF(_len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1); - BAIL_IF(!fh->forReading, PHYSFS_ERR_OPEN_FOR_WRITING, -1); - BAIL_IF_ERRPASS(len == 0, 0); - if (fh->buffer) - return doBufferedRead(fh, buffer, len); - - return fh->io->read(fh->io, buffer, len); -} /* PHYSFS_readBytes */ - - -static PHYSFS_sint64 doBufferedWrite(PHYSFS_File *handle, const void *buffer, - const size_t len) -{ - FileHandle *fh = (FileHandle *) handle; - - /* whole thing fits in the buffer? */ - if ((fh->buffill + len) < fh->bufsize) - { - memcpy(fh->buffer + fh->buffill, buffer, len); - fh->buffill += len; - return (PHYSFS_sint64) len; - } /* if */ - - /* would overflow buffer. Flush and then write the new objects, too. */ - BAIL_IF_ERRPASS(!PHYSFS_flush(handle), -1); - return fh->io->write(fh->io, buffer, len); -} /* doBufferedWrite */ - - -PHYSFS_sint64 PHYSFS_write(PHYSFS_File *handle, const void *buffer, - PHYSFS_uint32 size, PHYSFS_uint32 count) -{ - const PHYSFS_uint64 len = ((PHYSFS_uint64) size) * ((PHYSFS_uint64) count); - const PHYSFS_sint64 retval = PHYSFS_writeBytes(handle, buffer, len); - return ( (retval <= 0) ? retval : (retval / ((PHYSFS_sint64) size)) ); -} /* PHYSFS_write */ - - -PHYSFS_sint64 PHYSFS_writeBytes(PHYSFS_File *handle, const void *buffer, - PHYSFS_uint64 _len) -{ - const size_t len = (size_t) _len; - FileHandle *fh = (FileHandle *) handle; - -#ifdef PHYSFS_NO_64BIT_SUPPORT - const PHYSFS_uint64 maxlen = __PHYSFS_UI64(0x7FFFFFFF); -#else - const PHYSFS_uint64 maxlen = __PHYSFS_UI64(0x7FFFFFFFFFFFFFFF); -#endif - - if (!__PHYSFS_ui64FitsAddressSpace(_len)) - BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1); - - BAIL_IF(_len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1); - BAIL_IF(fh->forReading, PHYSFS_ERR_OPEN_FOR_READING, -1); - BAIL_IF_ERRPASS(len == 0, 0); - if (fh->buffer) - return doBufferedWrite(handle, buffer, len); - - return fh->io->write(fh->io, buffer, len); -} /* PHYSFS_write */ - - -int PHYSFS_eof(PHYSFS_File *handle) -{ - FileHandle *fh = (FileHandle *) handle; - - if (!fh->forReading) /* never EOF on files opened for write/append. */ - return 0; - - /* can't be eof if buffer isn't empty */ - if (fh->bufpos == fh->buffill) - { - /* check the Io. */ - PHYSFS_Io *io = fh->io; - const PHYSFS_sint64 pos = io->tell(io); - const PHYSFS_sint64 len = io->length(io); - if ((pos < 0) || (len < 0)) - return 0; /* beats me. */ - return (pos >= len); - } /* if */ - - return 0; -} /* PHYSFS_eof */ - - -PHYSFS_sint64 PHYSFS_tell(PHYSFS_File *handle) -{ - FileHandle *fh = (FileHandle *) handle; - const PHYSFS_sint64 pos = fh->io->tell(fh->io); - const PHYSFS_sint64 retval = fh->forReading ? - (pos - fh->buffill) + fh->bufpos : - (pos + fh->buffill); - return retval; -} /* PHYSFS_tell */ - - -int PHYSFS_seek(PHYSFS_File *handle, PHYSFS_uint64 pos) -{ - FileHandle *fh = (FileHandle *) handle; - BAIL_IF_ERRPASS(!PHYSFS_flush(handle), 0); - - if (fh->buffer && fh->forReading) - { - /* avoid throwing away our precious buffer if seeking within it. */ - PHYSFS_sint64 offset = pos - PHYSFS_tell(handle); - if ( /* seeking within the already-buffered range? */ - /* forward? */ - ((offset >= 0) && (((size_t)offset) <= fh->buffill-fh->bufpos)) || - /* backward? */ - ((offset < 0) && (((size_t) -offset) <= fh->bufpos)) ) - { - fh->bufpos = (size_t) (((PHYSFS_sint64) fh->bufpos) + offset); - return 1; /* successful seek */ - } /* if */ - } /* if */ - - /* we have to fall back to a 'raw' seek. */ - fh->buffill = fh->bufpos = 0; - return fh->io->seek(fh->io, pos); -} /* PHYSFS_seek */ - - -PHYSFS_sint64 PHYSFS_fileLength(PHYSFS_File *handle) -{ - PHYSFS_Io *io = ((FileHandle *) handle)->io; - return io->length(io); -} /* PHYSFS_filelength */ - - -int PHYSFS_setBuffer(PHYSFS_File *handle, PHYSFS_uint64 _bufsize) -{ - FileHandle *fh = (FileHandle *) handle; - const size_t bufsize = (size_t) _bufsize; - - if (!__PHYSFS_ui64FitsAddressSpace(_bufsize)) - BAIL(PHYSFS_ERR_INVALID_ARGUMENT, 0); - - BAIL_IF_ERRPASS(!PHYSFS_flush(handle), 0); - - /* - * For reads, we need to move the file pointer to where it would be - * if we weren't buffering, so that the next read will get the - * right chunk of stuff from the file. PHYSFS_flush() handles writes. - */ - if ((fh->forReading) && (fh->buffill != fh->bufpos)) - { - PHYSFS_uint64 pos; - const PHYSFS_sint64 curpos = fh->io->tell(fh->io); - BAIL_IF_ERRPASS(curpos == -1, 0); - pos = ((curpos - fh->buffill) + fh->bufpos); - BAIL_IF_ERRPASS(!fh->io->seek(fh->io, pos), 0); - } /* if */ - - if (bufsize == 0) /* delete existing buffer. */ - { - if (fh->buffer) - { - allocator.Free(fh->buffer); - fh->buffer = NULL; - } /* if */ - } /* if */ - - else - { - PHYSFS_uint8 *newbuf; - newbuf = (PHYSFS_uint8 *) allocator.Realloc(fh->buffer, bufsize); - BAIL_IF(!newbuf, PHYSFS_ERR_OUT_OF_MEMORY, 0); - fh->buffer = newbuf; - } /* else */ - - fh->bufsize = bufsize; - fh->buffill = fh->bufpos = 0; - return 1; -} /* PHYSFS_setBuffer */ - - -int PHYSFS_flush(PHYSFS_File *handle) -{ - FileHandle *fh = (FileHandle *) handle; - PHYSFS_Io *io; - PHYSFS_sint64 rc; - - if ((fh->forReading) || (fh->bufpos == fh->buffill)) - return 1; /* open for read or buffer empty are successful no-ops. */ - - /* dump buffer to disk. */ - io = fh->io; - rc = io->write(io, fh->buffer + fh->bufpos, fh->buffill - fh->bufpos); - BAIL_IF_ERRPASS(rc <= 0, 0); - fh->bufpos = fh->buffill = 0; - return io->flush ? io->flush(io) : 1; -} /* PHYSFS_flush */ - - -int PHYSFS_stat(const char *_fname, PHYSFS_Stat *stat) -{ - int retval = 0; - char *fname; - size_t len; - - BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0); - BAIL_IF(!stat, PHYSFS_ERR_INVALID_ARGUMENT, 0); - len = strlen(_fname) + 1; - fname = (char *) __PHYSFS_smallAlloc(len); - BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0); - - /* set some sane defaults... */ - stat->filesize = -1; - stat->modtime = -1; - stat->createtime = -1; - stat->accesstime = -1; - stat->filetype = PHYSFS_FILETYPE_OTHER; - stat->readonly = 1; - - if (sanitizePlatformIndependentPath(_fname, fname)) - { - if (*fname == '\0') - { - stat->filetype = PHYSFS_FILETYPE_DIRECTORY; - stat->readonly = !writeDir; /* Writeable if we have a writeDir */ - retval = 1; - } /* if */ - else - { - DirHandle *i; - int exists = 0; - __PHYSFS_platformGrabMutex(stateLock); - for (i = searchPath; ((i != NULL) && (!exists)); i = i->next) - { - char *arcfname = fname; - exists = partOfMountPoint(i, arcfname); - if (exists) - { - stat->filetype = PHYSFS_FILETYPE_DIRECTORY; - stat->readonly = 1; - retval = 1; - } /* if */ - else if (verifyPath(i, &arcfname, 0)) - { - retval = i->funcs->stat(i->opaque, arcfname, stat); - if ((retval) || (currentErrorCode() != PHYSFS_ERR_NOT_FOUND)) - exists = 1; - } /* else if */ - } /* for */ - __PHYSFS_platformReleaseMutex(stateLock); - } /* else */ - } /* if */ - - __PHYSFS_smallFree(fname); - return retval; -} /* PHYSFS_stat */ - - -int __PHYSFS_readAll(PHYSFS_Io *io, void *buf, const size_t _len) -{ - const PHYSFS_uint64 len = (PHYSFS_uint64) _len; - return (io->read(io, buf, len) == len); -} /* __PHYSFS_readAll */ - - -void *__PHYSFS_initSmallAlloc(void *ptr, const size_t len) -{ - void *useHeap = ((ptr == NULL) ? ((void *) 1) : ((void *) 0)); - if (useHeap) /* too large for stack allocation or alloca() failed. */ - ptr = allocator.Malloc(len+sizeof (void *)); - - if (ptr != NULL) - { - void **retval = (void **) ptr; - /*printf("%s alloc'd (%lld) bytes at (%p).\n", - useHeap ? "heap" : "stack", (long long) len, ptr);*/ - *retval = useHeap; - return retval + 1; - } /* if */ - - return NULL; /* allocation failed. */ -} /* __PHYSFS_initSmallAlloc */ - - -void __PHYSFS_smallFree(void *ptr) -{ - if (ptr != NULL) - { - void **block = ((void **) ptr) - 1; - const int useHeap = (*block != NULL); - if (useHeap) - allocator.Free(block); - /*printf("%s free'd (%p).\n", useHeap ? "heap" : "stack", block);*/ - } /* if */ -} /* __PHYSFS_smallFree */ - - -int PHYSFS_setAllocator(const PHYSFS_Allocator *a) -{ - BAIL_IF(initialized, PHYSFS_ERR_IS_INITIALIZED, 0); - externalAllocator = (a != NULL); - if (externalAllocator) - memcpy(&allocator, a, sizeof (PHYSFS_Allocator)); - - return 1; -} /* PHYSFS_setAllocator */ - - -const PHYSFS_Allocator *PHYSFS_getAllocator(void) -{ - BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL); - return &allocator; -} /* PHYSFS_getAllocator */ - - -static void *mallocAllocatorMalloc(PHYSFS_uint64 s) -{ - if (!__PHYSFS_ui64FitsAddressSpace(s)) - BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL); - #undef malloc - return malloc((size_t) s); -} /* mallocAllocatorMalloc */ - - -static void *mallocAllocatorRealloc(void *ptr, PHYSFS_uint64 s) -{ - if (!__PHYSFS_ui64FitsAddressSpace(s)) - BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL); - #undef realloc - return realloc(ptr, (size_t) s); -} /* mallocAllocatorRealloc */ - - -static void mallocAllocatorFree(void *ptr) -{ - #undef free - free(ptr); -} /* mallocAllocatorFree */ - - -static void setDefaultAllocator(void) -{ - assert(!externalAllocator); - allocator.Init = NULL; - allocator.Deinit = NULL; - allocator.Malloc = mallocAllocatorMalloc; - allocator.Realloc = mallocAllocatorRealloc; - allocator.Free = mallocAllocatorFree; -} /* setDefaultAllocator */ - - -int __PHYSFS_DirTreeInit(__PHYSFS_DirTree *dt, const size_t entrylen) -{ - static char rootpath[2] = { '/', '\0' }; - size_t alloclen; - - assert(entrylen >= sizeof (__PHYSFS_DirTreeEntry)); - - memset(dt, '\0', sizeof (*dt)); - - dt->root = (__PHYSFS_DirTreeEntry *) allocator.Malloc(entrylen); - BAIL_IF(!dt->root, PHYSFS_ERR_OUT_OF_MEMORY, 0); - memset(dt->root, '\0', entrylen); - dt->root->name = rootpath; - dt->root->isdir = 1; - dt->hashBuckets = 64; - if (!dt->hashBuckets) - dt->hashBuckets = 1; - dt->entrylen = entrylen; - - alloclen = dt->hashBuckets * sizeof (__PHYSFS_DirTreeEntry *); - dt->hash = (__PHYSFS_DirTreeEntry **) allocator.Malloc(alloclen); - BAIL_IF(!dt->hash, PHYSFS_ERR_OUT_OF_MEMORY, 0); - memset(dt->hash, '\0', alloclen); - - return 1; -} /* __PHYSFS_DirTreeInit */ - - -static inline PHYSFS_uint32 hashPathName(__PHYSFS_DirTree *dt, const char *name) -{ - return __PHYSFS_hashString(name, strlen(name)) % dt->hashBuckets; -} /* hashPathName */ - - -/* Fill in missing parent directories. */ -static __PHYSFS_DirTreeEntry *addAncestors(__PHYSFS_DirTree *dt, char *name) -{ - __PHYSFS_DirTreeEntry *retval = dt->root; - char *sep = strrchr(name, '/'); - - if (sep) - { - *sep = '\0'; /* chop off last piece. */ - retval = (__PHYSFS_DirTreeEntry *) __PHYSFS_DirTreeFind(dt, name); - - if (retval != NULL) - { - *sep = '/'; - BAIL_IF(!retval->isdir, PHYSFS_ERR_CORRUPT, NULL); - return retval; /* already hashed. */ - } /* if */ - - /* okay, this is a new dir. Build and hash us. */ - retval = (__PHYSFS_DirTreeEntry*)__PHYSFS_DirTreeAdd(dt, name, 1); - *sep = '/'; - } /* if */ - - return retval; -} /* addAncestors */ - - -void *__PHYSFS_DirTreeAdd(__PHYSFS_DirTree *dt, char *name, const int isdir) -{ - __PHYSFS_DirTreeEntry *retval = __PHYSFS_DirTreeFind(dt, name); - if (!retval) - { - const size_t alloclen = strlen(name) + 1 + dt->entrylen; - PHYSFS_uint32 hashval; - __PHYSFS_DirTreeEntry *parent = addAncestors(dt, name); - BAIL_IF_ERRPASS(!parent, NULL); - assert(dt->entrylen >= sizeof (__PHYSFS_DirTreeEntry)); - retval = (__PHYSFS_DirTreeEntry *) allocator.Malloc(alloclen); - BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL); - memset(retval, '\0', dt->entrylen); - retval->name = ((char *) retval) + dt->entrylen; - strcpy(retval->name, name); - hashval = hashPathName(dt, name); - retval->hashnext = dt->hash[hashval]; - dt->hash[hashval] = retval; - retval->sibling = parent->children; - retval->isdir = isdir; - parent->children = retval; - } /* if */ - - return retval; -} /* __PHYSFS_DirTreeAdd */ - - -/* Find the __PHYSFS_DirTreeEntry for a path in platform-independent notation. */ -void *__PHYSFS_DirTreeFind(__PHYSFS_DirTree *dt, const char *path) -{ - PHYSFS_uint32 hashval; - __PHYSFS_DirTreeEntry *prev = NULL; - __PHYSFS_DirTreeEntry *retval; - - if (*path == '\0') - return dt->root; - - hashval = hashPathName(dt, path); - for (retval = dt->hash[hashval]; retval; retval = retval->hashnext) - { - if (strcmp(retval->name, path) == 0) - { - if (prev != NULL) /* move this to the front of the list */ - { - prev->hashnext = retval->hashnext; - retval->hashnext = dt->hash[hashval]; - dt->hash[hashval] = retval; - } /* if */ - - return retval; - } /* if */ - - prev = retval; - } /* for */ - - BAIL(PHYSFS_ERR_NOT_FOUND, NULL); -} /* __PHYSFS_DirTreeFind */ - -PHYSFS_EnumerateCallbackResult __PHYSFS_DirTreeEnumerate(void *opaque, - const char *dname, PHYSFS_EnumerateCallback cb, - const char *origdir, void *callbackdata) -{ - PHYSFS_EnumerateCallbackResult retval = PHYSFS_ENUM_OK; - __PHYSFS_DirTree *tree = (__PHYSFS_DirTree *) opaque; - const __PHYSFS_DirTreeEntry *entry = __PHYSFS_DirTreeFind(tree, dname); - BAIL_IF(!entry, PHYSFS_ERR_NOT_FOUND, PHYSFS_ENUM_ERROR); - - entry = entry->children; - - while (entry && (retval == PHYSFS_ENUM_OK)) - { - const char *name = entry->name; - const char *ptr = strrchr(name, '/'); - retval = cb(callbackdata, origdir, ptr ? ptr + 1 : name); - BAIL_IF(retval == PHYSFS_ENUM_ERROR, PHYSFS_ERR_APP_CALLBACK, retval); - entry = entry->sibling; - } /* while */ - - return retval; -} /* __PHYSFS_DirTreeEnumerate */ - - -void __PHYSFS_DirTreeDeinit(__PHYSFS_DirTree *dt) -{ - if (!dt) - return; - - if (dt->root) - { - assert(dt->root->sibling == NULL); - assert(dt->hash || (dt->root->children == NULL)); - allocator.Free(dt->root); - } /* if */ - - if (dt->hash) - { - size_t i; - for (i = 0; i < dt->hashBuckets; i++) - { - __PHYSFS_DirTreeEntry *entry; - __PHYSFS_DirTreeEntry *next; - for (entry = dt->hash[i]; entry; entry = next) - { - next = entry->hashnext; - allocator.Free(entry); - } /* for */ - } /* for */ - allocator.Free(dt->hash); - } /* if */ -} /* __PHYSFS_DirTreeDeinit */ - -/* end of physfs.c ... */ - |