1 /**

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

     3  *

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

     5  *

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

     7  *

     8  *  This file written by Ryan C. Gordon.

     9  */

    10 

    11 /* !!! FIXME: ERR_PAST_EOF shouldn't trigger for reads. Just return zero. */

    12 /* !!! FIXME: use snprintf(), not sprintf(). */

    13 

    14 #define __PHYSICSFS_INTERNAL__

    15 #include "physfs_internal.h"

    16 

    17 

    18 typedef struct __PHYSFS_DIRHANDLE__

    19 {

    20     void *opaque;  /* Instance data unique to the archiver. */

    21     char *dirName;  /* Path to archive in platform-dependent notation. */

    22     char *mountPoint; /* Mountpoint in virtual file tree. */

    23     const PHYSFS_Archiver *funcs;  /* Ptr to archiver info for this handle. */

    24     struct __PHYSFS_DIRHANDLE__ *next;  /* linked list stuff. */

    25 } DirHandle;

    26 

    27 

    28 typedef struct __PHYSFS_FILEHANDLE__

    29 {

    30     PHYSFS_Io *io;  /* Instance data unique to the archiver for this file. */

    31     PHYSFS_uint8 forReading; /* Non-zero if reading, zero if write/append */

    32     const DirHandle *dirHandle;  /* Archiver instance that created this */

    33     PHYSFS_uint8 *buffer;  /* Buffer, if set (NULL otherwise). Don't touch! */

    34     PHYSFS_uint32 bufsize;  /* Bufsize, if set (0 otherwise). Don't touch! */

    35     PHYSFS_uint32 buffill;  /* Buffer fill size. Don't touch! */

    36     PHYSFS_uint32 bufpos;  /* Buffer position. Don't touch! */

    37     struct __PHYSFS_FILEHANDLE__ *next;  /* linked list stuff. */

    38 } FileHandle;

    39 

    40 

    41 typedef struct __PHYSFS_ERRSTATETYPE__

    42 {

    43     void *tid;

    44     PHYSFS_ErrorCode code;

    45     struct __PHYSFS_ERRSTATETYPE__ *next;

    46 } ErrState;

    47 

    48 

    49 /* The various i/o drivers...some of these may not be compiled in. */

    50 extern const PHYSFS_Archiver __PHYSFS_Archiver_ZIP;

    51 extern const PHYSFS_Archiver __PHYSFS_Archiver_LZMA;

    52 extern const PHYSFS_Archiver __PHYSFS_Archiver_GRP;

    53 extern const PHYSFS_Archiver __PHYSFS_Archiver_QPAK;

    54 extern const PHYSFS_Archiver __PHYSFS_Archiver_HOG;

    55 extern const PHYSFS_Archiver __PHYSFS_Archiver_MVL;

    56 extern const PHYSFS_Archiver __PHYSFS_Archiver_WAD;

    57 extern const PHYSFS_Archiver __PHYSFS_Archiver_DIR;

    58 extern const PHYSFS_Archiver __PHYSFS_Archiver_ISO9660;

    59 

    60 static const PHYSFS_Archiver *staticArchivers[] =

    61 {

    62 #if PHYSFS_SUPPORTS_ZIP

    63     &__PHYSFS_Archiver_ZIP,

    64 #endif

    65 #if PHYSFS_SUPPORTS_7Z

    66     &__PHYSFS_Archiver_LZMA,

    67 #endif

    68 #if PHYSFS_SUPPORTS_GRP

    69     &__PHYSFS_Archiver_GRP,

    70 #endif

    71 #if PHYSFS_SUPPORTS_QPAK

    72     &__PHYSFS_Archiver_QPAK,

    73 #endif

    74 #if PHYSFS_SUPPORTS_HOG

    75     &__PHYSFS_Archiver_HOG,

    76 #endif

    77 #if PHYSFS_SUPPORTS_MVL

    78     &__PHYSFS_Archiver_MVL,

    79 #endif

    80 #if PHYSFS_SUPPORTS_WAD

    81     &__PHYSFS_Archiver_WAD,

    82 #endif

    83 #if PHYSFS_SUPPORTS_ISO9660

    84     &__PHYSFS_Archiver_ISO9660,

    85 #endif

    86     NULL

    87 };

    88 

    89 

    90 

    91 /* General PhysicsFS state ... */

    92 static int initialized = 0;

    93 static ErrState *errorStates = NULL;

    94 static DirHandle *searchPath = NULL;

    95 static DirHandle *writeDir = NULL;

    96 static FileHandle *openWriteList = NULL;

    97 static FileHandle *openReadList = NULL;

    98 static char *baseDir = NULL;

    99 static char *userDir = NULL;

   100 static char *prefDir = NULL;

   101 static int allowSymLinks = 0;

   102 static const PHYSFS_Archiver **archivers = NULL;

   103 static const PHYSFS_ArchiveInfo **archiveInfo = NULL;

   104 

   105 /* mutexes ... */

   106 static void *errorLock = NULL;     /* protects error message list.        */

   107 static void *stateLock = NULL;     /* protects other PhysFS static state. */

   108 

   109 /* allocator ... */

   110 static int externalAllocator = 0;

   111 PHYSFS_Allocator allocator;

   112 

   113 

   114 /* PHYSFS_Io implementation for i/o to physical filesystem... */

   115 

   116 /* !!! FIXME: maybe refcount the paths in a string pool? */

   117 typedef struct __PHYSFS_NativeIoInfo

   118 {

   119     void *handle;

   120     const char *path;

   121     int mode;   /* 'r', 'w', or 'a' */

   122 } NativeIoInfo;

   123 

   124 static PHYSFS_sint64 nativeIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

   125 {

   126     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   127     return __PHYSFS_platformRead(info->handle, buf, len);

   128 } /* nativeIo_read */

   129 

   130 static PHYSFS_sint64 nativeIo_write(PHYSFS_Io *io, const void *buffer,

   131                                     PHYSFS_uint64 len)

   132 {

   133     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   134     return __PHYSFS_platformWrite(info->handle, buffer, len);

   135 } /* nativeIo_write */

   136 

   137 static int nativeIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

   138 {

   139     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   140     return __PHYSFS_platformSeek(info->handle, offset);

   141 } /* nativeIo_seek */

   142 

   143 static PHYSFS_sint64 nativeIo_tell(PHYSFS_Io *io)

   144 {

   145     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   146     return __PHYSFS_platformTell(info->handle);

   147 } /* nativeIo_tell */

   148 

   149 static PHYSFS_sint64 nativeIo_length(PHYSFS_Io *io)

   150 {

   151     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   152     return __PHYSFS_platformFileLength(info->handle);

   153 } /* nativeIo_length */

   154 

   155 static PHYSFS_Io *nativeIo_duplicate(PHYSFS_Io *io)

   156 {

   157     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   158     return __PHYSFS_createNativeIo(info->path, info->mode);

   159 } /* nativeIo_duplicate */

   160 

   161 static int nativeIo_flush(PHYSFS_Io *io)

   162 {

   163     return __PHYSFS_platformFlush(io->opaque);

   164 } /* nativeIo_flush */

   165 

   166 static void nativeIo_destroy(PHYSFS_Io *io)

   167 {

   168     NativeIoInfo *info = (NativeIoInfo *) io->opaque;

   169     __PHYSFS_platformClose(info->handle);

   170     allocator.Free((void *) info->path);

   171     allocator.Free(info);

   172     allocator.Free(io);

   173 } /* nativeIo_destroy */

   174 

   175 static const PHYSFS_Io __PHYSFS_nativeIoInterface =

   176 {

   177     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   178     nativeIo_read,

   179     nativeIo_write,

   180     nativeIo_seek,

   181     nativeIo_tell,

   182     nativeIo_length,

   183     nativeIo_duplicate,

   184     nativeIo_flush,

   185     nativeIo_destroy

   186 };

   187 

   188 PHYSFS_Io *__PHYSFS_createNativeIo(const char *path, const int mode)

   189 {

   190     PHYSFS_Io *io = NULL;

   191     NativeIoInfo *info = NULL;

   192     void *handle = NULL;

   193     char *pathdup = NULL;

   194 

   195     assert((mode == 'r') || (mode == 'w') || (mode == 'a'));

   196 

   197     io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   198     GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

   199     info = (NativeIoInfo *) allocator.Malloc(sizeof (NativeIoInfo));

   200     GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

   201     pathdup = (char *) allocator.Malloc(strlen(path) + 1);

   202     GOTO_IF_MACRO(!pathdup, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

   203 

   204     if (mode == 'r')

   205         handle = __PHYSFS_platformOpenRead(path);

   206     else if (mode == 'w')

   207         handle = __PHYSFS_platformOpenWrite(path);

   208     else if (mode == 'a')

   209         handle = __PHYSFS_platformOpenAppend(path);

   210 

   211     GOTO_IF_MACRO(!handle, ERRPASS, createNativeIo_failed);

   212 

   213     strcpy(pathdup, path);

   214     info->handle = handle;

   215     info->path = pathdup;

   216     info->mode = mode;

   217     memcpy(io, &__PHYSFS_nativeIoInterface, sizeof (*io));

   218     io->opaque = info;

   219     return io;

   220 

   221 createNativeIo_failed:

   222     if (handle != NULL) __PHYSFS_platformClose(handle);

   223     if (pathdup != NULL) allocator.Free(pathdup);

   224     if (info != NULL) allocator.Free(info);

   225     if (io != NULL) allocator.Free(io);

   226     return NULL;

   227 } /* __PHYSFS_createNativeIo */

   228 

   229 

   230 /* PHYSFS_Io implementation for i/o to a memory buffer... */

   231 

   232 typedef struct __PHYSFS_MemoryIoInfo

   233 {

   234     const PHYSFS_uint8 *buf;

   235     PHYSFS_uint64 len;

   236     PHYSFS_uint64 pos;

   237     PHYSFS_Io *parent;

   238     volatile PHYSFS_uint32 refcount;

   239     void (*destruct)(void *);

   240 } MemoryIoInfo;

   241 

   242 static PHYSFS_sint64 memoryIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

   243 {

   244     MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   245     const PHYSFS_uint64 avail = info->len - info->pos;

   246     assert(avail <= info->len);

   247 

   248     if (avail == 0)

   249         return 0;  /* we're at EOF; nothing to do. */

   250 

   251     if (len > avail)

   252         len = avail;

   253 

   254     memcpy(buf, info->buf + info->pos, (size_t) len);

   255     info->pos += len;

   256     return len;

   257 } /* memoryIo_read */

   258 

   259 static PHYSFS_sint64 memoryIo_write(PHYSFS_Io *io, const void *buffer,

   260                                     PHYSFS_uint64 len)

   261 {

   262     BAIL_MACRO(PHYSFS_ERR_OPEN_FOR_READING, -1);

   263 } /* memoryIo_write */

   264 

   265 static int memoryIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

   266 {

   267     MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   268     BAIL_IF_MACRO(offset > info->len, PHYSFS_ERR_PAST_EOF, 0);

   269     info->pos = offset;

   270     return 1;

   271 } /* memoryIo_seek */

   272 

   273 static PHYSFS_sint64 memoryIo_tell(PHYSFS_Io *io)

   274 {

   275     const MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   276     return (PHYSFS_sint64) info->pos;

   277 } /* memoryIo_tell */

   278 

   279 static PHYSFS_sint64 memoryIo_length(PHYSFS_Io *io)

   280 {

   281     const MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   282     return (PHYSFS_sint64) info->len;

   283 } /* memoryIo_length */

   284 

   285 static PHYSFS_Io *memoryIo_duplicate(PHYSFS_Io *io)

   286 {

   287     MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   288     MemoryIoInfo *newinfo = NULL;

   289     PHYSFS_Io *parent = info->parent;

   290     PHYSFS_Io *retval = NULL;

   291 

   292     /* avoid deep copies. */

   293     assert((!parent) || (!((MemoryIoInfo *) parent->opaque)->parent) );

   294 

   295     /* share the buffer between duplicates. */

   296     if (parent != NULL)  /* dup the parent, increment its refcount. */

   297         return parent->duplicate(parent);

   298 

   299     /* we're the parent. */

   300 

   301     retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   302     BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   303     newinfo = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));

   304     if (!newinfo)

   305     {

   306         allocator.Free(retval);

   307         BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   308     } /* if */

   309 

   310     /* !!! FIXME: want lockless atomic increment. */

   311     __PHYSFS_platformGrabMutex(stateLock);

   312     info->refcount++;

   313     __PHYSFS_platformReleaseMutex(stateLock);

   314 

   315     memset(newinfo, '\0', sizeof (*info));

   316     newinfo->buf = info->buf;

   317     newinfo->len = info->len;

   318     newinfo->pos = 0;

   319     newinfo->parent = io;

   320     newinfo->refcount = 0;

   321     newinfo->destruct = NULL;

   322 

   323     memcpy(retval, io, sizeof (*retval));

   324     retval->opaque = newinfo;

   325     return retval;

   326 } /* memoryIo_duplicate */

   327 

   328 static int memoryIo_flush(PHYSFS_Io *io) { return 1;  /* it's read-only. */ }

   329 

   330 static void memoryIo_destroy(PHYSFS_Io *io)

   331 {

   332     MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;

   333     PHYSFS_Io *parent = info->parent;

   334     int should_die = 0;

   335 

   336     if (parent != NULL)

   337     {

   338         assert(info->buf == ((MemoryIoInfo *) info->parent->opaque)->buf);

   339         assert(info->len == ((MemoryIoInfo *) info->parent->opaque)->len);

   340         assert(info->refcount == 0);

   341         assert(info->destruct == NULL);

   342         allocator.Free(info);

   343         allocator.Free(io);

   344         parent->destroy(parent);  /* decrements refcount. */

   345         return;

   346     } /* if */

   347 

   348     /* we _are_ the parent. */

   349     assert(info->refcount > 0);  /* even in a race, we hold a reference. */

   350 

   351     /* !!! FIXME: want lockless atomic decrement. */

   352     __PHYSFS_platformGrabMutex(stateLock);

   353     info->refcount--;

   354     should_die = (info->refcount == 0);

   355     __PHYSFS_platformReleaseMutex(stateLock);

   356 

   357     if (should_die)

   358     {

   359         void (*destruct)(void *) = info->destruct;

   360         void *buf = (void *) info->buf;

   361         io->opaque = NULL;  /* kill this here in case of race. */

   362         allocator.Free(info);

   363         allocator.Free(io);

   364         if (destruct != NULL)

   365             destruct(buf);

   366     } /* if */

   367 } /* memoryIo_destroy */

   368 

   369 

   370 static const PHYSFS_Io __PHYSFS_memoryIoInterface =

   371 {

   372     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   373     memoryIo_read,

   374     memoryIo_write,

   375     memoryIo_seek,

   376     memoryIo_tell,

   377     memoryIo_length,

   378     memoryIo_duplicate,

   379     memoryIo_flush,

   380     memoryIo_destroy

   381 };

   382 

   383 PHYSFS_Io *__PHYSFS_createMemoryIo(const void *buf, PHYSFS_uint64 len,

   384                                    void (*destruct)(void *))

   385 {

   386     PHYSFS_Io *io = NULL;

   387     MemoryIoInfo *info = NULL;

   388 

   389     io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   390     GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);

   391     info = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));

   392     GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);

   393 

   394     memset(info, '\0', sizeof (*info));

   395     info->buf = (const PHYSFS_uint8 *) buf;

   396     info->len = len;

   397     info->pos = 0;

   398     info->parent = NULL;

   399     info->refcount = 1;

   400     info->destruct = destruct;

   401 

   402     memcpy(io, &__PHYSFS_memoryIoInterface, sizeof (*io));

   403     io->opaque = info;

   404     return io;

   405 

   406 createMemoryIo_failed:

   407     if (info != NULL) allocator.Free(info);

   408     if (io != NULL) allocator.Free(io);

   409     return NULL;

   410 } /* __PHYSFS_createMemoryIo */

   411 

   412 

   413 /* PHYSFS_Io implementation for i/o to a PHYSFS_File... */

   414 

   415 static PHYSFS_sint64 handleIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

   416 {

   417     return PHYSFS_readBytes((PHYSFS_File *) io->opaque, buf, len);

   418 } /* handleIo_read */

   419 

   420 static PHYSFS_sint64 handleIo_write(PHYSFS_Io *io, const void *buffer,

   421                                     PHYSFS_uint64 len)

   422 {

   423     return PHYSFS_writeBytes((PHYSFS_File *) io->opaque, buffer, len);

   424 } /* handleIo_write */

   425 

   426 static int handleIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

   427 {

   428     return PHYSFS_seek((PHYSFS_File *) io->opaque, offset);

   429 } /* handleIo_seek */

   430 

   431 static PHYSFS_sint64 handleIo_tell(PHYSFS_Io *io)

   432 {

   433     return PHYSFS_tell((PHYSFS_File *) io->opaque);

   434 } /* handleIo_tell */

   435 

   436 static PHYSFS_sint64 handleIo_length(PHYSFS_Io *io)

   437 {

   438     return PHYSFS_fileLength((PHYSFS_File *) io->opaque);

   439 } /* handleIo_length */

   440 

   441 static PHYSFS_Io *handleIo_duplicate(PHYSFS_Io *io)

   442 {

   443     /*

   444      * There's no duplicate at the PHYSFS_File level, so we break the

   445      *  abstraction. We're allowed to: we're physfs.c!

   446      */

   447     FileHandle *origfh = (FileHandle *) io->opaque;

   448     FileHandle *newfh = (FileHandle *) allocator.Malloc(sizeof (FileHandle));

   449     PHYSFS_Io *retval = NULL;

   450 

   451     GOTO_IF_MACRO(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

   452     memset(newfh, '\0', sizeof (*newfh));

   453 

   454     retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   455     GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

   456 

   457 #if 0  /* we don't buffer the duplicate, at least not at the moment. */

   458     if (origfh->buffer != NULL)

   459     {

   460         newfh->buffer = (PHYSFS_uint8 *) allocator.Malloc(origfh->bufsize);

   461         if (!newfh->buffer)

   462             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

   463         newfh->bufsize = origfh->bufsize;

   464     } /* if */

   465 #endif

   466 

   467     newfh->io = origfh->io->duplicate(origfh->io);

   468     GOTO_IF_MACRO(!newfh->io, ERRPASS, handleIo_dupe_failed);

   469 

   470     newfh->forReading = origfh->forReading;

   471     newfh->dirHandle = origfh->dirHandle;

   472 

   473     __PHYSFS_platformGrabMutex(stateLock);

   474     if (newfh->forReading)

   475     {

   476         newfh->next = openReadList;

   477         openReadList = newfh;

   478     } /* if */

   479     else

   480     {

   481         newfh->next = openWriteList;

   482         openWriteList = newfh;

   483     } /* else */

   484     __PHYSFS_platformReleaseMutex(stateLock);

   485 

   486     memcpy(retval, io, sizeof (PHYSFS_Io));

   487     retval->opaque = newfh;

   488     return retval;

   489     

   490 handleIo_dupe_failed:

   491     if (newfh)

   492     {

   493         if (newfh->io != NULL) newfh->io->destroy(newfh->io);

   494         if (newfh->buffer != NULL) allocator.Free(newfh->buffer);

   495         allocator.Free(newfh);

   496     } /* if */

   497 

   498     return NULL;

   499 } /* handleIo_duplicate */

   500 

   501 static int handleIo_flush(PHYSFS_Io *io)

   502 {

   503     return PHYSFS_flush((PHYSFS_File *) io->opaque);

   504 } /* handleIo_flush */

   505 

   506 static void handleIo_destroy(PHYSFS_Io *io)

   507 {

   508     if (io->opaque != NULL)

   509         PHYSFS_close((PHYSFS_File *) io->opaque);

   510     allocator.Free(io);

   511 } /* handleIo_destroy */

   512 

   513 static const PHYSFS_Io __PHYSFS_handleIoInterface =

   514 {

   515     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   516     handleIo_read,

   517     handleIo_write,

   518     handleIo_seek,

   519     handleIo_tell,

   520     handleIo_length,

   521     handleIo_duplicate,

   522     handleIo_flush,

   523     handleIo_destroy

   524 };

   525 

   526 static PHYSFS_Io *__PHYSFS_createHandleIo(PHYSFS_File *f)

   527 {

   528     PHYSFS_Io *io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

   529     BAIL_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   530     memcpy(io, &__PHYSFS_handleIoInterface, sizeof (*io));

   531     io->opaque = f;

   532     return io;

   533 } /* __PHYSFS_createHandleIo */

   534 

   535 

   536 /* functions ... */

   537 

   538 typedef struct

   539 {

   540     char **list;

   541     PHYSFS_uint32 size;

   542     PHYSFS_ErrorCode errcode;

   543 } EnumStringListCallbackData;

   544 

   545 static void enumStringListCallback(void *data, const char *str)

   546 {

   547     void *ptr;

   548     char *newstr;

   549     EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data;

   550 

   551     if (pecd->errcode)

   552         return;

   553 

   554     ptr = allocator.Realloc(pecd->list, (pecd->size + 2) * sizeof (char *));

   555     newstr = (char *) allocator.Malloc(strlen(str) + 1);

   556     if (ptr != NULL)

   557         pecd->list = (char **) ptr;

   558 

   559     if ((ptr == NULL) || (newstr == NULL))

   560     {

   561         pecd->errcode = PHYSFS_ERR_OUT_OF_MEMORY;

   562         pecd->list[pecd->size] = NULL;

   563         PHYSFS_freeList(pecd->list);

   564         return;

   565     } /* if */

   566 

   567     strcpy(newstr, str);

   568     pecd->list[pecd->size] = newstr;

   569     pecd->size++;

   570 } /* enumStringListCallback */

   571 

   572 

   573 static char **doEnumStringList(void (*func)(PHYSFS_StringCallback, void *))

   574 {

   575     EnumStringListCallbackData ecd;

   576     memset(&ecd, '\0', sizeof (ecd));

   577     ecd.list = (char **) allocator.Malloc(sizeof (char *));

   578     BAIL_IF_MACRO(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   579     func(enumStringListCallback, &ecd);

   580 

   581     if (ecd.errcode)

   582     {

   583         __PHYSFS_setError(ecd.errcode);

   584         return NULL;

   585     } /* if */

   586 

   587     ecd.list[ecd.size] = NULL;

   588     return ecd.list;

   589 } /* doEnumStringList */

   590 

   591 

   592 static void __PHYSFS_bubble_sort(void *a, size_t lo, size_t hi,

   593                                  int (*cmpfn)(void *, size_t, size_t),

   594                                  void (*swapfn)(void *, size_t, size_t))

   595 {

   596     size_t i;

   597     int sorted;

   598 

   599     do

   600     {

   601         sorted = 1;

   602         for (i = lo; i < hi; i++)

   603         {

   604             if (cmpfn(a, i, i + 1) > 0)

   605             {

   606                 swapfn(a, i, i + 1);

   607                 sorted = 0;

   608             } /* if */

   609         } /* for */

   610     } while (!sorted);

   611 } /* __PHYSFS_bubble_sort */

   612 

   613 

   614 static void __PHYSFS_quick_sort(void *a, size_t lo, size_t hi,

   615                          int (*cmpfn)(void *, size_t, size_t),

   616                          void (*swapfn)(void *, size_t, size_t))

   617 {

   618     size_t i;

   619     size_t j;

   620     size_t v;

   621 

   622     if ((hi - lo) <= PHYSFS_QUICKSORT_THRESHOLD)

   623         __PHYSFS_bubble_sort(a, lo, hi, cmpfn, swapfn);

   624     else

   625     {

   626         i = (hi + lo) / 2;

   627 

   628         if (cmpfn(a, lo, i) > 0) swapfn(a, lo, i);

   629         if (cmpfn(a, lo, hi) > 0) swapfn(a, lo, hi);

   630         if (cmpfn(a, i, hi) > 0) swapfn(a, i, hi);

   631 

   632         j = hi - 1;

   633         swapfn(a, i, j);

   634         i = lo;

   635         v = j;

   636         while (1)

   637         {

   638             while(cmpfn(a, ++i, v) < 0) { /* do nothing */ }

   639             while(cmpfn(a, --j, v) > 0) { /* do nothing */ }

   640             if (j < i)

   641                 break;

   642             swapfn(a, i, j);

   643         } /* while */

   644         if (i != (hi-1))

   645             swapfn(a, i, hi-1);

   646         __PHYSFS_quick_sort(a, lo, j, cmpfn, swapfn);

   647         __PHYSFS_quick_sort(a, i+1, hi, cmpfn, swapfn);

   648     } /* else */

   649 } /* __PHYSFS_quick_sort */

   650 

   651 

   652 void __PHYSFS_sort(void *entries, size_t max,

   653                    int (*cmpfn)(void *, size_t, size_t),

   654                    void (*swapfn)(void *, size_t, size_t))

   655 {

   656     /*

   657      * Quicksort w/ Bubblesort fallback algorithm inspired by code from here:

   658      *   http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html

   659      */

   660     if (max > 0)

   661         __PHYSFS_quick_sort(entries, 0, max - 1, cmpfn, swapfn);

   662 } /* __PHYSFS_sort */

   663 

   664 

   665 static ErrState *findErrorForCurrentThread(void)

   666 {

   667     ErrState *i;

   668     void *tid;

   669 

   670     if (errorLock != NULL)

   671         __PHYSFS_platformGrabMutex(errorLock);

   672 

   673     if (errorStates != NULL)

   674     {

   675         tid = __PHYSFS_platformGetThreadID();

   676 

   677         for (i = errorStates; i != NULL; i = i->next)

   678         {

   679             if (i->tid == tid)

   680             {

   681                 if (errorLock != NULL)

   682                     __PHYSFS_platformReleaseMutex(errorLock);

   683                 return i;

   684             } /* if */

   685         } /* for */

   686     } /* if */

   687 

   688     if (errorLock != NULL)

   689         __PHYSFS_platformReleaseMutex(errorLock);

   690 

   691     return NULL;   /* no error available. */

   692 } /* findErrorForCurrentThread */

   693 

   694 

   695 void __PHYSFS_setError(const PHYSFS_ErrorCode errcode)

   696 {

   697     ErrState *err;

   698 

   699     if (!errcode)

   700         return;

   701 

   702     err = findErrorForCurrentThread();

   703     if (err == NULL)

   704     {

   705         err = (ErrState *) allocator.Malloc(sizeof (ErrState));

   706         if (err == NULL)

   707             return;   /* uhh...? */

   708 

   709         memset(err, '\0', sizeof (ErrState));

   710         err->tid = __PHYSFS_platformGetThreadID();

   711 

   712         if (errorLock != NULL)

   713             __PHYSFS_platformGrabMutex(errorLock);

   714 

   715         err->next = errorStates;

   716         errorStates = err;

   717 

   718         if (errorLock != NULL)

   719             __PHYSFS_platformReleaseMutex(errorLock);

   720     } /* if */

   721 

   722     err->code = errcode;

   723 } /* __PHYSFS_setError */

   724 

   725 

   726 PHYSFS_ErrorCode PHYSFS_getLastErrorCode(void)

   727 {

   728     ErrState *err = findErrorForCurrentThread();

   729     const PHYSFS_ErrorCode retval = (err) ? err->code : PHYSFS_ERR_OK;

   730     if (err)

   731         err->code = PHYSFS_ERR_OK;

   732     return retval;

   733 } /* PHYSFS_getLastErrorCode */

   734 

   735 

   736 PHYSFS_DECL const char *PHYSFS_getErrorByCode(PHYSFS_ErrorCode code)

   737 {

   738     switch (code)

   739     {

   740         case PHYSFS_ERR_OK: return "no error";

   741         case PHYSFS_ERR_OTHER_ERROR: return "unknown error";

   742         case PHYSFS_ERR_OUT_OF_MEMORY: return "out of memory";

   743         case PHYSFS_ERR_NOT_INITIALIZED: return "not initialized";

   744         case PHYSFS_ERR_IS_INITIALIZED: return "already initialized";

   745         case PHYSFS_ERR_ARGV0_IS_NULL: return "argv[0] is NULL";

   746         case PHYSFS_ERR_UNSUPPORTED: return "unsupported";

   747         case PHYSFS_ERR_PAST_EOF: return "past end of file";

   748         case PHYSFS_ERR_FILES_STILL_OPEN: return "files still open";

   749         case PHYSFS_ERR_INVALID_ARGUMENT: return "invalid argument";

   750         case PHYSFS_ERR_NOT_MOUNTED: return "not mounted";

   751         case PHYSFS_ERR_NO_SUCH_PATH: return "no such path";

   752         case PHYSFS_ERR_SYMLINK_FORBIDDEN: return "symlinks are forbidden";

   753         case PHYSFS_ERR_NO_WRITE_DIR: return "write directory is not set";

   754         case PHYSFS_ERR_OPEN_FOR_READING: return "file open for reading";

   755         case PHYSFS_ERR_OPEN_FOR_WRITING: return "file open for writing";

   756         case PHYSFS_ERR_NOT_A_FILE: return "not a file";

   757         case PHYSFS_ERR_READ_ONLY: return "read-only filesystem";

   758         case PHYSFS_ERR_CORRUPT: return "corrupted";

   759         case PHYSFS_ERR_SYMLINK_LOOP: return "infinite symbolic link loop";

   760         case PHYSFS_ERR_IO: return "i/o error";

   761         case PHYSFS_ERR_PERMISSION: return "permission denied";

   762         case PHYSFS_ERR_NO_SPACE: return "no space available for writing";

   763         case PHYSFS_ERR_BAD_FILENAME: return "filename is illegal or insecure";

   764         case PHYSFS_ERR_BUSY: return "tried to modify a file the OS needs";

   765         case PHYSFS_ERR_DIR_NOT_EMPTY: return "directory isn't empty";

   766         case PHYSFS_ERR_OS_ERROR: return "OS reported an error";

   767     } /* switch */

   768 

   769     return NULL;  /* don't know this error code. */

   770 } /* PHYSFS_getErrorByCode */

   771 

   772 

   773 void PHYSFS_setErrorCode(PHYSFS_ErrorCode code)

   774 {

   775     __PHYSFS_setError(code);

   776 } /* PHYSFS_setErrorCode */

   777 

   778 

   779 const char *PHYSFS_getLastError(void)

   780 {

   781     const PHYSFS_ErrorCode err = PHYSFS_getLastErrorCode();

   782     return (err) ? PHYSFS_getErrorByCode(err) : NULL;

   783 } /* PHYSFS_getLastError */

   784 

   785 

   786 /* MAKE SURE that errorLock is held before calling this! */

   787 static void freeErrorStates(void)

   788 {

   789     ErrState *i;

   790     ErrState *next;

   791 

   792     for (i = errorStates; i != NULL; i = next)

   793     {

   794         next = i->next;

   795         allocator.Free(i);

   796     } /* for */

   797 

   798     errorStates = NULL;

   799 } /* freeErrorStates */

   800 

   801 

   802 void PHYSFS_getLinkedVersion(PHYSFS_Version *ver)

   803 {

   804     if (ver != NULL)

   805     {

   806         ver->major = PHYSFS_VER_MAJOR;

   807         ver->minor = PHYSFS_VER_MINOR;

   808         ver->patch = PHYSFS_VER_PATCH;

   809     } /* if */

   810 } /* PHYSFS_getLinkedVersion */

   811 

   812 

   813 static const char *find_filename_extension(const char *fname)

   814 {

   815     const char *retval = NULL;

   816     if (fname != NULL)

   817     {

   818         const char *p = strchr(fname, '.');

   819         retval = p;

   820 

   821         while (p != NULL)

   822         {

   823             p = strchr(p + 1, '.');

   824             if (p != NULL)

   825                 retval = p;

   826         } /* while */

   827 

   828         if (retval != NULL)

   829             retval++;  /* skip '.' */

   830     } /* if */

   831 

   832     return retval;

   833 } /* find_filename_extension */

   834 

   835 

   836 static DirHandle *tryOpenDir(PHYSFS_Io *io, const PHYSFS_Archiver *funcs,

   837                              const char *d, int forWriting)

   838 {

   839     DirHandle *retval = NULL;

   840     void *opaque = NULL;

   841 

   842     if (io != NULL)

   843         BAIL_IF_MACRO(!io->seek(io, 0), ERRPASS, NULL);

   844 

   845     opaque = funcs->openArchive(io, d, forWriting);

   846     if (opaque != NULL)

   847     {

   848         retval = (DirHandle *) allocator.Malloc(sizeof (DirHandle));

   849         if (retval == NULL)

   850             funcs->closeArchive(opaque);

   851         else

   852         {

   853             memset(retval, '\0', sizeof (DirHandle));

   854             retval->mountPoint = NULL;

   855             retval->funcs = funcs;

   856             retval->opaque = opaque;

   857         } /* else */

   858     } /* if */

   859 

   860     return retval;

   861 } /* tryOpenDir */

   862 

   863 

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

   865 {

   866     DirHandle *retval = NULL;

   867     const PHYSFS_Archiver **i;

   868     const char *ext;

   869 

   870     assert((io != NULL) || (d != NULL));

   871 

   872     if (io == NULL)

   873     {

   874         /* DIR gets first shot (unlike the rest, it doesn't deal with files). */

   875         retval = tryOpenDir(io, &__PHYSFS_Archiver_DIR, d, forWriting);

   876         if (retval != NULL)

   877             return retval;

   878 

   879         io = __PHYSFS_createNativeIo(d, forWriting ? 'w' : 'r');

   880         BAIL_IF_MACRO(!io, ERRPASS, 0);

   881     } /* if */

   882 

   883     ext = find_filename_extension(d);

   884     if (ext != NULL)

   885     {

   886         /* Look for archivers with matching file extensions first... */

   887         for (i = archivers; (*i != NULL) && (retval == NULL); i++)

   888         {

   889             if (__PHYSFS_stricmpASCII(ext, (*i)->info.extension) == 0)

   890                 retval = tryOpenDir(io, *i, d, forWriting);

   891         } /* for */

   892 

   893         /* failing an exact file extension match, try all the others... */

   894         for (i = archivers; (*i != NULL) && (retval == NULL); i++)

   895         {

   896             if (__PHYSFS_stricmpASCII(ext, (*i)->info.extension) != 0)

   897                 retval = tryOpenDir(io, *i, d, forWriting);

   898         } /* for */

   899     } /* if */

   900 

   901     else  /* no extension? Try them all. */

   902     {

   903         for (i = archivers; (*i != NULL) && (retval == NULL); i++)

   904             retval = tryOpenDir(io, *i, d, forWriting);

   905     } /* else */

   906 

   907     BAIL_IF_MACRO(!retval, PHYSFS_ERR_UNSUPPORTED, NULL);

   908     return retval;

   909 } /* openDirectory */

   910 

   911 

   912 /*

   913  * Make a platform-independent path string sane. Doesn't actually check the

   914  *  file hierarchy, it just cleans up the string.

   915  *  (dst) must be a buffer at least as big as (src), as this is where the

   916  *  cleaned up string is deposited.

   917  * If there are illegal bits in the path (".." entries, etc) then we

   918  *  return zero and (dst) is undefined. Non-zero if the path was sanitized.

   919  */

   920 static int sanitizePlatformIndependentPath(const char *src, char *dst)

   921 {

   922     char *prev;

   923     char ch;

   924 

   925     while (*src == '/')  /* skip initial '/' chars... */

   926         src++;

   927 

   928     prev = dst;

   929     do

   930     {

   931         ch = *(src++);

   932 

   933         if ((ch == ':') || (ch == '\\'))  /* illegal chars in a physfs path. */

   934             BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);

   935 

   936         if (ch == '/')   /* path separator. */

   937         {

   938             *dst = '\0';  /* "." and ".." are illegal pathnames. */

   939             if ((strcmp(prev, ".") == 0) || (strcmp(prev, "..") == 0))

   940                 BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);

   941 

   942             while (*src == '/')   /* chop out doubles... */

   943                 src++;

   944 

   945             if (*src == '\0') /* ends with a pathsep? */

   946                 break;  /* we're done, don't add final pathsep to dst. */

   947 

   948             prev = dst + 1;

   949         } /* if */

   950 

   951         *(dst++) = ch;

   952     } while (ch != '\0');

   953 

   954     return 1;

   955 } /* sanitizePlatformIndependentPath */

   956 

   957 

   958 /*

   959  * Figure out if (fname) is part of (h)'s mountpoint. (fname) must be an

   960  *  output from sanitizePlatformIndependentPath(), so that it is in a known

   961  *  state.

   962  *

   963  * This only finds legitimate segments of a mountpoint. If the mountpoint is

   964  *  "/a/b/c" and (fname) is "/a/b/c", "/", or "/a/b/c/d", then the results are

   965  *  all zero. "/a/b" will succeed, though.

   966  */

   967 static int partOfMountPoint(DirHandle *h, char *fname)

   968 {

   969     /* !!! FIXME: This code feels gross. */

   970     int rc;

   971     size_t len, mntpntlen;

   972 

   973     if (h->mountPoint == NULL)

   974         return 0;

   975     else if (*fname == '\0')

   976         return 1;

   977 

   978     len = strlen(fname);

   979     mntpntlen = strlen(h->mountPoint);

   980     if (len > mntpntlen)  /* can't be a subset of mountpoint. */

   981         return 0;

   982 

   983     /* if true, must be not a match or a complete match, but not a subset. */

   984     if ((len + 1) == mntpntlen)

   985         return 0;

   986 

   987     rc = strncmp(fname, h->mountPoint, len); /* !!! FIXME: case insensitive? */

   988     if (rc != 0)

   989         return 0;  /* not a match. */

   990 

   991     /* make sure /a/b matches /a/b/ and not /a/bc ... */

   992     return h->mountPoint[len] == '/';

   993 } /* partOfMountPoint */

   994 

   995 

   996 static DirHandle *createDirHandle(PHYSFS_Io *io, const char *newDir,

   997                                   const char *mountPoint, int forWriting)

   998 {

   999     DirHandle *dirHandle = NULL;

  1000     char *tmpmntpnt = NULL;

  1001 

  1002     if (mountPoint != NULL)

  1003     {

  1004         const size_t len = strlen(mountPoint) + 1;

  1005         tmpmntpnt = (char *) __PHYSFS_smallAlloc(len);

  1006         GOTO_IF_MACRO(!tmpmntpnt, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

  1007         if (!sanitizePlatformIndependentPath(mountPoint, tmpmntpnt))

  1008             goto badDirHandle;

  1009         mountPoint = tmpmntpnt;  /* sanitized version. */

  1010     } /* if */

  1011 

  1012     dirHandle = openDirectory(io, newDir, forWriting);

  1013     GOTO_IF_MACRO(!dirHandle, ERRPASS, badDirHandle);

  1014 

  1015     if (newDir == NULL)

  1016         dirHandle->dirName = NULL;

  1017     else

  1018     {

  1019         dirHandle->dirName = (char *) allocator.Malloc(strlen(newDir) + 1);

  1020         if (!dirHandle->dirName)

  1021             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

  1022         strcpy(dirHandle->dirName, newDir);

  1023     } /* else */

  1024 

  1025     if ((mountPoint != NULL) && (*mountPoint != '\0'))

  1026     {

  1027         dirHandle->mountPoint = (char *)allocator.Malloc(strlen(mountPoint)+2);

  1028         if (!dirHandle->mountPoint)

  1029             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

  1030         strcpy(dirHandle->mountPoint, mountPoint);

  1031         strcat(dirHandle->mountPoint, "/");

  1032     } /* if */

  1033 

  1034     __PHYSFS_smallFree(tmpmntpnt);

  1035     return dirHandle;

  1036 

  1037 badDirHandle:

  1038     if (dirHandle != NULL)

  1039     {

  1040         dirHandle->funcs->closeArchive(dirHandle->opaque);

  1041         allocator.Free(dirHandle->dirName);

  1042         allocator.Free(dirHandle->mountPoint);

  1043         allocator.Free(dirHandle);

  1044     } /* if */

  1045 

  1046     __PHYSFS_smallFree(tmpmntpnt);

  1047     return NULL;

  1048 } /* createDirHandle */

  1049 

  1050 

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

  1052 static int freeDirHandle(DirHandle *dh, FileHandle *openList)

  1053 {

  1054     FileHandle *i;

  1055 

  1056     if (dh == NULL)

  1057         return 1;

  1058 

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

  1060         BAIL_IF_MACRO(i->dirHandle == dh, PHYSFS_ERR_FILES_STILL_OPEN, 0);

  1061 

  1062     dh->funcs->closeArchive(dh->opaque);

  1063     allocator.Free(dh->dirName);

  1064     allocator.Free(dh->mountPoint);

  1065     allocator.Free(dh);

  1066     return 1;

  1067 } /* freeDirHandle */

  1068 

  1069 

  1070 static char *calculateBaseDir(const char *argv0)

  1071 {

  1072     const char dirsep = __PHYSFS_platformDirSeparator;

  1073     char *retval = NULL;

  1074     char *ptr = NULL;

  1075 

  1076     /* Give the platform layer first shot at this. */

  1077     retval = __PHYSFS_platformCalcBaseDir(argv0);

  1078     if (retval != NULL)

  1079         return retval;

  1080 

  1081     /* We need argv0 to go on. */

  1082     BAIL_IF_MACRO(argv0 == NULL, PHYSFS_ERR_ARGV0_IS_NULL, NULL);

  1083 

  1084     ptr = strrchr(argv0, dirsep);

  1085     if (ptr != NULL)

  1086     {

  1087         const size_t size = ((size_t) (ptr - argv0)) + 1;

  1088         retval = (char *) allocator.Malloc(size + 1);

  1089         BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

  1090         memcpy(retval, argv0, size);

  1091         retval[size] = '\0';

  1092         return retval;

  1093     } /* if */

  1094 

  1095     /* argv0 wasn't helpful. */

  1096     BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, NULL);

  1097 } /* calculateBaseDir */

  1098 

  1099 

  1100 static int initializeMutexes(void)

  1101 {

  1102     errorLock = __PHYSFS_platformCreateMutex();

  1103     if (errorLock == NULL)

  1104         goto initializeMutexes_failed;

  1105 

  1106     stateLock = __PHYSFS_platformCreateMutex();

  1107     if (stateLock == NULL)

  1108         goto initializeMutexes_failed;

  1109 

  1110     return 1;  /* success. */

  1111 

  1112 initializeMutexes_failed:

  1113     if (errorLock != NULL)

  1114         __PHYSFS_platformDestroyMutex(errorLock);

  1115 

  1116     if (stateLock != NULL)

  1117         __PHYSFS_platformDestroyMutex(stateLock);

  1118 

  1119     errorLock = stateLock = NULL;

  1120     return 0;  /* failed. */

  1121 } /* initializeMutexes */

  1122 

  1123 

  1124 static void setDefaultAllocator(void);

  1125 

  1126 static int initStaticArchivers(void)

  1127 {

  1128     const size_t numStaticArchivers = __PHYSFS_ARRAYLEN(staticArchivers);

  1129     const size_t len = numStaticArchivers * sizeof (void *);

  1130     size_t i;

  1131 

  1132     assert(numStaticArchivers > 0);  /* seriously, none at all?! */

  1133     assert(staticArchivers[numStaticArchivers - 1] == NULL);

  1134