/** * PhysicsFS; a portable, flexible file i/o abstraction. * * Documentation is in physfs.h. It's verbose, honest. :) * * Please see the file LICENSE.txt in the source's root directory. * * This file written by Ryan C. Gordon. */ #include #include #include #include "physfs.h" #define __PHYSICSFS_INTERNAL__ #include "physfs_internal.h" typedef struct __PHYSFS_DIRHANDLE__ { void *opaque; /* Instance data unique to the archiver. */ char *dirName; /* Path to archive in platform-dependent notation. */ char *mountPoint; /* Mountpoint in virtual file tree. */ const PHYSFS_Archiver *funcs; /* Ptr to archiver info for this handle. */ struct __PHYSFS_DIRHANDLE__ *next; /* linked list stuff. */ } DirHandle; typedef struct __PHYSFS_FILEHANDLE__ { void *opaque; /* Instance data unique to the archiver for this file. */ PHYSFS_uint8 forReading; /* Non-zero if reading, zero if write/append */ const DirHandle *dirHandle; /* Archiver instance that created this */ const PHYSFS_Archiver *funcs; /* Ptr to archiver info for this handle. */ PHYSFS_uint8 *buffer; /* Buffer, if set (NULL otherwise). Don't touch! */ PHYSFS_uint32 bufsize; /* Bufsize, if set (0 otherwise). Don't touch! */ PHYSFS_uint32 buffill; /* Buffer fill size. Don't touch! */ PHYSFS_uint32 bufpos; /* Buffer position. Don't touch! */ struct __PHYSFS_FILEHANDLE__ *next; /* linked list stuff. */ } FileHandle; typedef struct __PHYSFS_ERRMSGTYPE__ { PHYSFS_uint64 tid; int errorAvailable; char errorString[80]; struct __PHYSFS_ERRMSGTYPE__ *next; } ErrMsg; /* The various i/o drivers...some of these may not be compiled in. */ extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP; extern const PHYSFS_Archiver __PHYSFS_Archiver_ZIP; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_LZMA; extern const PHYSFS_Archiver __PHYSFS_Archiver_LZMA; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP; extern const PHYSFS_Archiver __PHYSFS_Archiver_GRP; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK; extern const PHYSFS_Archiver __PHYSFS_Archiver_QPAK; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG; extern const PHYSFS_Archiver __PHYSFS_Archiver_HOG; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL; extern const PHYSFS_Archiver __PHYSFS_Archiver_MVL; extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD; extern const PHYSFS_Archiver __PHYSFS_Archiver_WAD; extern const PHYSFS_Archiver __PHYSFS_Archiver_DIR; static const PHYSFS_ArchiveInfo *supported_types[] = { #if (defined PHYSFS_SUPPORTS_ZIP) &__PHYSFS_ArchiveInfo_ZIP, #endif #if (defined PHYSFS_SUPPORTS_7Z) &__PHYSFS_ArchiveInfo_LZMA, #endif #if (defined PHYSFS_SUPPORTS_GRP) &__PHYSFS_ArchiveInfo_GRP, #endif #if (defined PHYSFS_SUPPORTS_QPAK) &__PHYSFS_ArchiveInfo_QPAK, #endif #if (defined PHYSFS_SUPPORTS_HOG) &__PHYSFS_ArchiveInfo_HOG, #endif #if (defined PHYSFS_SUPPORTS_MVL) &__PHYSFS_ArchiveInfo_MVL, #endif #if (defined PHYSFS_SUPPORTS_WAD) &__PHYSFS_ArchiveInfo_WAD, #endif NULL }; static const PHYSFS_Archiver *archivers[] = { &__PHYSFS_Archiver_DIR, #if (defined PHYSFS_SUPPORTS_ZIP) &__PHYSFS_Archiver_ZIP, #endif #if (defined PHYSFS_SUPPORTS_7Z) &__PHYSFS_Archiver_LZMA, #endif #if (defined PHYSFS_SUPPORTS_GRP) &__PHYSFS_Archiver_GRP, #endif #if (defined PHYSFS_SUPPORTS_QPAK) &__PHYSFS_Archiver_QPAK, #endif #if (defined PHYSFS_SUPPORTS_HOG) &__PHYSFS_Archiver_HOG, #endif #if (defined PHYSFS_SUPPORTS_MVL) &__PHYSFS_Archiver_MVL, #endif #if (defined PHYSFS_SUPPORTS_WAD) &__PHYSFS_Archiver_WAD, #endif NULL }; /* General PhysicsFS state ... */ static int initialized = 0; static ErrMsg *errorMessages = NULL; static DirHandle *searchPath = NULL; static DirHandle *writeDir = NULL; static FileHandle *openWriteList = NULL; static FileHandle *openReadList = NULL; static char *baseDir = NULL; static char *userDir = NULL; static int allowSymLinks = 0; /* mutexes ... */ static void *errorLock = NULL; /* protects error message list. */ static void *stateLock = NULL; /* protects other PhysFS static state. */ /* allocator ... */ static int externalAllocator = 0; PHYSFS_Allocator allocator; /* functions ... */ typedef struct { char **list; PHYSFS_uint32 size; const char *errorstr; } EnumStringListCallbackData; static void enumStringListCallback(void *data, const char *str) { void *ptr; char *newstr; EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data; if (pecd->errorstr) return; ptr = allocator.Realloc(pecd->list, (pecd->size + 2) * sizeof (char *)); newstr = (char *) allocator.Malloc(strlen(str) + 1); if (ptr != NULL) pecd->list = (char **) ptr; if ((ptr == NULL) || (newstr == NULL)) { pecd->errorstr = ERR_OUT_OF_MEMORY; pecd->list[pecd->size] = NULL; PHYSFS_freeList(pecd->list); return; } /* if */ strcpy(newstr, str); pecd->list[pecd->size] = newstr; pecd->size++; } /* enumStringListCallback */ static char **doEnumStringList(void (*func)(PHYSFS_StringCallback, void *)) { EnumStringListCallbackData ecd; memset(&ecd, '\0', sizeof (ecd)); ecd.list = (char **) allocator.Malloc(sizeof (char *)); BAIL_IF_MACRO(ecd.list == NULL, ERR_OUT_OF_MEMORY, NULL); func(enumStringListCallback, &ecd); BAIL_IF_MACRO(ecd.errorstr != NULL, ecd.errorstr, NULL); ecd.list[ecd.size] = NULL; return(ecd.list); } /* doEnumStringList */ static void __PHYSFS_bubble_sort(void *a, PHYSFS_uint32 lo, PHYSFS_uint32 hi, int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32), void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32)) { PHYSFS_uint32 i; int sorted; do { sorted = 1; for (i = lo; i < hi; i++) { if (cmpfn(a, i, i + 1) > 0) { swapfn(a, i, i + 1); sorted = 0; } /* if */ } /* for */ } while (!sorted); } /* __PHYSFS_bubble_sort */ static void __PHYSFS_quick_sort(void *a, PHYSFS_uint32 lo, PHYSFS_uint32 hi, int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32), void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32)) { PHYSFS_uint32 i; PHYSFS_uint32 j; PHYSFS_uint32 v; if ((hi - lo) <= PHYSFS_QUICKSORT_THRESHOLD) __PHYSFS_bubble_sort(a, lo, hi, cmpfn, swapfn); else { i = (hi + lo) / 2; if (cmpfn(a, lo, i) > 0) swapfn(a, lo, i); if (cmpfn(a, lo, hi) > 0) swapfn(a, lo, hi); if (cmpfn(a, i, hi) > 0) swapfn(a, i, hi); j = hi - 1; swapfn(a, i, j); i = lo; v = j; while (1) { while(cmpfn(a, ++i, v) < 0) { /* do nothing */ } while(cmpfn(a, --j, v) > 0) { /* do nothing */ } if (j < i) break; swapfn(a, i, j); } /* while */ swapfn(a, i, hi-1); __PHYSFS_quick_sort(a, lo, j, cmpfn, swapfn); __PHYSFS_quick_sort(a, i+1, hi, cmpfn, swapfn); } /* else */ } /* __PHYSFS_quick_sort */ void __PHYSFS_sort(void *entries, PHYSFS_uint32 max, int (*cmpfn)(void *, PHYSFS_uint32, PHYSFS_uint32), void (*swapfn)(void *, PHYSFS_uint32, PHYSFS_uint32)) { /* * Quicksort w/ Bubblesort fallback algorithm inspired by code from here: * http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html */ __PHYSFS_quick_sort(entries, 0, max - 1, cmpfn, swapfn); } /* __PHYSFS_sort */ static ErrMsg *findErrorForCurrentThread(void) { ErrMsg *i; PHYSFS_uint64 tid; if (errorLock != NULL) __PHYSFS_platformGrabMutex(errorLock); if (errorMessages != NULL) { tid = __PHYSFS_platformGetThreadID(); for (i = errorMessages; i != NULL; i = i->next) { if (i->tid == tid) { if (errorLock != NULL) __PHYSFS_platformReleaseMutex(errorLock); return(i); } /* if */ } /* for */ } /* if */ if (errorLock != NULL) __PHYSFS_platformReleaseMutex(errorLock); return(NULL); /* no error available. */ } /* findErrorForCurrentThread */ void __PHYSFS_setError(const char *str) { ErrMsg *err; if (str == NULL) return; err = findErrorForCurrentThread(); if (err == NULL) { err = (ErrMsg *) allocator.Malloc(sizeof (ErrMsg)); if (err == NULL) return; /* uhh...? */ memset((void *) err, '\0', sizeof (ErrMsg)); err->tid = __PHYSFS_platformGetThreadID(); if (errorLock != NULL) __PHYSFS_platformGrabMutex(errorLock); err->next = errorMessages; errorMessages = err; if (errorLock != NULL) __PHYSFS_platformReleaseMutex(errorLock); } /* if */ err->errorAvailable = 1; strncpy(err->errorString, str, sizeof (err->errorString)); err->errorString[sizeof (err->errorString) - 1] = '\0'; } /* __PHYSFS_setError */ const char *PHYSFS_getLastError(void) { ErrMsg *err = findErrorForCurrentThread(); if ((err == NULL) || (!err->errorAvailable)) return(NULL); err->errorAvailable = 0; return(err->errorString); } /* PHYSFS_getLastError */ /* MAKE SURE that errorLock is held before calling this! */ static void freeErrorMessages(void) { ErrMsg *i; ErrMsg *next; for (i = errorMessages; i != NULL; i = next) { next = i->next; allocator.Free(i); } /* for */ errorMessages = NULL; } /* freeErrorMessages */ void PHYSFS_getLinkedVersion(PHYSFS_Version *ver) { if (ver != NULL) { ver->major = PHYSFS_VER_MAJOR; ver->minor = PHYSFS_VER_MINOR; ver->patch = PHYSFS_VER_PATCH; } /* if */ } /* PHYSFS_getLinkedVersion */ static const char *find_filename_extension(const char *fname) { const char *retval = strchr(fname, '.'); const char *p = retval; while (p != NULL) { p = strchr(p + 1, '.'); if (p != NULL) retval = p; } /* while */ if (retval != NULL) retval++; /* skip '.' */ return(retval); } /* find_filename_extension */ static DirHandle *tryOpenDir(const PHYSFS_Archiver *funcs, const char *d, int forWriting) { DirHandle *retval = NULL; if (funcs->isArchive(d, forWriting)) { void *opaque = funcs->openArchive(d, forWriting); if (opaque != NULL) { retval = (DirHandle *) allocator.Malloc(sizeof (DirHandle)); if (retval == NULL) funcs->dirClose(opaque); else { memset(retval, '\0', sizeof (DirHandle)); retval->mountPoint = NULL; retval->funcs = funcs; retval->opaque = opaque; } /* else */ } /* if */ } /* if */ return(retval); } /* tryOpenDir */ static DirHandle *openDirectory(const char *d, int forWriting) { DirHandle *retval = NULL; const PHYSFS_Archiver **i; const char *ext; BAIL_IF_MACRO(!__PHYSFS_platformExists(d), ERR_NO_SUCH_FILE, NULL); ext = find_filename_extension(d); if (ext != NULL) { /* Look for archivers with matching file extensions first... */ for (i = archivers; (*i != NULL) && (retval == NULL); i++) { if (__PHYSFS_stricmpASCII(ext, (*i)->info->extension) == 0) retval = tryOpenDir(*i, d, forWriting); } /* for */ /* failing an exact file extension match, try all the others... */ for (i = archivers; (*i != NULL) && (retval == NULL); i++) { if (__PHYSFS_stricmpASCII(ext, (*i)->info->extension) != 0) retval = tryOpenDir(*i, d, forWriting); } /* for */ } /* if */ else /* no extension? Try them all. */ { for (i = archivers; (*i != NULL) && (retval == NULL); i++) retval = tryOpenDir(*i, d, forWriting); } /* else */ BAIL_IF_MACRO(retval == NULL, ERR_UNSUPPORTED_ARCHIVE, NULL); return(retval); } /* openDirectory */ /* * Make a platform-independent path string sane. Doesn't actually check the * file hierarchy, it just cleans up the string. * (dst) must be a buffer at least as big as (src), as this is where the * cleaned up string is deposited. * If there are illegal bits in the path (".." entries, etc) then we * return zero and (dst) is undefined. Non-zero if the path was sanitized. */ static int sanitizePlatformIndependentPath(const char *src, char *dst) { char *prev; char ch; while (*src == '/') /* skip initial '/' chars... */ src++; prev = dst; do { ch = *(src++); if ((ch == ':') || (ch == '\\')) /* illegal chars in a physfs path. */ BAIL_MACRO(ERR_INSECURE_FNAME, 0); if (ch == '/') /* path separator. */ { *dst = '\0'; /* "." and ".." are illegal pathnames. */ if ((strcmp(prev, ".") == 0) || (strcmp(prev, "..") == 0)) BAIL_MACRO(ERR_INSECURE_FNAME, 0); while (*src == '/') /* chop out doubles... */ src++; if (*src == '\0') /* ends with a pathsep? */ break; /* we're done, don't add final pathsep to dst. */ prev = dst + 1; } /* if */ *(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) { /* !!! FIXME: This code feels gross. */ 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(const char *newDir, const char *mountPoint, int forWriting) { DirHandle *dirHandle = NULL; char *tmpmntpnt = NULL; GOTO_IF_MACRO(!newDir, ERR_INVALID_ARGUMENT, badDirHandle); if (mountPoint != NULL) { const size_t len = strlen(mountPoint) + 1; tmpmntpnt = (char *) __PHYSFS_smallAlloc(len); GOTO_IF_MACRO(!tmpmntpnt, ERR_OUT_OF_MEMORY, badDirHandle); if (!sanitizePlatformIndependentPath(mountPoint, tmpmntpnt)) goto badDirHandle; mountPoint = tmpmntpnt; /* sanitized version. */ } /* if */ dirHandle = openDirectory(newDir, forWriting); GOTO_IF_MACRO(!dirHandle, NULL, badDirHandle); dirHandle->dirName = (char *) allocator.Malloc(strlen(newDir) + 1); GOTO_IF_MACRO(!dirHandle->dirName, ERR_OUT_OF_MEMORY, badDirHandle); strcpy(dirHandle->dirName, newDir); if ((mountPoint != NULL) && (*mountPoint != '\0')) { dirHandle->mountPoint = (char *)allocator.Malloc(strlen(mountPoint)+2); GOTO_IF_MACRO(!dirHandle->mountPoint, ERR_OUT_OF_MEMORY, badDirHandle); strcpy(dirHandle->mountPoint, mountPoint); strcat(dirHandle->mountPoint, "/"); } /* if */ __PHYSFS_smallFree(tmpmntpnt); return(dirHandle); badDirHandle: if (dirHandle != NULL) { dirHandle->funcs->dirClose(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_MACRO(i->dirHandle == dh, ERR_FILES_STILL_OPEN, 0); dh->funcs->dirClose(dh->opaque); allocator.Free(dh->dirName); allocator.Free(dh->mountPoint); allocator.Free(dh); return(1); } /* freeDirHandle */ 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 *) allocator.Malloc(strlen(baseDir) + strlen(str) + strlen(dirsep) + 6); if (retval == NULL) __PHYSFS_setError(ERR_OUT_OF_MEMORY); else sprintf(retval, "%susers%s%s", baseDir, dirsep, str); allocator.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 = (char *) allocator.Realloc(*dir, strlen(*dir) + strlen(dirsep) + 1); if (!ptr) { allocator.Free(*dir); return(0); } /* if */ strcat(ptr, dirsep); *dir = ptr; return(1); } /* appendDirSep */ static char *calculateBaseDir(const char *argv0) { char *retval = NULL; const char *dirsep = 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_MACRO(argv0 == NULL, ERR_ARGV0_IS_NULL, NULL); dirsep = PHYSFS_getDirSeparator(); if (strlen(dirsep) == 1) /* fast path. */ ptr = strrchr(argv0, *dirsep); else { ptr = strstr(argv0, dirsep); if (ptr != NULL) { char *p = ptr; while (p != NULL) { ptr = p; p = strstr(p + 1, dirsep); } /* while */ } /* if */ } /* else */ if (ptr != NULL) { size_t size = (size_t) (ptr - argv0); retval = (char *) allocator.Malloc(size + 1); BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); memcpy(retval, argv0, size); retval[size] = '\0'; return(retval); } /* if */ /* argv0 wasn't helpful. */ BAIL_MACRO(ERR_INVALID_ARGUMENT, NULL); return(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 void setDefaultAllocator(void); int PHYSFS_init(const char *argv0) { char *ptr; BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0); if (!externalAllocator) setDefaultAllocator(); if (allocator.Init != NULL) BAIL_IF_MACRO(!allocator.Init(), NULL, 0); BAIL_IF_MACRO(!__PHYSFS_platformInit(), NULL, 0); BAIL_IF_MACRO(!initializeMutexes(), NULL, 0); baseDir = calculateBaseDir(argv0); BAIL_IF_MACRO(baseDir == NULL, NULL, 0); /* !!! FIXME: only call this if we got this from argv0 (unreliable). */ ptr = __PHYSFS_platformRealPath(baseDir); allocator.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); allocator.Free(userDir); userDir = ptr; } /* if */ if ((userDir == NULL) || (!appendDirSep(&userDir))) { allocator.Free(baseDir); baseDir = NULL; return(0); } /* if */ initialized = 1; /* This makes sure that the error subsystem is initialized. */ __PHYSFS_setError(PHYSFS_getLastError()); return(1); } /* PHYSFS_init */ /* MAKE SURE you hold stateLock before calling this! */ static int closeFileHandleList(FileHandle **list) { FileHandle *i; FileHandle *next = NULL; for (i = *list; i != NULL; i = next) { next = i->next; if (!i->funcs->fileClose(i->opaque)) { *list = i; return(0); } /* if */ 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 */ int PHYSFS_deinit(void) { BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0); BAIL_IF_MACRO(!__PHYSFS_platformDeinit(), NULL, 0); closeFileHandleList(&openWriteList); BAIL_IF_MACRO(!PHYSFS_setWriteDir(NULL), ERR_FILES_STILL_OPEN, 0); freeSearchPath(); freeErrorMessages(); if (baseDir != NULL) { allocator.Free(baseDir); baseDir = NULL; } /* if */ if (userDir != NULL) { allocator.Free(userDir); userDir = NULL; } /* if */ allowSymLinks = 0; initialized = 0; __PHYSFS_platformDestroyMutex(errorLock); __PHYSFS_platformDestroyMutex(stateLock); if (allocator.Deinit != NULL) allocator.Deinit(); errorLock = stateLock = NULL; 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++) allocator.Free(*i); allocator.Free(list); } /* PHYSFS_freeList */ const char *PHYSFS_getDirSeparator(void) { return(__PHYSFS_platformDirSeparator); } /* 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_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) { 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_MACRO_MUTEX(!freeDirHandle(writeDir, openWriteList), NULL, stateLock, 0); writeDir = NULL; } /* if */ if (newDir != NULL) { writeDir = createDirHandle(newDir, NULL, 1); retval = (writeDir != NULL); } /* if */ __PHYSFS_platformReleaseMutex(stateLock); return(retval); } /* PHYSFS_setWriteDir */ int PHYSFS_mount(const char *newDir, const char *mountPoint, int appendToPath) { DirHandle *dh; DirHandle *prev = NULL; DirHandle *i; BAIL_IF_MACRO(newDir == NULL, ERR_INVALID_ARGUMENT, 0); if (mountPoint == NULL) mountPoint = "/"; __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; i != NULL; i = i->next) { /* already in search path? */ BAIL_IF_MACRO_MUTEX(strcmp(newDir, i->dirName)==0, NULL, stateLock, 1); prev = i; } /* for */ dh = createDirHandle(newDir, mountPoint, 0); BAIL_IF_MACRO_MUTEX(dh == NULL, NULL, 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); } /* PHYSFS_mount */ int PHYSFS_addToSearchPath(const char *newDir, int appendToPath) { return(PHYSFS_mount(newDir, NULL, appendToPath)); } /* PHYSFS_addToSearchPath */ int PHYSFS_removeFromSearchPath(const char *oldDir) { DirHandle *i; DirHandle *prev = NULL; DirHandle *next = NULL; BAIL_IF_MACRO(oldDir == NULL, 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_MACRO_MUTEX(!freeDirHandle(i, openReadList), NULL, stateLock, 0); if (prev == NULL) searchPath = next; else prev->next = next; BAIL_MACRO_MUTEX(NULL, stateLock, 1); } /* if */ prev = i; } /* for */ BAIL_MACRO_MUTEX(ERR_NOT_IN_SEARCH_PATH, stateLock, 0); } /* PHYSFS_removeFromSearchPath */ 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_MACRO(ERR_NOT_IN_SEARCH_PATH, 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 */ /* Split out to avoid stack allocation in a loop. */ static void setSaneCfgAddPath(const char *i, const size_t l, const char *dirsep, int archivesFirst) { const char *d = PHYSFS_getRealDir(i); const size_t allocsize = strlen(d) + strlen(dirsep) + l + 1; char *str = (char *) __PHYSFS_smallAlloc(allocsize); if (str != NULL) { sprintf(str, "%s%s%s", d, dirsep, i); PHYSFS_addToSearchPath(str, archivesFirst == 0); __PHYSFS_smallFree(str); } /* if */ } /* setSaneCfgAddPath */ int PHYSFS_setSaneConfig(const char *organization, const char *appName, const char *archiveExt, int includeCdRoms, int archivesFirst) { const char *basedir = PHYSFS_getBaseDir(); const char *userdir = PHYSFS_getUserDir(); const char *dirsep = PHYSFS_getDirSeparator(); PHYSFS_uint64 len = 0; char *str = NULL; BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0); /* set write dir... */ len = (strlen(userdir) + (strlen(organization) * 2) + (strlen(appName) * 2) + (strlen(dirsep) * 3) + 2); str = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(str == NULL, ERR_OUT_OF_MEMORY, 0); sprintf(str, "%s.%s%s%s", userdir, organization, dirsep, appName); if (!PHYSFS_setWriteDir(str)) { int no_write = 0; sprintf(str, ".%s/%s", organization, appName); if ( (PHYSFS_setWriteDir(userdir)) && (PHYSFS_mkdir(str)) ) { sprintf(str, "%s.%s%s%s", userdir, organization, dirsep, appName); if (!PHYSFS_setWriteDir(str)) no_write = 1; } /* if */ else { no_write = 1; } /* else */ if (no_write) { PHYSFS_setWriteDir(NULL); /* just in case. */ __PHYSFS_smallFree(str); BAIL_MACRO(ERR_CANT_SET_WRITE_DIR, 0); } /* if */ } /* if */ /* Put write dir first in search path... */ PHYSFS_addToSearchPath(str, 0); __PHYSFS_smallFree(str); /* Put base path on search path... */ PHYSFS_addToSearchPath(basedir, 1); /* handle CD-ROMs... */ if (includeCdRoms) { char **cds = PHYSFS_getCdRomDirs(); char **i; for (i = cds; *i != NULL; i++) PHYSFS_addToSearchPath(*i, 1); PHYSFS_freeList(cds); } /* if */ /* Root out archives, and add them to search path... */ if (archiveExt != NULL) { char **rc = PHYSFS_enumerateFiles("/"); char **i; size_t extlen = strlen(archiveExt); char *ext; for (i = rc; *i != NULL; i++) { size_t l = strlen(*i); if ((l > extlen) && ((*i)[l - extlen - 1] == '.')) { ext = (*i) + (l - extlen); if (__PHYSFS_stricmpASCII(ext, archiveExt) == 0) setSaneCfgAddPath(*i, l, dirsep, archivesFirst); } /* if */ } /* for */ PHYSFS_freeList(rc); } /* if */ return(1); } /* PHYSFS_setSaneConfig */ void PHYSFS_permitSymbolicLinks(int allow) { allowSymLinks = allow; } /* PHYSFS_permitSymbolicLinks */ /* string manipulation in C makes my ass itch. */ char *__PHYSFS_convertToDependent(const char *prepend, const char *dirName, const char *append) { const char *dirsep = __PHYSFS_platformDirSeparator; size_t sepsize = strlen(dirsep); char *str; char *i1; char *i2; size_t allocSize; while (*dirName == '/') /* !!! FIXME: pass through sanitize function. */ dirName++; allocSize = strlen(dirName) + 1; if (prepend != NULL) allocSize += strlen(prepend) + sepsize; if (append != NULL) allocSize += strlen(append) + sepsize; /* make sure there's enough space if the dir separator is bigger. */ if (sepsize > 1) { str = (char *) dirName; do { str = strchr(str, '/'); if (str != NULL) { allocSize += (sepsize - 1); str++; } /* if */ } while (str != NULL); } /* if */ str = (char *) allocator.Malloc(allocSize); BAIL_IF_MACRO(str == NULL, ERR_OUT_OF_MEMORY, NULL); if (prepend == NULL) *str = '\0'; else { strcpy(str, prepend); strcat(str, dirsep); } /* else */ for (i1 = (char *) dirName, i2 = str + strlen(str); *i1; i1++, i2++) { if (*i1 == '/') { strcpy(i2, dirsep); i2 += sepsize; } /* if */ else { *i2 = *i1; } /* else */ } /* for */ *i2 = '\0'; if (append) { strcat(str, dirsep); strcat(str, append); } /* if */ return(str); } /* __PHYSFS_convertToDependent */ /* * 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_MACRO(len < mntpntlen-1, ERR_NO_SUCH_PATH, 0); /* !!! FIXME: Case insensitive? */ retval = strncmp(h->mountPoint, fname, mntpntlen-1); BAIL_IF_MACRO(retval != 0, ERR_NO_SUCH_PATH, 0); if (len > mntpntlen-1) /* corner case... */ BAIL_IF_MACRO(fname[mntpntlen-1] != '/', ERR_NO_SUCH_PATH, 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) { int rc = 0; end = strchr(start, '/'); if (end != NULL) *end = '\0'; rc = h->funcs->isSymLink(h->opaque, fname, &retval); if (end != NULL) *end = '/'; BAIL_IF_MACRO(rc, ERR_SYMLINK_DISALLOWED, 0); /* insecure. */ /* 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_MACRO(!sanitizePlatformIndependentPath(_dname, dname), NULL, 0); __PHYSFS_platformGrabMutex(stateLock); BAIL_IF_MACRO_MUTEX(writeDir == NULL, ERR_NO_WRITE_DIR, stateLock, 0); h = writeDir; BAIL_IF_MACRO_MUTEX(!verifyPath(h, &dname, 1), NULL, 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) retval = h->funcs->isDirectory(h->opaque, dname, &exists); 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_MACRO(_dname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_dname) + 1; dname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(dname == NULL, 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_MACRO(!sanitizePlatformIndependentPath(_fname, fname), NULL, 0); __PHYSFS_platformGrabMutex(stateLock); BAIL_IF_MACRO_MUTEX(writeDir == NULL, ERR_NO_WRITE_DIR, stateLock, 0); h = writeDir; BAIL_IF_MACRO_MUTEX(!verifyPath(h, &fname, 0), NULL, 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_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, 0); retval = doDelete(_fname, fname); __PHYSFS_smallFree(fname); return(retval); } /* PHYSFS_delete */ const char *PHYSFS_getRealDir(const char *_fname) { const char *retval = NULL; char *fname = NULL; size_t len; BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, NULL); len = strlen(_fname) + 1; fname = __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, NULL); if (sanitizePlatformIndependentPath(_fname, fname)) { DirHandle *i; __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (retval == NULL)); i = i->next) { char *arcfname = fname; if (partOfMountPoint(i, arcfname)) retval = i->dirName; else if (verifyPath(i, &arcfname, 0)) { if (i->funcs->exists(i->opaque, arcfname)) retval = i->dirName; } /* if */ } /* for */ __PHYSFS_platformReleaseMutex(stateLock); } /* if */ __PHYSFS_smallFree(fname); return(retval); } /* 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 void 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; /* already in the list. */ 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)) return; /* better luck next time. */ 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++; } /* enumFilesCallback */ char **PHYSFS_enumerateFiles(const char *path) { EnumStringListCallbackData ecd; memset(&ecd, '\0', sizeof (ecd)); ecd.list = (char **) allocator.Malloc(sizeof (char *)); BAIL_IF_MACRO(ecd.list == NULL, ERR_OUT_OF_MEMORY, NULL); PHYSFS_enumerateFilesCallback(path, enumFilesCallback, &ecd); ecd.list[ecd.size] = NULL; return(ecd.list); } /* PHYSFS_enumerateFiles */ /* * Broke out to seperate function so we can use stack allocation gratuitously. */ static void enumerateFromMountPoint(DirHandle *i, const char *arcfname, PHYSFS_EnumFilesCallback callback, const char *_fname, void *data) { 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); if (mountPoint == NULL) return; /* oh well. */ strcpy(mountPoint, i->mountPoint); ptr = mountPoint + ((len) ? len + 1 : 0); end = strchr(ptr, '/'); assert(end); /* should always find a terminating '/'. */ *end = '\0'; callback(data, _fname, ptr); __PHYSFS_smallFree(mountPoint); } /* enumerateFromMountPoint */ /* !!! FIXME: this should report error conditions. */ void PHYSFS_enumerateFilesCallback(const char *_fname, PHYSFS_EnumFilesCallback callback, void *data) { size_t len; char *fname; BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, ) /*0*/; BAIL_IF_MACRO(callback == NULL, ERR_INVALID_ARGUMENT, ) /*0*/; len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, ) /*0*/; if (sanitizePlatformIndependentPath(_fname, fname)) { DirHandle *i; int noSyms; __PHYSFS_platformGrabMutex(stateLock); noSyms = !allowSymLinks; for (i = searchPath; i != NULL; i = i->next) { char *arcfname = fname; if (partOfMountPoint(i, arcfname)) enumerateFromMountPoint(i, arcfname, callback, _fname, data); else if (verifyPath(i, &arcfname, 0)) { i->funcs->enumerateFiles(i->opaque, arcfname, noSyms, callback, _fname, data); } /* else if */ } /* for */ __PHYSFS_platformReleaseMutex(stateLock); } /* if */ __PHYSFS_smallFree(fname); } /* PHYSFS_enumerateFilesCallback */ int PHYSFS_exists(const char *fname) { return(PHYSFS_getRealDir(fname) != NULL); } /* PHYSFS_exists */ PHYSFS_sint64 PHYSFS_getLastModTime(const char *_fname) { PHYSFS_sint64 retval = -1; char *fname; size_t len; BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, -1); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, -1); if (sanitizePlatformIndependentPath(_fname, fname)) { if (*fname == '\0') /* eh...punt if it's the root dir. */ retval = 1; /* !!! FIXME: Maybe this should be an error? */ 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) retval = 1; /* !!! FIXME: What's the right value? */ else if (verifyPath(i, &arcfname, 0)) { retval = i->funcs->getLastModTime(i->opaque, arcfname, &exists); } /* else if */ } /* for */ __PHYSFS_platformReleaseMutex(stateLock); } /* else */ } /* if */ __PHYSFS_smallFree(fname); return(retval); } /* PHYSFS_getLastModTime */ int PHYSFS_isDirectory(const char *_fname) { int retval = 0; size_t len; char *fname; BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, 0); if (!sanitizePlatformIndependentPath(_fname, fname)) retval = 0; else if (*fname == '\0') retval = 1; /* Root is always a dir. :) */ else { DirHandle *i; int exists = 0; __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (!exists)); i = i->next) { char *arcfname = fname; if ((exists = partOfMountPoint(i, arcfname)) != 0) retval = 1; else if (verifyPath(i, &arcfname, 0)) retval = i->funcs->isDirectory(i->opaque, arcfname, &exists); } /* for */ __PHYSFS_platformReleaseMutex(stateLock); } /* else */ __PHYSFS_smallFree(fname); return(retval); } /* PHYSFS_isDirectory */ int PHYSFS_isSymbolicLink(const char *_fname) { int retval = 0; size_t len; char *fname; BAIL_IF_MACRO(!allowSymLinks, ERR_SYMLINK_DISALLOWED, 0); BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, 0); if (!sanitizePlatformIndependentPath(_fname, fname)) retval = 0; else if (*fname == '\0') retval = 1; /* Root is never a symlink. */ else { DirHandle *i; int fileExists = 0; __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (!fileExists)); i = i->next) { char *arcfname = fname; if ((fileExists = partOfMountPoint(i, arcfname)) != 0) retval = 0; /* virtual dir...not a symlink. */ else if (verifyPath(i, &arcfname, 0)) retval = i->funcs->isSymLink(i->opaque, arcfname, &fileExists); } /* for */ __PHYSFS_platformReleaseMutex(stateLock); } /* else */ __PHYSFS_smallFree(fname); return(retval); } /* PHYSFS_isSymbolicLink */ static PHYSFS_File *doOpenWrite(const char *_fname, int appending) { FileHandle *fh = NULL; size_t len; char *fname; BAIL_IF_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, 0); if (sanitizePlatformIndependentPath(_fname, fname)) { void *opaque = NULL; DirHandle *h = NULL; const PHYSFS_Archiver *f; __PHYSFS_platformGrabMutex(stateLock); GOTO_IF_MACRO(!writeDir, ERR_NO_WRITE_DIR, doOpenWriteEnd); h = writeDir; GOTO_IF_MACRO(!verifyPath(h, &fname, 0), NULL, doOpenWriteEnd); f = h->funcs; if (appending) opaque = f->openAppend(h->opaque, fname); else opaque = f->openWrite(h->opaque, fname); GOTO_IF_MACRO(opaque == NULL, NULL, doOpenWriteEnd); fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle)); if (fh == NULL) { f->fileClose(opaque); GOTO_MACRO(ERR_OUT_OF_MEMORY, doOpenWriteEnd); } /* if */ else { memset(fh, '\0', sizeof (FileHandle)); fh->opaque = opaque; fh->dirHandle = h; fh->funcs = h->funcs; 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_MACRO(_fname == NULL, ERR_INVALID_ARGUMENT, 0); len = strlen(_fname) + 1; fname = (char *) __PHYSFS_smallAlloc(len); BAIL_IF_MACRO(fname == NULL, ERR_OUT_OF_MEMORY, 0); if (sanitizePlatformIndependentPath(_fname, fname)) { int fileExists = 0; DirHandle *i = NULL; fvoid *opaque = NULL; __PHYSFS_platformGrabMutex(stateLock); GOTO_IF_MACRO(!searchPath, ERR_NO_SUCH_PATH, openReadEnd); /* !!! FIXME: Why aren't we using a for loop here? */ i = searchPath; do { char *arcfname = fname; if (verifyPath(i, &arcfname, 0)) { opaque = i->funcs->openRead(i->opaque, arcfname, &fileExists); if (opaque) break; } /* if */ i = i->next; } while ((i != NULL) && (!fileExists)); /* !!! FIXME: may not set an error if openRead didn't fail. */ GOTO_IF_MACRO(opaque == NULL, NULL, openReadEnd); fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle)); if (fh == NULL) { i->funcs->fileClose(opaque); GOTO_MACRO(ERR_OUT_OF_MEMORY, openReadEnd); } /* if */ memset(fh, '\0', sizeof (FileHandle)); fh->opaque = opaque; fh->forReading = 1; fh->dirHandle = i; fh->funcs = i->funcs; 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_uint8 *tmp = handle->buffer; rc = PHYSFS_flush((PHYSFS_File *) handle); if (rc) rc = handle->funcs->fileClose(handle->opaque); if (!rc) return(-1); 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_MACRO_MUTEX(rc == -1, NULL, stateLock, 0); if (!rc) { rc = closeHandleInOpenList(&openWriteList, handle); BAIL_IF_MACRO_MUTEX(rc == -1, NULL, stateLock, 0); } /* if */ __PHYSFS_platformReleaseMutex(stateLock); BAIL_IF_MACRO(!rc, ERR_NOT_A_HANDLE, 0); return(1); } /* PHYSFS_close */ static PHYSFS_sint64 doBufferedRead(FileHandle *fh, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { PHYSFS_sint64 retval = 0; PHYSFS_uint32 remainder = 0; while (objCount > 0) { PHYSFS_uint32 buffered = fh->buffill - fh->bufpos; PHYSFS_uint64 mustread = (objSize * objCount) - remainder; PHYSFS_uint32 copied; if (buffered == 0) /* need to refill buffer? */ { PHYSFS_sint64 rc = fh->funcs->read(fh->opaque, fh->buffer, 1, fh->bufsize); if (rc <= 0) { fh->bufpos -= remainder; return(((rc == -1) && (retval == 0)) ? -1 : retval); } /* if */ buffered = fh->buffill = (PHYSFS_uint32) rc; fh->bufpos = 0; } /* if */ if (buffered > mustread) buffered = (PHYSFS_uint32) mustread; memcpy(buffer, fh->buffer + fh->bufpos, (size_t) buffered); buffer = ((PHYSFS_uint8 *) buffer) + buffered; fh->bufpos += buffered; buffered += remainder; /* take remainder into account. */ copied = (buffered / objSize); remainder = (buffered % objSize); retval += copied; objCount -= copied; } /* while */ return(retval); } /* doBufferedRead */ PHYSFS_sint64 PHYSFS_read(PHYSFS_File *handle, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { FileHandle *fh = (FileHandle *) handle; BAIL_IF_MACRO(!fh->forReading, ERR_FILE_ALREADY_OPEN_W, -1); if (fh->buffer != NULL) return(doBufferedRead(fh, buffer, objSize, objCount)); return(fh->funcs->read(fh->opaque, buffer, objSize, objCount)); } /* PHYSFS_read */ static PHYSFS_sint64 doBufferedWrite(PHYSFS_File *handle, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { FileHandle *fh = (FileHandle *) handle; /* whole thing fits in the buffer? */ if (fh->buffill + (objSize * objCount) < fh->bufsize) { memcpy(fh->buffer + fh->buffill, buffer, objSize * objCount); fh->buffill += (objSize * objCount); return(objCount); } /* if */ /* would overflow buffer. Flush and then write the new objects, too. */ BAIL_IF_MACRO(!PHYSFS_flush(handle), NULL, -1); return(fh->funcs->write(fh->opaque, buffer, objSize, objCount)); } /* doBufferedWrite */ PHYSFS_sint64 PHYSFS_write(PHYSFS_File *handle, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { FileHandle *fh = (FileHandle *) handle; BAIL_IF_MACRO(fh->forReading, ERR_FILE_ALREADY_OPEN_R, -1); if (fh->buffer != NULL) return(doBufferedWrite(handle, buffer, objSize, objCount)); return(fh->funcs->write(fh->opaque, buffer, objSize, objCount)); } /* 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); /* eof if buffer is empty and archiver says so. */ return((fh->bufpos == fh->buffill) && (fh->funcs->eof(fh->opaque))); } /* PHYSFS_eof */ PHYSFS_sint64 PHYSFS_tell(PHYSFS_File *handle) { FileHandle *fh = (FileHandle *) handle; PHYSFS_sint64 pos = fh->funcs->tell(fh->opaque); 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_MACRO(!PHYSFS_flush(handle), NULL, 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? */ ((offset >= 0) && (offset <= fh->buffill - fh->bufpos)) /* fwd */ || ((offset < 0) && (-offset <= fh->bufpos)) /* backward */ ) { fh->bufpos += (PHYSFS_uint32) offset; return(1); /* successful seek */ } /* if */ } /* if */ /* we have to fall back to a 'raw' seek. */ fh->buffill = fh->bufpos = 0; return(fh->funcs->seek(fh->opaque, pos)); } /* PHYSFS_seek */ PHYSFS_sint64 PHYSFS_fileLength(PHYSFS_File *handle) { FileHandle *fh = (FileHandle *) handle; return(fh->funcs->fileLength(fh->opaque)); } /* PHYSFS_filelength */ int PHYSFS_setBuffer(PHYSFS_File *handle, PHYSFS_uint64 _bufsize) { FileHandle *fh = (FileHandle *) handle; PHYSFS_uint32 bufsize; /* !!! FIXME: Unlocalized string. */ BAIL_IF_MACRO(_bufsize > 0xFFFFFFFF, "buffer must fit in 32-bits", 0); bufsize = (PHYSFS_uint32) _bufsize; BAIL_IF_MACRO(!PHYSFS_flush(handle), NULL, 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; PHYSFS_sint64 curpos = fh->funcs->tell(fh->opaque); BAIL_IF_MACRO(curpos == -1, NULL, 0); pos = ((curpos - fh->buffill) + fh->bufpos); BAIL_IF_MACRO(!fh->funcs->seek(fh->opaque, pos), NULL, 0); } /* if */ if (bufsize == 0) /* delete existing buffer. */ { if (fh->buffer != NULL) { allocator.Free(fh->buffer); fh->buffer = NULL; } /* if */ } /* if */ else { PHYSFS_uint8 *newbuf; newbuf = (PHYSFS_uint8 *) allocator.Realloc(fh->buffer, bufsize); BAIL_IF_MACRO(newbuf == NULL, 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_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. */ rc = fh->funcs->write(fh->opaque, fh->buffer + fh->bufpos, fh->buffill - fh->bufpos, 1); BAIL_IF_MACRO(rc <= 0, NULL, 0); fh->bufpos = fh->buffill = 0; return(1); } /* PHYSFS_flush */ int PHYSFS_setAllocator(const PHYSFS_Allocator *a) { BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0); externalAllocator = (a != NULL); if (externalAllocator) memcpy(&allocator, a, sizeof (PHYSFS_Allocator)); return(1); } /* PHYSFS_setAllocator */ static void *mallocAllocatorMalloc(PHYSFS_uint64 s) { BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), ERR_OUT_OF_MEMORY, NULL); #undef malloc return(malloc((size_t) s)); } /* mallocAllocatorMalloc */ static void *mallocAllocatorRealloc(void *ptr, PHYSFS_uint64 s) { BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), 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); if (!__PHYSFS_platformSetDefaultAllocator(&allocator)) { allocator.Init = NULL; allocator.Deinit = NULL; allocator.Malloc = mallocAllocatorMalloc; allocator.Realloc = mallocAllocatorRealloc; allocator.Free = mallocAllocatorFree; } /* if */ } /* setDefaultAllocator */ void *__PHYSFS_initSmallAlloc(void *ptr, PHYSFS_uint64 len) { const char useHeap = ((ptr == NULL) ? 1 : 0); if (useHeap) /* too large for stack allocation or alloca() failed. */ ptr = allocator.Malloc(len+1); if (ptr != NULL) { char *retval = (char *) ptr; /*printf("%s alloc'd (%d) bytes at (%p).\n", useHeap ? "heap" : "stack", (int) len, ptr);*/ *retval = useHeap; return(retval+1); } /* if */ return(NULL); /* allocation failed. */ } /* __PHYSFS_initSmallAlloc */ void __PHYSFS_smallFree(void *ptr) { if (ptr != NULL) { char *block = ((char *) ptr) - 1; const char useHeap = *block; if (useHeap) allocator.Free(block); /*printf("%s free'd (%p).\n", useHeap ? "heap" : "stack", block);*/ } /* if */ } /* __PHYSFS_smallFree */ /* end of physfs.c ... */