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 /* General PhysicsFS state ... */

    50 static int initialized = 0;

    51 static ErrState *errorStates = NULL;

    52 static DirHandle *searchPath = NULL;

    53 static DirHandle *writeDir = NULL;

    54 static FileHandle *openWriteList = NULL;

    55 static FileHandle *openReadList = NULL;

    56 static char *baseDir = NULL;

    57 static char *userDir = NULL;

    58 static char *prefDir = NULL;

    59 static int allowSymLinks = 0;

    60 static const PHYSFS_Archiver **archivers = NULL;

    61 static const PHYSFS_ArchiveInfo **archiveInfo = NULL;

    62 static volatile size_t numArchivers = 0;

    63 

    64 /* mutexes ... */

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

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

    67 

    68 /* allocator ... */

    69 static int externalAllocator = 0;

    70 PHYSFS_Allocator allocator;

    71 

    72 

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

    74 

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

    76 typedef struct __PHYSFS_NativeIoInfo

    77 {

    78     void *handle;

    79     const char *path;

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

    81 } NativeIoInfo;

    82 

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

    84 {

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

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

    87 } /* nativeIo_read */

    88 

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

    90                                     PHYSFS_uint64 len)

    91 {

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

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

    94 } /* nativeIo_write */

    95 

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

    97 {

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

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

   100 } /* nativeIo_seek */

   101 

   102 static PHYSFS_sint64 nativeIo_tell(PHYSFS_Io *io)

   103 {

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

   105     return __PHYSFS_platformTell(info->handle);

   106 } /* nativeIo_tell */

   107 

   108 static PHYSFS_sint64 nativeIo_length(PHYSFS_Io *io)

   109 {

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

   111     return __PHYSFS_platformFileLength(info->handle);

   112 } /* nativeIo_length */

   113 

   114 static PHYSFS_Io *nativeIo_duplicate(PHYSFS_Io *io)

   115 {

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

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

   118 } /* nativeIo_duplicate */

   119 

   120 static int nativeIo_flush(PHYSFS_Io *io)

   121 {

   122     return __PHYSFS_platformFlush(io->opaque);

   123 } /* nativeIo_flush */

   124 

   125 static void nativeIo_destroy(PHYSFS_Io *io)

   126 {

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

   128     __PHYSFS_platformClose(info->handle);

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

   130     allocator.Free(info);

   131     allocator.Free(io);

   132 } /* nativeIo_destroy */

   133 

   134 static const PHYSFS_Io __PHYSFS_nativeIoInterface =

   135 {

   136     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   137     nativeIo_read,

   138     nativeIo_write,

   139     nativeIo_seek,

   140     nativeIo_tell,

   141     nativeIo_length,

   142     nativeIo_duplicate,

   143     nativeIo_flush,

   144     nativeIo_destroy

   145 };

   146 

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

   148 {

   149     PHYSFS_Io *io = NULL;

   150     NativeIoInfo *info = NULL;

   151     void *handle = NULL;

   152     char *pathdup = NULL;

   153 

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

   155 

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

   157     GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

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

   159     GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

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

   161     GOTO_IF_MACRO(!pathdup, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);

   162 

   163     if (mode == 'r')

   164         handle = __PHYSFS_platformOpenRead(path);

   165     else if (mode == 'w')

   166         handle = __PHYSFS_platformOpenWrite(path);

   167     else if (mode == 'a')

   168         handle = __PHYSFS_platformOpenAppend(path);

   169 

   170     GOTO_IF_MACRO(!handle, ERRPASS, createNativeIo_failed);

   171 

   172     strcpy(pathdup, path);

   173     info->handle = handle;

   174     info->path = pathdup;

   175     info->mode = mode;

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

   177     io->opaque = info;

   178     return io;

   179 

   180 createNativeIo_failed:

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

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

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

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

   185     return NULL;

   186 } /* __PHYSFS_createNativeIo */

   187 

   188 

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

   190 

   191 typedef struct __PHYSFS_MemoryIoInfo

   192 {

   193     const PHYSFS_uint8 *buf;

   194     PHYSFS_uint64 len;

   195     PHYSFS_uint64 pos;

   196     PHYSFS_Io *parent;

   197     volatile PHYSFS_uint32 refcount;

   198     void (*destruct)(void *);

   199 } MemoryIoInfo;

   200 

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

   202 {

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

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

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

   206 

   207     if (avail == 0)

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

   209 

   210     if (len > avail)

   211         len = avail;

   212 

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

   214     info->pos += len;

   215     return len;

   216 } /* memoryIo_read */

   217 

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

   219                                     PHYSFS_uint64 len)

   220 {

   221     BAIL_MACRO(PHYSFS_ERR_OPEN_FOR_READING, -1);

   222 } /* memoryIo_write */

   223 

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

   225 {

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

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

   228     info->pos = offset;

   229     return 1;

   230 } /* memoryIo_seek */

   231 

   232 static PHYSFS_sint64 memoryIo_tell(PHYSFS_Io *io)

   233 {

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

   235     return (PHYSFS_sint64) info->pos;

   236 } /* memoryIo_tell */

   237 

   238 static PHYSFS_sint64 memoryIo_length(PHYSFS_Io *io)

   239 {

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

   241     return (PHYSFS_sint64) info->len;

   242 } /* memoryIo_length */

   243 

   244 static PHYSFS_Io *memoryIo_duplicate(PHYSFS_Io *io)

   245 {

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

   247     MemoryIoInfo *newinfo = NULL;

   248     PHYSFS_Io *parent = info->parent;

   249     PHYSFS_Io *retval = NULL;

   250 

   251     /* avoid deep copies. */

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

   253 

   254     /* share the buffer between duplicates. */

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

   256         return parent->duplicate(parent);

   257 

   258     /* we're the parent. */

   259 

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

   261     BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

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

   263     if (!newinfo)

   264     {

   265         allocator.Free(retval);

   266         BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   267     } /* if */

   268 

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

   270     __PHYSFS_platformGrabMutex(stateLock);

   271     info->refcount++;

   272     __PHYSFS_platformReleaseMutex(stateLock);

   273 

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

   275     newinfo->buf = info->buf;

   276     newinfo->len = info->len;

   277     newinfo->pos = 0;

   278     newinfo->parent = io;

   279     newinfo->refcount = 0;

   280     newinfo->destruct = NULL;

   281 

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

   283     retval->opaque = newinfo;

   284     return retval;

   285 } /* memoryIo_duplicate */

   286 

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

   288 

   289 static void memoryIo_destroy(PHYSFS_Io *io)

   290 {

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

   292     PHYSFS_Io *parent = info->parent;

   293     int should_die = 0;

   294 

   295     if (parent != NULL)

   296     {

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

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

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

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

   301         allocator.Free(info);

   302         allocator.Free(io);

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

   304         return;

   305     } /* if */

   306 

   307     /* we _are_ the parent. */

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

   309 

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

   311     __PHYSFS_platformGrabMutex(stateLock);

   312     info->refcount--;

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

   314     __PHYSFS_platformReleaseMutex(stateLock);

   315 

   316     if (should_die)

   317     {

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

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

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

   321         allocator.Free(info);

   322         allocator.Free(io);

   323         if (destruct != NULL)

   324             destruct(buf);

   325     } /* if */

   326 } /* memoryIo_destroy */

   327 

   328 

   329 static const PHYSFS_Io __PHYSFS_memoryIoInterface =

   330 {

   331     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   332     memoryIo_read,

   333     memoryIo_write,

   334     memoryIo_seek,

   335     memoryIo_tell,

   336     memoryIo_length,

   337     memoryIo_duplicate,

   338     memoryIo_flush,

   339     memoryIo_destroy

   340 };

   341 

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

   343                                    void (*destruct)(void *))

   344 {

   345     PHYSFS_Io *io = NULL;

   346     MemoryIoInfo *info = NULL;

   347 

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

   349     GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);

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

   351     GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);

   352 

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

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

   355     info->len = len;

   356     info->pos = 0;

   357     info->parent = NULL;

   358     info->refcount = 1;

   359     info->destruct = destruct;

   360 

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

   362     io->opaque = info;

   363     return io;

   364 

   365 createMemoryIo_failed:

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

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

   368     return NULL;

   369 } /* __PHYSFS_createMemoryIo */

   370 

   371 

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

   373 

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

   375 {

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

   377 } /* handleIo_read */

   378 

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

   380                                     PHYSFS_uint64 len)

   381 {

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

   383 } /* handleIo_write */

   384 

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

   386 {

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

   388 } /* handleIo_seek */

   389 

   390 static PHYSFS_sint64 handleIo_tell(PHYSFS_Io *io)

   391 {

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

   393 } /* handleIo_tell */

   394 

   395 static PHYSFS_sint64 handleIo_length(PHYSFS_Io *io)

   396 {

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

   398 } /* handleIo_length */

   399 

   400 static PHYSFS_Io *handleIo_duplicate(PHYSFS_Io *io)

   401 {

   402     /*

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

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

   405      */

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

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

   408     PHYSFS_Io *retval = NULL;

   409 

   410     GOTO_IF_MACRO(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

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

   412 

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

   414     GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

   415 

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

   417     if (origfh->buffer != NULL)

   418     {

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

   420         if (!newfh->buffer)

   421             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);

   422         newfh->bufsize = origfh->bufsize;

   423     } /* if */

   424 #endif

   425 

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

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

   428 

   429     newfh->forReading = origfh->forReading;

   430     newfh->dirHandle = origfh->dirHandle;

   431 

   432     __PHYSFS_platformGrabMutex(stateLock);

   433     if (newfh->forReading)

   434     {

   435         newfh->next = openReadList;

   436         openReadList = newfh;

   437     } /* if */

   438     else

   439     {

   440         newfh->next = openWriteList;

   441         openWriteList = newfh;

   442     } /* else */

   443     __PHYSFS_platformReleaseMutex(stateLock);

   444 

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

   446     retval->opaque = newfh;

   447     return retval;

   448     

   449 handleIo_dupe_failed:

   450     if (newfh)

   451     {

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

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

   454         allocator.Free(newfh);

   455     } /* if */

   456 

   457     return NULL;

   458 } /* handleIo_duplicate */

   459 

   460 static int handleIo_flush(PHYSFS_Io *io)

   461 {

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

   463 } /* handleIo_flush */

   464 

   465 static void handleIo_destroy(PHYSFS_Io *io)

   466 {

   467     if (io->opaque != NULL)

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

   469     allocator.Free(io);

   470 } /* handleIo_destroy */

   471 

   472 static const PHYSFS_Io __PHYSFS_handleIoInterface =

   473 {

   474     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   475     handleIo_read,

   476     handleIo_write,

   477     handleIo_seek,

   478     handleIo_tell,

   479     handleIo_length,

   480     handleIo_duplicate,

   481     handleIo_flush,

   482     handleIo_destroy

   483 };

   484 

   485 static PHYSFS_Io *__PHYSFS_createHandleIo(PHYSFS_File *f)

   486 {

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

   488     BAIL_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

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

   490     io->opaque = f;

   491     return io;

   492 } /* __PHYSFS_createHandleIo */

   493 

   494 

   495 /* functions ... */

   496 

   497 typedef struct

   498 {

   499     char **list;

   500     PHYSFS_uint32 size;

   501     PHYSFS_ErrorCode errcode;

   502 } EnumStringListCallbackData;

   503 

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

   505 {

   506     void *ptr;

   507     char *newstr;

   508     EnumStringListCallbackData *pecd = (EnumStringListCallbackData *) data;

   509 

   510     if (pecd->errcode)

   511         return;

   512 

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

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

   515     if (ptr != NULL)

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

   517 

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

   519     {

   520         pecd->errcode = PHYSFS_ERR_OUT_OF_MEMORY;

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

   522         PHYSFS_freeList(pecd->list);

   523         return;

   524     } /* if */

   525 

   526     strcpy(newstr, str);

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

   528     pecd->size++;

   529 } /* enumStringListCallback */

   530 

   531 

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

   533 {

   534     EnumStringListCallbackData ecd;

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

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

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

   538     func(enumStringListCallback, &ecd);

   539 

   540     if (ecd.errcode)

   541     {

   542         PHYSFS_setErrorCode(ecd.errcode);

   543         return NULL;

   544     } /* if */

   545 

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

   547     return ecd.list;

   548 } /* doEnumStringList */

   549 

   550 

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

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

   553                                  void (*swapfn)(void *, size_t, size_t))

   554 {

   555     size_t i;

   556     int sorted;

   557 

   558     do

   559     {

   560         sorted = 1;

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

   562         {

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

   564             {

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

   566                 sorted = 0;

   567             } /* if */

   568         } /* for */

   569     } while (!sorted);

   570 } /* __PHYSFS_bubble_sort */

   571 

   572 

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

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

   575                          void (*swapfn)(void *, size_t, size_t))

   576 {

   577     size_t i;

   578     size_t j;

   579     size_t v;

   580 

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

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

   583     else

   584     {

   585         i = (hi + lo) / 2;

   586 

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

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

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

   590 

   591         j = hi - 1;

   592         swapfn(a, i, j);

   593         i = lo;

   594         v = j;

   595         while (1)

   596         {

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

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

   599             if (j < i)

   600                 break;

   601             swapfn(a, i, j);

   602         } /* while */

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

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

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

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

   607     } /* else */

   608 } /* __PHYSFS_quick_sort */

   609 

   610 

   611 void __PHYSFS_sort(void *entries, size_t max,

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

   613                    void (*swapfn)(void *, size_t, size_t))

   614 {

   615     /*

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

   617      *   https://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html

   618      */

   619     if (max > 0)

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

   621 } /* __PHYSFS_sort */

   622 

   623 

   624 static ErrState *findErrorForCurrentThread(void)

   625 {

   626     ErrState *i;

   627     void *tid;

   628 

   629     if (errorLock != NULL)

   630         __PHYSFS_platformGrabMutex(errorLock);

   631 

   632     if (errorStates != NULL)

   633     {

   634         tid = __PHYSFS_platformGetThreadID();

   635 

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

   637         {

   638             if (i->tid == tid)

   639             {

   640                 if (errorLock != NULL)

   641                     __PHYSFS_platformReleaseMutex(errorLock);

   642                 return i;

   643             } /* if */

   644         } /* for */

   645     } /* if */

   646 

   647     if (errorLock != NULL)

   648         __PHYSFS_platformReleaseMutex(errorLock);

   649 

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

   651 } /* findErrorForCurrentThread */

   652 

   653 

   654 /* this doesn't reset the error state. */

   655 static inline PHYSFS_ErrorCode currentErrorCode(void)

   656 {

   657     const ErrState *err = findErrorForCurrentThread();

   658     return err ? err->code : PHYSFS_ERR_OK;

   659 } /* currentErrorCode */

   660 

   661 

   662 PHYSFS_ErrorCode PHYSFS_getLastErrorCode(void)

   663 {

   664     ErrState *err = findErrorForCurrentThread();

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

   666     if (err)

   667         err->code = PHYSFS_ERR_OK;

   668     return retval;

   669 } /* PHYSFS_getLastErrorCode */

   670 

   671 

   672 PHYSFS_DECL const char *PHYSFS_getErrorByCode(PHYSFS_ErrorCode code)

   673 {

   674     switch (code)

   675     {

   676         case PHYSFS_ERR_OK: return "no error";

   677         case PHYSFS_ERR_OTHER_ERROR: return "unknown error";

   678         case PHYSFS_ERR_OUT_OF_MEMORY: return "out of memory";

   679         case PHYSFS_ERR_NOT_INITIALIZED: return "not initialized";

   680         case PHYSFS_ERR_IS_INITIALIZED: return "already initialized";

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

   682         case PHYSFS_ERR_UNSUPPORTED: return "unsupported";

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

   684         case PHYSFS_ERR_FILES_STILL_OPEN: return "files still open";

   685         case PHYSFS_ERR_INVALID_ARGUMENT: return "invalid argument";

   686         case PHYSFS_ERR_NOT_MOUNTED: return "not mounted";

   687         case PHYSFS_ERR_NOT_FOUND: return "not found";

   688         case PHYSFS_ERR_SYMLINK_FORBIDDEN: return "symlinks are forbidden";

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

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

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

   692         case PHYSFS_ERR_NOT_A_FILE: return "not a file";

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

   694         case PHYSFS_ERR_CORRUPT: return "corrupted";

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

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

   697         case PHYSFS_ERR_PERMISSION: return "permission denied";

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

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

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

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

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

   703         case PHYSFS_ERR_DUPLICATE: return "duplicate resource";

   704         case PHYSFS_ERR_BAD_PASSWORD: return "bad password";

   705     } /* switch */

   706 

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

   708 } /* PHYSFS_getErrorByCode */

   709 

   710 

   711 void PHYSFS_setErrorCode(PHYSFS_ErrorCode errcode)

   712 {

   713     ErrState *err;

   714 

   715     if (!errcode)

   716         return;

   717 

   718     err = findErrorForCurrentThread();

   719     if (err == NULL)

   720     {

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

   722         if (err == NULL)

   723             return;   /* uhh...? */

   724 

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

   726         err->tid = __PHYSFS_platformGetThreadID();

   727 

   728         if (errorLock != NULL)

   729             __PHYSFS_platformGrabMutex(errorLock);

   730 

   731         err->next = errorStates;

   732         errorStates = err;

   733 

   734         if (errorLock != NULL)

   735             __PHYSFS_platformReleaseMutex(errorLock);

   736     } /* if */

   737 

   738     err->code = errcode;

   739 } /* PHYSFS_setErrorCode */

   740 

   741 

   742 const char *PHYSFS_getLastError(void)

   743 {

   744     const PHYSFS_ErrorCode err = PHYSFS_getLastErrorCode();

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

   746 } /* PHYSFS_getLastError */

   747 

   748 

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

   750 static void freeErrorStates(void)

   751 {

   752     ErrState *i;

   753     ErrState *next;

   754 

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

   756     {

   757         next = i->next;

   758         allocator.Free(i);

   759     } /* for */

   760 

   761     errorStates = NULL;

   762 } /* freeErrorStates */

   763 

   764 

   765 void PHYSFS_getLinkedVersion(PHYSFS_Version *ver)

   766 {

   767     if (ver != NULL)

   768     {

   769         ver->major = PHYSFS_VER_MAJOR;

   770         ver->minor = PHYSFS_VER_MINOR;

   771         ver->patch = PHYSFS_VER_PATCH;

   772     } /* if */

   773 } /* PHYSFS_getLinkedVersion */

   774 

   775 

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

   777 {

   778     const char *retval = NULL;

   779     if (fname != NULL)

   780     {

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

   782         retval = p;

   783 

   784         while (p != NULL)

   785         {

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

   787             if (p != NULL)

   788                 retval = p;

   789         } /* while */

   790 

   791         if (retval != NULL)

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

   793     } /* if */

   794 

   795     return retval;

   796 } /* find_filename_extension */

   797 

   798 

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

   800                              const char *d, int forWriting)

   801 {

   802     DirHandle *retval = NULL;

   803     void *opaque = NULL;

   804 

   805     if (io != NULL)

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

   807 

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

   809     if (opaque != NULL)

   810     {

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

   812         if (retval == NULL)

   813             funcs->closeArchive(opaque);

   814         else

   815         {

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

   817             retval->mountPoint = NULL;

   818             retval->funcs = funcs;

   819             retval->opaque = opaque;

   820         } /* else */

   821     } /* if */

   822 

   823     return retval;

   824 } /* tryOpenDir */

   825 

   826 

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

   828 {

   829     DirHandle *retval = NULL;

   830     const PHYSFS_Archiver **i;

   831     const char *ext;

   832     int created_io = 0;

   833 

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

   835 

   836     if (io == NULL)

   837     {

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

   839         extern const PHYSFS_Archiver __PHYSFS_Archiver_DIR;

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

   841         if (retval != NULL)

   842             return retval;

   843 

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

   845         BAIL_IF_MACRO(!io, ERRPASS, 0);

   846         created_io = 1;

   847     } /* if */

   848 

   849     ext = find_filename_extension(d);

   850     if (ext != NULL)

   851     {

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

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

   854         {

   855             if (__PHYSFS_utf8stricmp(ext, (*i)->info.extension) == 0)

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

   857         } /* for */

   858 

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

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

   861         {

   862             if (__PHYSFS_utf8stricmp(ext, (*i)->info.extension) != 0)

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

   864         } /* for */

   865     } /* if */

   866 

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

   868     {

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

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

   871     } /* else */

   872 

   873     if ((!retval) && (created_io))

   874         io->destroy(io);

   875 

   876     BAIL_IF_MACRO(!retval, PHYSFS_ERR_UNSUPPORTED, NULL);

   877     return retval;

   878 } /* openDirectory */

   879 

   880 

   881 /*

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

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

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

   885  *  cleaned up string is deposited.

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

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

   888  */

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

   890 {

   891     char *prev;

   892     char ch;

   893 

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

   895         src++;

   896 

   897     prev = dst;

   898     do

   899     {

   900         ch = *(src++);

   901 

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

   903             BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);

   904 

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

   906         {

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

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

   909                 BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);

   910 

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

   912                 src++;

   913 

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

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

   916 

   917             prev = dst + 1;

   918         } /* if */

   919 

   920         *(dst++) = ch;

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

   922 

   923     return 1;

   924 } /* sanitizePlatformIndependentPath */

   925 

   926 

   927 /*

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

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

   930  *  state.

   931  *

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

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

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

   935  */

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

   937 {

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

   939     int rc;

   940     size_t len, mntpntlen;

   941 

   942     if (h->mountPoint == NULL)

   943         return 0;

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

   945         return 1;

   946 

   947     len = strlen(fname);

   948     mntpntlen = strlen(h->mountPoint);

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

   950         return 0;

   951 

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

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

   954         return 0;

   955 

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

   957     if (rc != 0)

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

   959 

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

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

   962 } /* partOfMountPoint */

   963 

   964 

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

   966                                   const char *mountPoint, int forWriting)

   967 {

   968     DirHandle *dirHandle = NULL;

   969     char *tmpmntpnt = NULL;

   970 

   971     if (mountPoint != NULL)

   972     {

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

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

   975         GOTO_IF_MACRO(!tmpmntpnt, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

   976         if (!sanitizePlatformIndependentPath(mountPoint, tmpmntpnt))

   977             goto badDirHandle;

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

   979     } /* if */

   980 

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

   982     GOTO_IF_MACRO(!dirHandle, ERRPASS, badDirHandle);

   983 

   984     if (newDir == NULL)

   985         dirHandle->dirName = NULL;

   986     else

   987     {

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

   989         if (!dirHandle->dirName)

   990             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

   991         strcpy(dirHandle->dirName, newDir);

   992     } /* else */

   993 

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

   995     {

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

   997         if (!dirHandle->mountPoint)

   998             GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);

   999         strcpy(dirHandle->mountPoint, mountPoint);

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

  1001     } /* if */

  1002 

  1003     __PHYSFS_smallFree(tmpmntpnt);

  1004     return dirHandle;

  1005 

  1006 badDirHandle:

  1007     if (dirHandle != NULL)

  1008     {

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

  1010         allocator.Free(dirHandle->dirName);

  1011         allocator.Free(dirHandle->mountPoint);

  1012         allocator.Free(dirHandle);

  1013     } /* if */

  1014 

  1015     __PHYSFS_smallFree(tmpmntpnt);

  1016     return NULL;

  1017 } /* createDirHandle */

  1018 

  1019 

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

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

  1022 {

  1023     FileHandle *i;

  1024 

  1025     if (dh == NULL)

  1026         return 1;

  1027 

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

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

  1030 

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

  1032     allocator.Free(dh->dirName);

  1033     allocator.Free(dh->mountPoint);

  1034     allocator.Free(dh);

  1035     return 1;

  1036 } /* freeDirHandle */

  1037 

  1038 

  1039 static char *calculateBaseDir(const char *argv0)

  1040 {

  1041     const char dirsep = __PHYSFS_platformDirSeparator;

  1042     char *retval = NULL;

  1043     char *ptr = NULL;

  1044 

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

  1046     retval = __PHYSFS_platformCalcBaseDir(argv0);

  1047     if (retval != NULL)

  1048         return retval;

  1049 

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

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

  1052 

  1053     ptr = strrchr(argv0, dirsep);

  1054     if (ptr != NULL)

  1055     {

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

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

  1058         BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

  1059         memcpy(retval, argv0, size);

  1060         retval[size] = '\0';

  1061         return retval;

  1062     } /* if */

  1063 

  1064     /* argv0 wasn't helpful. */

  1065     BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, NULL);

  1066 } /* calculateBaseDir */

  1067 

  1068 

  1069 static int initializeMutexes(void)

  1070 {

  1071     errorLock = __PHYSFS_platformCreateMutex();

  1072     if (errorLock == NULL)

  1073         goto initializeMutexes_failed;

  1074 

  1075     stateLock = __PHYSFS_platformCreateMutex();

  1076     if (stateLock == NULL)

  1077         goto initializeMutexes_failed;

  1078 

  1079     return 1;  /* success. */

  1080 

  1081 initializeMutexes_failed:

  1082     if (errorLock != NULL)

  1083         __PHYSFS_platformDestroyMutex(errorLock);

  1084 

  1085     if (stateLock != NULL)

  1086         __PHYSFS_platformDestroyMutex(stateLock);

  1087 

  1088     errorLock = stateLock = NULL;

  1089     return 0;  /* failed. */

  1090 } /* initializeMutexes */

  1091 

  1092 

  1093 static int doRegisterArchiver(const PHYSFS_Archiver *_archiver);

  1094 

  1095 static int initStaticArchivers(void)

  1096 {

  1097     #define REGISTER_STATIC_ARCHIVER(arc) { \

  1098         extern const PHYSFS_Archiver __PHYSFS_Archiver_##arc; \

  1099         if (!doRegisterArchiver(&__PHYSFS_Archiver_##arc)) { \

  1100             return 0; \

  1101         } \

  1102     }

  1103 

  1104     #if PHYSFS_SUPPORTS_ZIP

  1105         REGISTER_STATIC_ARCHIVER(ZIP);

  1106     #endif

  1107     #if PHYSFS_SUPPORTS_7Z

  1108         REGISTER_STATIC_ARCHIVER(LZMA);

  1109     #endif

  1110     #if PHYSFS_SUPPORTS_GRP

  1111         REGISTER_STATIC_ARCHIVER(GRP);

  1112     #endif

  1113     #if PHYSFS_SUPPORTS_QPAK

  1114         REGISTER_STATIC_ARCHIVER(QPAK);

  1115     #endif

  1116     #if PHYSFS_SUPPORTS_HOG

  1117         REGISTER_STATIC_ARCHIVER(HOG);

  1118     #endif

  1119     #if PHYSFS_SUPPORTS_MVL

  1120         REGISTER_STATIC_ARCHIVER(MVL);

  1121     #endif

  1122     #if PHYSFS_SUPPORTS_WAD

  1123         REGISTER_STATIC_ARCHIVER(WAD);

  1124     #endif

  1125     #if PHYSFS_SUPPORTS_SLB

  1126         REGISTER_STATIC_ARCHIVER(SLB);

  1127     #endif

  1128     #if PHYSFS_SUPPORTS_ISO9660

  1129         REGISTER_STATIC_ARCHIVER(ISO9660);

  1130     #endif

  1131 

  1132     #undef REGISTER_STATIC_ARCHIVER

  1133 

  1134     return 1;

  1135 } /* initStaticArchivers */