gave names to nearly all structs and enums which should make for better C++ error...
[xonotic/darkplaces.git] / fs.c
diff --git a/fs.c b/fs.c
index 376336b..67ffa9f 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -1,8 +1,7 @@
 /*
        DarkPlaces file system
 
-       Copyright (C) 2003 Mathieu Olivier
-       Copyright (C) 1999,2000  contributors of the QuakeForge project
+       Copyright (C) 2003-2005 Mathieu Olivier
 
        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
 # include <unistd.h>
 #endif
 
-#ifndef PATH_MAX
-# define PATH_MAX 512
-#endif
-
 #include "fs.h"
 
-// use syscalls instead of f* functions
-#define FS_USESYSCALLS
-
 // Win32 requires us to add O_BINARY, but the other OSes don't have it
-#ifdef FS_USESYSCALLS
-# ifndef O_BINARY
-#  define O_BINARY 0
-# endif
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif
+
+// In case the system doesn't support the O_NONBLOCK flag
+#ifndef O_NONBLOCK
+# define O_NONBLOCK 0
 #endif
 
 
@@ -69,7 +64,7 @@ The "game directory" is the first tree on the search path and directory that
 all generated files (savegames, screenshots, demos, config files) will be
 saved to.  This can be overridden with the "-game" command line parameter.
 The game directory can never be changed while quake is executing.  This is a
-precacution against having a malicious server instruct clients to write files
+precaution against having a malicious server instruct clients to write files
 over areas they shouldn't.
 
 */
@@ -99,7 +94,11 @@ CONSTANTS
 #define MAX_WBITS              15
 #define Z_OK                   0
 #define Z_STREAM_END   1
-#define ZLIB_VERSION   "1.1.4"
+#define ZLIB_VERSION   "1.2.3"
+
+// Uncomment the following line if the zlib DLL you have still uses
+// the 1.1.x series calling convention on Win32 (WINAPI)
+//#define ZLIB_USES_WINAPI
 
 
 /*
@@ -136,39 +135,36 @@ typedef struct
 } z_stream;
 
 
-// Our own file structure on top of FILE
-typedef enum
-{
-       FS_FLAG_NONE            = 0,
-       FS_FLAG_PACKED          = (1 << 0),     // inside a package (PAK or PK3)
-       FS_FLAG_DEFLATED        = (1 << 1)      // file is compressed using the deflate algorithm (PK3 only)
-} fs_flags_t;
+// inside a package (PAK or PK3)
+#define QFILE_FLAG_PACKED (1 << 0)
+// file is compressed using the deflate algorithm (PK3 only)
+#define QFILE_FLAG_DEFLATED (1 << 1)
 
-#define ZBUFF_SIZE 1024
+#define FILE_BUFF_SIZE 2048
 typedef struct
 {
        z_stream        zstream;
-       size_t          real_length;                    // length of the uncompressed file
-       size_t          in_ind, in_max;                 // input buffer index and counter
+       size_t          comp_length;                    // length of the compressed file
+       size_t          in_ind, in_len;                 // input buffer current index and length
        size_t          in_position;                    // position in the compressed file
-       size_t          out_ind, out_max;               // output buffer index and counter
-       size_t          out_position;                   // how many bytes did we uncompress until now?
-       qbyte           input [ZBUFF_SIZE];
-       qbyte           output [ZBUFF_SIZE];
+       qbyte           input [FILE_BUFF_SIZE];
 } ztoolkit_t;
 
 struct qfile_s
 {
-       fs_flags_t      flags;
-#ifdef FS_USESYSCALLS
-       int                     stream;
-#else
-       FILE*           stream;
-#endif
-       size_t          length;         // file size on disk (PACKED only)
-       size_t          offset;         // offset into a package (PACKED only)
-       size_t          position;       // current position in the file (PACKED only)
-       ztoolkit_t*     z;                      // used for inflating (DEFLATED only)
+       int                             flags;
+       int                             handle;                                 // file descriptor
+       fs_offset_t             real_length;                    // uncompressed file size (for files opened in "read" mode)
+       fs_offset_t             position;                               // current position in the file
+       fs_offset_t             offset;                                 // offset into the package (0 if external file)
+       int                             ungetc;                                 // single stored character from ungetc, cleared to EOF when read
+
+       // Contents buffer
+       fs_offset_t             buff_ind, buff_len;             // buffer current index and length
+       qbyte                   buff [FILE_BUFF_SIZE];
+
+       // For zipped files
+       ztoolkit_t*             ztk;
 };
 
 
@@ -176,7 +172,7 @@ struct qfile_s
 
 // You can get the complete ZIP format description from PKWARE website
 
-typedef struct
+typedef struct pk3_endOfCentralDir_s
 {
        unsigned int signature;
        unsigned short disknum;
@@ -190,13 +186,13 @@ typedef struct
 
 
 // ------ PAK files on disk ------ //
-typedef struct
+typedef struct dpackfile_s
 {
        char name[56];
        int filepos, filelen;
 } dpackfile_t;
 
-typedef struct
+typedef struct dpackheader_s
 {
        char id[4];
        int dirofs;
@@ -205,34 +201,27 @@ typedef struct
 
 
 // Packages in memory
-typedef enum
-{
-       FILE_FLAG_NONE          = 0,
-       FILE_FLAG_TRUEOFFS      = (1 << 0),     // the offset in packfile_t is the true contents offset
-       FILE_FLAG_DEFLATED      = (1 << 1)      // file compressed using the deflate algorithm
-} file_flags_t;
+// the offset in packfile_t is the true contents offset
+#define PACKFILE_FLAG_TRUEOFFS (1 << 0)
+// file compressed using the deflate algorithm
+#define PACKFILE_FLAG_DEFLATED (1 << 1)
 
-typedef struct
+typedef struct packfile_s
 {
        char name [MAX_QPATH];
-       file_flags_t flags;
-       size_t offset;
-       size_t packsize;        // size in the package
-       size_t realsize;        // real file size (uncompressed)
+       int flags;
+       fs_offset_t offset;
+       fs_offset_t packsize;   // size in the package
+       fs_offset_t realsize;   // real file size (uncompressed)
 } packfile_t;
 
 typedef struct pack_s
 {
        char filename [MAX_OSPATH];
-#ifdef FS_USESYSCALLS
        int handle;
-#else
-       FILE *handle;
-#endif
-       int ignorecase; // PK3 ignores case
+       int ignorecase;  // PK3 ignores case
        int numfiles;
        packfile_t *files;
-       mempool_t *mempool;
        struct pack_s *next;
 } pack_t;
 
@@ -259,8 +248,8 @@ void FS_Dir_f(void);
 void FS_Ls_f(void);
 
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
-                                                                        size_t offset, size_t packsize,
-                                                                        size_t realsize, file_flags_t flags);
+                                                                       fs_offset_t offset, fs_offset_t packsize,
+                                                                       fs_offset_t realsize, int flags);
 
 
 /*
@@ -272,9 +261,8 @@ VARIABLES
 */
 
 mempool_t *fs_mempool;
-mempool_t *pak_mempool;
 
-int fs_filesize;
+fs_offset_t fs_filesize;
 
 pack_t *packlist = NULL;
 
@@ -287,6 +275,8 @@ char fs_basedir[MAX_OSPATH];
 
 qboolean fs_modified;   // set true if using non-id files
 
+cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp"};
+
 
 /*
 =============================================================================
@@ -297,7 +287,7 @@ PRIVATE FUNCTIONS - PK3 HANDLING
 */
 
 // Functions exported from zlib
-#ifdef WIN32
+#if defined(WIN32) && defined(ZLIB_USES_WINAPI)
 # define ZEXPORT WINAPI
 #else
 # define ZEXPORT
@@ -346,22 +336,32 @@ Try to load the Zlib DLL
 */
 qboolean PK3_OpenLibrary (void)
 {
-       const char* dllname;
+       const char* dllnames [] =
+       {
+#if defined(WIN64)
+               "zlib64.dll",
+#elif defined(WIN32)
+# ifdef ZLIB_USES_WINAPI
+               "zlibwapi.dll",
+               "zlib.dll",
+# else
+               "zlib1.dll",
+# endif
+#elif defined(MACOSX)
+               "libz.dylib",
+#else
+               "libz.so.1",
+               "libz.so",
+#endif
+               NULL
+       };
 
        // Already loaded?
        if (zlib_dll)
                return true;
 
-#ifdef WIN32
-       dllname = "zlib.dll";
-#elif defined(MACOSX)
-       dllname = "libz.dylib";
-#else
-       dllname = "libz.so";
-#endif
-
        // Load the DLL
-       if (! Sys_LoadLibrary (dllname, &zlib_dll, zlibfuncs))
+       if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
        {
                Con_Printf ("Compressed files support disabled\n");
                return false;
@@ -379,23 +379,14 @@ PK3_GetEndOfCentralDir
 Extract the end of the central directory from a PK3 package
 ====================
 */
-#ifdef FS_USESYSCALLS
 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
-#else
-qboolean PK3_GetEndOfCentralDir (const char *packfile, FILE *packhandle, pk3_endOfCentralDir_t *eocd)
-#endif
 {
        long filesize, maxsize;
        qbyte *buffer, *ptr;
        int ind;
 
        // Get the package size
-#ifdef FS_USESYSCALLS
        filesize = lseek (packhandle, 0, SEEK_END);
-#else
-       fseek (packhandle, 0, SEEK_END);
-       filesize = ftell(packhandle);
-#endif
        if (filesize < ZIP_END_CDIR_SIZE)
                return false;
 
@@ -404,14 +395,9 @@ qboolean PK3_GetEndOfCentralDir (const char *packfile, FILE *packhandle, pk3_end
                maxsize = filesize;
        else
                maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
-       buffer = Mem_Alloc (tempmempool, maxsize);
-#ifdef FS_USESYSCALLS
+       buffer = (qbyte *)Mem_Alloc (tempmempool, maxsize);
        lseek (packhandle, filesize - maxsize, SEEK_SET);
-       if (read (packhandle, buffer, maxsize) != (ssize_t) maxsize)
-#else
-       fseek (packhandle, filesize - maxsize, SEEK_SET);
-       if (fread (buffer, 1, maxsize, packhandle) != (size_t) maxsize)
-#endif
+       if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
        {
                Mem_Free (buffer);
                return false;
@@ -460,17 +446,12 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
 {
        qbyte *central_dir, *ptr;
        unsigned int ind;
-       int remaining;
+       fs_offset_t remaining;
 
        // Load the central directory in memory
-       central_dir = Mem_Alloc (tempmempool, eocd->cdir_size);
-#ifdef FS_USESYSCALLS
+       central_dir = (qbyte *)Mem_Alloc (tempmempool, eocd->cdir_size);
        lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
        read (pack->handle, central_dir, eocd->cdir_size);
-#else
-       fseek (pack->handle, eocd->cdir_offset, SEEK_SET);
-       fread (central_dir, 1, eocd->cdir_size, pack->handle);
-#endif
 
        // Extract the files properties
        // The parsing is done "by hand" because some fields have variable sizes and
@@ -480,7 +461,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
        ptr = central_dir;
        for (ind = 0; ind < eocd->nbentries; ind++)
        {
-               size_t namesize, count;
+               fs_offset_t namesize, count;
 
                // Checking the remaining size
                if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
@@ -507,7 +488,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
                {
                        // Still enough bytes for the name?
-                       if ((size_t) remaining < namesize || namesize >= sizeof (*pack->files))
+                       if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
                        {
                                Mem_Free (central_dir);
                                return -1;
@@ -517,17 +498,16 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                        if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
                        {
                                char filename [sizeof (pack->files[0].name)];
-                               size_t offset, packsize, realsize;
-                               file_flags_t flags;
+                               fs_offset_t offset, packsize, realsize;
+                               int flags;
 
                                // Extract the name (strip it if necessary)
-                               if (namesize >= sizeof (filename))
-                                       namesize = sizeof (filename) - 1;
+                               namesize = min(namesize, (int)sizeof (filename) - 1);
                                memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
                                filename[namesize] = '\0';
 
                                if (BuffLittleShort (&ptr[10]))
-                                       flags = FILE_FLAG_DEFLATED;
+                                       flags = PACKFILE_FLAG_DEFLATED;
                                else
                                        flags = 0;
                                offset = BuffLittleLong (&ptr[42]);
@@ -561,53 +541,59 @@ Create a package entry associated with a PK3 file
 */
 pack_t *FS_LoadPackPK3 (const char *packfile)
 {
-#ifdef FS_USESYSCALLS
        int packhandle;
-#else
-       FILE *packhandle;
-#endif
        pk3_endOfCentralDir_t eocd;
        pack_t *pack;
        int real_nb_files;
 
-#ifdef FS_USESYSCALLS
        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;
-#else
-       packhandle = fopen (packfile, "rb");
-       if (!packhandle)
-               return NULL;
-#endif
 
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
-               Sys_Error ("%s is not a PK3 file", packfile);
+       {
+               Con_Printf ("%s is not a PK3 file", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        // Multi-volume ZIP archives are NOT allowed
        if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
-               Sys_Error ("%s is a multi-volume ZIP archive", packfile);
+       {
+               Con_Printf ("%s is a multi-volume ZIP archive", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
        // since eocd.nbentries is an unsigned 16 bits integer
 #if MAX_FILES_IN_PACK < 65535
        if (eocd.nbentries > MAX_FILES_IN_PACK)
-               Sys_Error ("%s contains too many files (%hu)", packfile, eocd.nbentries);
+       {
+               Con_Printf ("%s contains too many files (%hu)", packfile, eocd.nbentries);
+               close(packhandle);
+               return NULL;
+       }
 #endif
 
        // Create a package structure in memory
-       pack = Mem_Alloc (pak_mempool, sizeof (pack_t));
+       pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
        pack->ignorecase = true; // PK3 ignores case
        strlcpy (pack->filename, packfile, sizeof (pack->filename));
        pack->handle = packhandle;
        pack->numfiles = eocd.nbentries;
-       pack->mempool = Mem_AllocPool (packfile, 0, NULL);
-       pack->files = Mem_Alloc (pack->mempool, eocd.nbentries * sizeof(packfile_t));
+       pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
        pack->next = packlist;
        packlist = pack;
 
        real_nb_files = PK3_BuildFileList (pack, &eocd);
        if (real_nb_files < 0)
-               Sys_Error ("%s is not a valid PK3 file", packfile);
+       {
+               Con_Printf ("%s is not a valid PK3 file", packfile);
+               close(pack->handle);
+               Mem_Free(pack);
+               return NULL;
+       }
 
        Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
        return pack;
@@ -621,30 +607,29 @@ PK3_GetTrueFileOffset
 Find where the true file data offset is
 ====================
 */
-void PK3_GetTrueFileOffset (packfile_t *file, pack_t *pack)
+qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
 {
        qbyte buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
-       size_t count;
+       fs_offset_t count;
 
        // Already found?
-       if (file->flags & FILE_FLAG_TRUEOFFS)
-               return;
+       if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
+               return true;
 
        // Load the local file description
-#ifdef FS_USESYSCALLS
-       lseek (pack->handle, file->offset, SEEK_SET);
+       lseek (pack->handle, pfile->offset, SEEK_SET);
        count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
-#else
-       fseek (pack->handle, file->offset, SEEK_SET);
-       count = fread (buffer, 1, ZIP_LOCAL_CHUNK_BASE_SIZE, pack->handle);
-#endif
        if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
-               Sys_Error ("Can't retrieve file %s in package %s", file->name, pack->filename);
+       {
+               Con_Printf ("Can't retrieve file %s in package %s", pfile->name, pack->filename);
+               return false;
+       }
 
        // Skip name and extra field
-       file->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
+       pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
 
-       file->flags |= FILE_FLAG_TRUEOFFS;
+       pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
+       return true;
 }
 
 
@@ -665,12 +650,12 @@ Add a file to the list of files contained into a package
 ====================
 */
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
-                                                                        size_t offset, size_t packsize,
-                                                                        size_t realsize, file_flags_t flags)
+                                                                        fs_offset_t offset, fs_offset_t packsize,
+                                                                        fs_offset_t realsize, int flags)
 {
        int (*strcmp_funct) (const char* str1, const char* str2);
        int left, right, middle;
-       packfile_t *file;
+       packfile_t *pfile;
 
        strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
 
@@ -686,8 +671,7 @@ static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
 
                // If we found the file, there's a problem
                if (!diff)
-                       Sys_Error ("Package %s contains the file %s several times\n",
-                                          pack->filename, name);
+                       Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
 
                // If we're too far in the list
                if (diff > 0)
@@ -697,17 +681,17 @@ static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
        }
 
        // We have to move the right of the list by one slot to free the one we need
-       file = &pack->files[left];
-       memmove (file + 1, file, (pack->numfiles - left) * sizeof (*file));
+       pfile = &pack->files[left];
+       memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
        pack->numfiles++;
 
-       strlcpy (file->name, name, sizeof (file->name));
-       file->offset = offset;
-       file->packsize = packsize;
-       file->realsize = realsize;
-       file->flags = flags;
+       strlcpy (pfile->name, name, sizeof (pfile->name));
+       pfile->offset = offset;
+       pfile->packsize = packsize;
+       pfile->realsize = realsize;
+       pfile->flags = flags;
 
-       return file;
+       return pfile;
 }
 
 
@@ -750,9 +734,7 @@ void FS_Path_f (void)
        for (s=fs_searchpaths ; s ; s=s->next)
        {
                if (s->pack)
-               {
                        Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
-               }
                else
                        Con_Printf("%s\n", s->filename);
        }
@@ -773,64 +755,59 @@ pack_t *FS_LoadPackPAK (const char *packfile)
 {
        dpackheader_t header;
        int i, numpackfiles;
-#ifdef FS_USESYSCALLS
        int packhandle;
-#else
-       FILE *packhandle;
-#endif
        pack_t *pack;
-       dpackfile_t *info;      // temporary alloc, allowing huge pack directories
+       dpackfile_t *info;
 
-#ifdef FS_USESYSCALLS
        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;
        read (packhandle, (void *)&header, sizeof(header));
-#else
-       packhandle = fopen (packfile, "rb");
-       if (!packhandle)
-               return NULL;
-       fread ((void *)&header, 1, sizeof(header), packhandle);
-#endif
        if (memcmp(header.id, "PACK", 4))
-               Sys_Error ("%s is not a packfile", packfile);
+       {
+               Con_Printf ("%s is not a packfile", packfile);
+               close(packhandle);
+               return NULL;
+       }
        header.dirofs = LittleLong (header.dirofs);
        header.dirlen = LittleLong (header.dirlen);
 
        if (header.dirlen % sizeof(dpackfile_t))
-               Sys_Error ("%s has an invalid directory size", packfile);
+       {
+               Con_Printf ("%s has an invalid directory size", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        numpackfiles = header.dirlen / sizeof(dpackfile_t);
 
        if (numpackfiles > MAX_FILES_IN_PACK)
-               Sys_Error ("%s has %i files", packfile, numpackfiles);
+       {
+               Con_Printf ("%s has %i files", packfile, numpackfiles);
+               close(packhandle);
+               return NULL;
+       }
 
-       pack = Mem_Alloc(pak_mempool, sizeof (pack_t));
+       pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
        pack->ignorecase = false; // PAK is case sensitive
        strlcpy (pack->filename, packfile, sizeof (pack->filename));
        pack->handle = packhandle;
        pack->numfiles = 0;
-       pack->mempool = Mem_AllocPool(packfile, 0, NULL);
-       pack->files = Mem_Alloc(pack->mempool, numpackfiles * sizeof(packfile_t));
+       pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
        pack->next = packlist;
        packlist = pack;
 
-       info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
-#ifdef FS_USESYSCALLS
+       info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
        lseek (packhandle, header.dirofs, SEEK_SET);
        read (packhandle, (void *)info, header.dirlen);
-#else
-       fseek (packhandle, header.dirofs, SEEK_SET);
-       fread ((void *)info, 1, header.dirlen, packhandle);
-#endif
 
        // parse the directory
        for (i = 0;i < numpackfiles;i++)
        {
-               size_t offset = LittleLong (info[i].filepos);
-               size_t size = LittleLong (info[i].filelen);
+               fs_offset_t offset = LittleLong (info[i].filepos);
+               fs_offset_t size = LittleLong (info[i].filelen);
 
-               FS_AddFileToPack (info[i].name, pack, offset, size, size, FILE_FLAG_TRUEOFFS);
+               FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
        }
 
        Mem_Free(info);
@@ -848,7 +825,7 @@ Sets fs_gamedir, adds the directory to the head of the path,
 then loads and adds pak1.pak pak2.pak ...
 ================
 */
-void FS_AddGameDirectory (char *dir)
+void FS_AddGameDirectory (const char *dir)
 {
        stringlist_t *list, *current;
        searchpath_t *search;
@@ -864,11 +841,11 @@ void FS_AddGameDirectory (char *dir)
        {
                if (matchpattern(current->text, "*.pak", true))
                {
-                       snprintf (pakfile, sizeof (pakfile), "%s/%s", dir, current->text);
+                       dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
                        pak = FS_LoadPackPAK (pakfile);
                        if (pak)
                        {
-                               search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
+                               search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
                                search->pack = pak;
                                search->next = fs_searchpaths;
                                fs_searchpaths = search;
@@ -883,11 +860,11 @@ void FS_AddGameDirectory (char *dir)
        {
                if (matchpattern(current->text, "*.pk3", true))
                {
-                       snprintf (pakfile, sizeof (pakfile), "%s/%s", dir, current->text);
+                       dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
                        pak = FS_LoadPackPK3 (pakfile);
                        if (pak)
                        {
-                               search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
+                               search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
                                search->pack = pak;
                                search->next = fs_searchpaths;
                                fs_searchpaths = search;
@@ -900,7 +877,7 @@ void FS_AddGameDirectory (char *dir)
 
        // Add the directory to the search path
        // (unpacked files have the priority over packed files)
-       search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
+       search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
        strlcpy (search->filename, dir, sizeof (search->filename));
        search->next = fs_searchpaths;
        fs_searchpaths = search;
@@ -908,32 +885,50 @@ void FS_AddGameDirectory (char *dir)
 
 
 /*
+================
+FS_AddGameHierarchy
+================
+*/
+void FS_AddGameHierarchy (const char *dir)
+{
+#ifndef WIN32
+       const char *homedir;
+#endif
+
+       // Add the common game directory
+       FS_AddGameDirectory (va("%s/%s/", fs_basedir, dir));
+
+#ifndef WIN32
+       // Add the personal game directory
+       homedir = getenv ("HOME");
+       if (homedir != NULL && homedir[0] != '\0')
+               FS_AddGameDirectory (va("%s/.%s/%s/", homedir, gameuserdirname, dir));
+#endif
+}
+
+
+/*
 ============
 FS_FileExtension
 ============
 */
-char *FS_FileExtension (const char *in)
+static const char *FS_FileExtension (const char *in)
 {
-       static char exten[8];
-       const char *slash, *backslash, *colon, *dot, *separator;
-       int i;
+       const char *separator, *backslash, *colon, *dot;
 
-       slash = strrchr(in, '/');
+       separator = strrchr(in, '/');
        backslash = strrchr(in, '\\');
-       colon = strrchr(in, ':');
-       dot = strrchr(in, '.');
-       separator = slash;
        if (separator < backslash)
                separator = backslash;
+       colon = strrchr(in, ':');
        if (separator < colon)
                separator = colon;
+
+       dot = strrchr(in, '.');
        if (dot == NULL || dot < separator)
                return "";
-       dot++;
-       for (i = 0;i < 7 && dot[i];i++)
-               exten[i] = dot[i];
-       exten[i] = 0;
-       return exten;
+
+       return dot + 1;
 }
 
 
@@ -948,16 +943,23 @@ void FS_Init (void)
        searchpath_t *search;
 
        fs_mempool = Mem_AllocPool("file management", 0, NULL);
-       pak_mempool = Mem_AllocPool("paks", 0, NULL);
 
-       Cvar_RegisterVariable (&scr_screenshot_name);
+       strcpy(fs_basedir, ".");
+       strcpy(fs_gamedir, "");
 
-       Cmd_AddCommand ("path", FS_Path_f);
-       Cmd_AddCommand ("dir", FS_Dir_f);
-       Cmd_AddCommand ("ls", FS_Ls_f);
+#ifdef MACOSX
+       // FIXME: is there a better way to find the directory outside the .app?
+       if (strstr(com_argv[0], ".app/"))
+       {
+               char *split;
 
-       strcpy(fs_basedir, ".");
-       strcpy(fs_gamedir, ".");
+               split = strstr(com_argv[0], ".app/");
+               while (split > com_argv[0] && *split != '/')
+                       split--;
+               strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
+               fs_basedir[split - com_argv[0]] = 0;
+       }
+#endif
 
        PK3_OpenLibrary ();
 
@@ -968,7 +970,7 @@ void FS_Init (void)
        if (i && i < com_argc-1)
        {
                strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
-               i = strlen (fs_basedir);
+               i = (int)strlen (fs_basedir);
                if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
                        fs_basedir[i-1] = 0;
        }
@@ -985,18 +987,26 @@ void FS_Init (void)
                        if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
                                break;
 
-                       search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
+                       search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
                        if (!strcasecmp (FS_FileExtension(com_argv[i]), "pak"))
                        {
                                search->pack = FS_LoadPackPAK (com_argv[i]);
                                if (!search->pack)
-                                       Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
+                               {
+                                       Con_Printf ("Couldn't load packfile: %s", com_argv[i]);
+                                       Mem_Free(search);
+                                       continue;
+                               }
                        }
                        else if (!strcasecmp (FS_FileExtension (com_argv[i]), "pk3"))
                        {
                                search->pack = FS_LoadPackPK3 (com_argv[i]);
                                if (!search->pack)
-                                       Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
+                               {
+                                       Con_Printf ("Couldn't load packfile: %s", com_argv[i]);
+                                       Mem_Free(search);
+                                       continue;
+                               }
                        }
                        else
                                strlcpy (search->filename, com_argv[i], sizeof (search->filename));
@@ -1006,19 +1016,20 @@ void FS_Init (void)
                return;
        }
 
-       // start up with GAMENAME by default (id1)
-       strlcpy (com_modname, GAMENAME, sizeof (com_modname));
-       FS_AddGameDirectory (va("%s/"GAMENAME, fs_basedir));
-       Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
+       // add the game-specific paths
+       // gamedirname1 (typically id1)
+       FS_AddGameHierarchy (gamedirname1);
 
        // add the game-specific path, if any
-       if (gamedirname[0])
+       if (gamedirname2)
        {
                fs_modified = true;
-               strlcpy (com_modname, gamedirname, sizeof (com_modname));
-               FS_AddGameDirectory (va("%s/%s", fs_basedir, gamedirname));
+               FS_AddGameHierarchy (gamedirname2);
        }
 
+       // set the com_modname (reported in server info)
+       strlcpy(com_modname, gamedirname1, sizeof(com_modname));
+
        // -game <gamedir>
        // Adds basedir/gamedir as an override game
        // LordHavoc: now supports multiple -game directories
@@ -1030,9 +1041,9 @@ void FS_Init (void)
                {
                        i++;
                        fs_modified = true;
+                       FS_AddGameHierarchy (com_argv[i]);
+                       // update the com_modname
                        strlcpy (com_modname, com_argv[i], sizeof (com_modname));
-                       FS_AddGameDirectory (va("%s/%s", fs_basedir, com_argv[i]));
-                       Cvar_SetQuick (&scr_screenshot_name, com_modname);
                }
        }
 
@@ -1041,6 +1052,22 @@ void FS_Init (void)
                unlink (va("%s/qconsole.log", fs_gamedir));
 }
 
+void FS_Init_Commands(void)
+{
+       Cvar_RegisterVariable (&scr_screenshot_name);
+
+       Cmd_AddCommand ("path", FS_Path_f);
+       Cmd_AddCommand ("dir", FS_Dir_f);
+       Cmd_AddCommand ("ls", FS_Ls_f);
+
+       // set the default screenshot name to either the mod name or the
+       // gamemode screenshot name
+       if (fs_modified)
+               Cvar_SetQuick (&scr_screenshot_name, com_modname);
+       else
+               Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
+}
+
 /*
 ================
 FS_Shutdown
@@ -1048,7 +1075,6 @@ FS_Shutdown
 */
 void FS_Shutdown (void)
 {
-       Mem_FreePool (&pak_mempool);
        Mem_FreePool (&fs_mempool);
 }
 
@@ -1056,38 +1082,71 @@ void FS_Shutdown (void)
 ====================
 FS_SysOpen
 
-Internal function used to create a qfile_t and open the relevant file on disk
+Internal function used to create a qfile_t and open the relevant non-packed file on disk
 ====================
 */
-static qfile_t* FS_SysOpen (const char* filepath, const char* mode)
+static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
 {
        qfile_t* file;
+       int mod, opt;
+       unsigned int ind;
 
-       file = Mem_Alloc (fs_mempool, sizeof (*file));
-       memset (file, 0, sizeof (*file));
-
-#ifdef FS_USESYSCALLS
-       if (strchr(mode, 'r'))
-               file->stream = open (filepath, O_RDONLY | O_BINARY);
-       else if (strchr(mode, 'w'))
-               file->stream = open (filepath, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, 0666);
-       else if (strchr(mode, 'a'))
-               file->stream = open (filepath, O_RDWR | O_BINARY | O_CREAT | O_APPEND, 0666);
-       else
-               file->stream = -1;
-       if (file->stream < 0)
+       // Parse the mode string
+       switch (mode[0])
        {
-               Mem_Free (file);
-               return NULL;
+               case 'r':
+                       mod = O_RDONLY;
+                       opt = 0;
+                       break;
+               case 'w':
+                       mod = O_WRONLY;
+                       opt = O_CREAT | O_TRUNC;
+                       break;
+               case 'a':
+                       mod = O_WRONLY;
+                       opt = O_CREAT | O_APPEND;
+                       break;
+               default:
+                       Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
+                       return NULL;
        }
-#else
-       file->stream = fopen (filepath, mode);
-       if (!file->stream)
+       for (ind = 1; mode[ind] != '\0'; ind++)
+       {
+               switch (mode[ind])
+               {
+                       case '+':
+                               mod = O_RDWR;
+                               break;
+                       case 'b':
+                               opt |= O_BINARY;
+                               break;
+                       default:
+                               Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
+                                                       filepath, mode, mode[ind]);
+               }
+       }
+
+       if (nonblocking)
+               opt |= O_NONBLOCK;
+
+       file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
+       memset (file, 0, sizeof (*file));
+       file->ungetc = EOF;
+
+       file->handle = open (filepath, mod | opt, 0666);
+       if (file->handle < 0)
        {
                Mem_Free (file);
                return NULL;
        }
-#endif
+
+       file->real_length = lseek (file->handle, 0, SEEK_END);
+
+       // For files opened in append mode, we start at the end of the file
+       if (mod & O_APPEND)
+               file->position = file->real_length;
+       else
+               lseek (file->handle, 0, SEEK_SET);
 
        return file;
 }
@@ -1095,48 +1154,100 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode)
 
 /*
 ===========
-FS_OpenRead
+FS_OpenPackedFile
+
+Open a packed file using its package file descriptor
 ===========
 */
-qfile_t *FS_OpenRead (const char *path, int offs, int len)
+qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
 {
+       packfile_t *pfile;
+       int dup_handle;
        qfile_t* file;
 
-       file = FS_SysOpen (path, "rb");
-       if (!file)
+       pfile = &pack->files[pack_ind];
+
+       fs_filesize = 0;
+
+       // If we don't have the true offset, get it now
+       if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
+               if (!PK3_GetTrueFileOffset (pfile, pack))
+                       return NULL;
+
+       // No Zlib DLL = no compressed files
+       if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
        {
-               Sys_Error ("Couldn't open %s", path);
+               Con_Printf("WARNING: can't open the compressed file %s\n"
+                                       "You need the Zlib DLL to use compressed files\n",
+                                       pfile->name);
                return NULL;
        }
 
-       // Normal file
-       if (offs < 0 || len < 0)
+       // LordHavoc: lseek affects all duplicates of a handle so we do it before
+       // the dup() call to avoid having to close the dup_handle on error here
+       if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
        {
-               // We set fs_filesize here for normal files
-#ifdef FS_USESYSCALLS
-               fs_filesize = lseek (file->stream, 0, SEEK_END);
-               lseek (file->stream, 0, SEEK_SET);
-#else
-               fseek (file->stream, 0, SEEK_END);
-               fs_filesize = ftell (file->stream);
-               fseek (file->stream, 0, SEEK_SET);
-#endif
+               Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)",
+                                       pfile->name, pack->filename, pfile->offset);
+               return NULL;
        }
-       // Packed file
-       else
+
+       dup_handle = dup (pack->handle);
+       if (dup_handle < 0)
        {
-#ifdef FS_USESYSCALLS
-               lseek (file->stream, offs, SEEK_SET);
-#else
-               fseek (file->stream, offs, SEEK_SET);
-#endif
+               Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)", pack->filename);
+               return NULL;
+       }
 
-               file->flags |= FS_FLAG_PACKED;
-               file->length = len;
-               file->offset = offs;
-               file->position = 0;
+       file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
+       memset (file, 0, sizeof (*file));
+       file->handle = dup_handle;
+       file->flags = QFILE_FLAG_PACKED;
+       file->real_length = pfile->realsize;
+       file->offset = pfile->offset;
+       file->position = 0;
+       file->ungetc = EOF;
+
+       if (pfile->flags & PACKFILE_FLAG_DEFLATED)
+       {
+               ztoolkit_t *ztk;
+
+               file->flags |= QFILE_FLAG_DEFLATED;
+
+               // We need some more variables
+               ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
+
+               ztk->comp_length = pfile->packsize;
+
+               // Initialize zlib stream
+               ztk->zstream.next_in = ztk->input;
+               ztk->zstream.avail_in = 0;
+
+               /* From Zlib's "unzip.c":
+                *
+                * windowBits is passed < 0 to tell that there is no zlib header.
+                * Note that in this case inflate *requires* an extra "dummy" byte
+                * after the compressed stream in order to complete decompression and
+                * return Z_STREAM_END.
+                * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+                * size of both compressed and uncompressed data
+                */
+               if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
+               {
+                       Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)", pfile->name);
+                       close(dup_handle);
+                       Mem_Free(file);
+                       return NULL;
+               }
+
+               ztk->zstream.next_out = file->buff;
+               ztk->zstream.avail_out = sizeof (file->buff);
+
+               file->ztk = ztk;
        }
 
+       fs_filesize = pfile->realsize;
+
        return file;
 }
 
@@ -1156,18 +1267,26 @@ int FS_CheckNastyPath (const char *path)
        // (on Windows \ is a directory separator, but / is also supported)
        if (strstr(path, "\\"))
                return 1; // non-portable
+
        // Mac: don't allow Mac-only filenames - : is a directory separator
        // instead of /, but we rely on / working already, so there's no reason to
        // support a Mac-only path
        // Amiga and Windows: : tries to go to root of drive
        if (strstr(path, ":"))
                return 1; // non-portable attempt to go to root of drive
+
        // Amiga: // is parent directory
        if (strstr(path, "//"))
                return 1; // non-portable attempt to go to parent directory
+
        // all: don't allow going to current directory (./) or parent directory (../ or /../)
        if (strstr(path, "./"))
-               return 2; // attempt to go to parent directory
+               return 2; // attempt to go outside the game directory
+
+       // Windows and UNIXes: don't allow absolute paths
+       if (path[0] == '/')
+               return 2; // attempt to go outside the game directory
+
        // after all these checks we're pretty sure it's a / separated filename
        // and won't do much if any harm
        return false;
@@ -1233,7 +1352,7 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                else
                {
                        char netpath[MAX_OSPATH];
-                       snprintf(netpath, sizeof(netpath), "%s/%s", search->filename, name);
+                       dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
                        if (FS_SysFileExists (netpath))
                        {
                                if (!quiet)
@@ -1257,93 +1376,37 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
 
 /*
 ===========
-FS_FOpenFile
+FS_OpenReadFile
 
-If the requested file is inside a packfile, a new qfile_t* will be opened
-into the file.
+Look for a file in the search paths and open it in read-only mode
 
 Sets fs_filesize
 ===========
 */
-qfile_t *FS_FOpenFile (const char *filename, qboolean quiet)
+qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
 {
        searchpath_t *search;
-       packfile_t *packfile;
-       int i;
-       qfile_t *file;
+       int pack_ind;
 
-       search = FS_FindFile (filename, &i, quiet);
+       search = FS_FindFile (filename, &pack_ind, quiet);
 
        // Not found?
        if (search == NULL)
        {
-               fs_filesize = -1;
+               fs_filesize = 0;
                return NULL;
        }
 
        // Found in the filesystem?
-       if (i < 0)
+       if (pack_ind < 0)
        {
-               char netpath[MAX_OSPATH];
-               snprintf(netpath, sizeof(netpath), "%s/%s", search->filename, filename);
-               return FS_OpenRead(netpath, -1, -1);
+               char path [MAX_OSPATH];
+               dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
+               return FS_SysOpen (path, "rb", nonblocking);
        }
 
        // So, we found it in a package...
-       packfile = &search->pack->files[i];
-
-       // If we don't have the true offset, get it now
-       if (! (packfile->flags & FILE_FLAG_TRUEOFFS))
-               PK3_GetTrueFileOffset (packfile, search->pack);
-
-       // No Zlib DLL = no compressed files
-       if (!zlib_dll && (packfile->flags & FILE_FLAG_DEFLATED))
-       {
-               Con_Printf("WARNING: can't open the compressed file %s\n"
-                                       "You need the Zlib DLL to use compressed files\n",
-                                       filename);
-               fs_filesize = -1;
-               return NULL;
-       }
-
-       // open a new file in the pakfile
-       file = FS_OpenRead (search->pack->filename, packfile->offset, packfile->packsize);
-       fs_filesize = packfile->realsize;
-
-       if (packfile->flags & FILE_FLAG_DEFLATED)
-       {
-               ztoolkit_t *ztk;
-
-               file->flags |= FS_FLAG_DEFLATED;
-
-               // We need some more variables
-               ztk = Mem_Alloc (fs_mempool, sizeof (*file->z));
-
-               ztk->real_length = packfile->realsize;
-
-               // Initialize zlib stream
-               ztk->zstream.next_in = ztk->input;
-               ztk->zstream.avail_in = 0;
-
-               /* From Zlib's "unzip.c":
-                *
-                * windowBits is passed < 0 to tell that there is no zlib header.
-                * Note that in this case inflate *requires* an extra "dummy" byte
-                * after the compressed stream in order to complete decompression and
-                * return Z_STREAM_END.
-                * In unzip, i don't wait absolutely Z_STREAM_END because I known the
-                * size of both compressed and uncompressed data
-                */
-               if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
-                       Sys_Error ("inflate init error (file: %s)", filename);
-
-               ztk->zstream.next_out = ztk->output;
-               ztk->zstream.avail_out = sizeof (ztk->output);
-
-               file->z = ztk;
-       }
-
-       return file;
+       return FS_OpenPackedFile (search->pack, pack_ind);
 }
 
 
@@ -1362,30 +1425,36 @@ FS_Open
 Open a file. The syntax is the same as fopen
 ====================
 */
-qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet)
+qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
 {
+       qfile_t* file;
+
        if (FS_CheckNastyPath(filepath))
        {
                Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
                return NULL;
        }
 
-       // If the file is opened in "write" or "append" mode
-       if (strchr (mode, 'w') || strchr (mode, 'a'))
+       // If the file is opened in "write", "append", or "read/write" mode
+       if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
        {
                char real_path [MAX_OSPATH];
 
                // Open the file on disk directly
-               snprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
+               dpsnprintf (real_path, sizeof (real_path), "%s%s", fs_gamedir, filepath);
 
                // Create directories up to the file
                FS_CreatePath (real_path);
 
-               return FS_SysOpen (real_path, mode);
+               return FS_SysOpen (real_path, mode, nonblocking);
        }
 
-       // Else, we look at the various search paths
-       return FS_FOpenFile (filepath, quiet);
+       // Else, we look at the various search paths and open the file in read-only mode
+       file = FS_OpenReadFile (filepath, quiet, nonblocking);
+       if (file != NULL)
+               fs_filesize = file->real_length;
+
+       return file;
 }
 
 
@@ -1398,17 +1467,13 @@ Close a file
 */
 int FS_Close (qfile_t* file)
 {
-#ifdef FS_USESYSCALLS
-       if (close (file->stream))
-#else
-       if (fclose (file->stream))
-#endif
+       if (close (file->handle))
                return EOF;
 
-       if (file->z)
+       if (file->ztk)
        {
-               qz_inflateEnd (&file->z->zstream);
-               Mem_Free (file->z);
+               qz_inflateEnd (&file->ztk->zstream);
+               Mem_Free (file->ztk);
        }
 
        Mem_Free (file);
@@ -1423,13 +1488,27 @@ FS_Write
 Write "datasize" bytes into a file
 ====================
 */
-size_t FS_Write (qfile_t* file, const void* data, size_t datasize)
+fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
 {
-#ifdef FS_USESYSCALLS
-       return write (file->stream, data, datasize);
-#else
-       return fwrite (data, 1, datasize, file->stream);
-#endif
+       fs_offset_t result;
+
+       // If necessary, seek to the exact file position we're supposed to be
+       if (file->buff_ind != file->buff_len)
+               lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
+
+       // Purge cached data
+       FS_Purge (file);
+
+       // Write the buffer and update the position
+       result = write (file->handle, data, (fs_offset_t)datasize);
+       file->position = lseek (file->handle, 0, SEEK_CUR);
+       if (file->real_length < file->position)
+               file->real_length = file->position;
+
+       if (result < 0)
+               return 0;
+
+       return result;
 }
 
 
@@ -1440,153 +1519,171 @@ FS_Read
 Read up to "buffersize" bytes from a file
 ====================
 */
-size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
+fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
 {
-       size_t count, nb;
-       ztoolkit_t *ztk;
+       fs_offset_t count, done;
 
-       // Quick path for unpacked files
-       if (! (file->flags & FS_FLAG_PACKED))
-#ifdef FS_USESYSCALLS
-               return read (file->stream, buffer, buffersize);
-#else
-               return fread (buffer, 1, buffersize, file->stream);
-#endif
+       if (buffersize == 0)
+               return 0;
 
-       // If the file isn't compressed
-       if (! (file->flags & FS_FLAG_DEFLATED))
+       // Get rid of the ungetc character
+       if (file->ungetc != EOF)
        {
-               // We must take care to not read after the end of the file
-               count = file->length - file->position;
-               if (buffersize > count)
-                       buffersize = count;
+               ((char*)buffer)[0] = file->ungetc;
+               buffersize--;
+               file->ungetc = EOF;
+               done = 1;
+       }
+       else
+               done = 0;
 
-#ifdef FS_USESYSCALLS
-               nb = read (file->stream, buffer, buffersize);
-#else
-               nb = fread (buffer, 1, buffersize, file->stream);
-#endif
+       // First, we copy as many bytes as we can from "buff"
+       if (file->buff_ind < file->buff_len)
+       {
+               count = file->buff_len - file->buff_ind;
+
+               done += ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
+               memcpy (buffer, &file->buff[file->buff_ind], done);
+               file->buff_ind += done;
 
-               file->position += nb;
-               return nb;
+               buffersize -= done;
+               if (buffersize == 0)
+                       return done;
        }
 
-       // If the file is compressed, it's more complicated...
-       ztk = file->z;
+       // NOTE: at this point, the read buffer is always empty
 
-       // First, we copy as many bytes as we can from "output"
-       if (ztk->out_ind < ztk->out_max)
+       // If the file isn't compressed
+       if (! (file->flags & QFILE_FLAG_DEFLATED))
        {
-               count = ztk->out_max - ztk->out_ind;
+               fs_offset_t nb;
+
+               // We must take care to not read after the end of the file
+               count = file->real_length - file->position;
+
+               // If we have a lot of data to get, put them directly into "buffer"
+               if (buffersize > sizeof (file->buff) / 2)
+               {
+                       if (count > (fs_offset_t)buffersize)
+                               count = (fs_offset_t)buffersize;
+                       lseek (file->handle, file->offset + file->position, SEEK_SET);
+                       nb = read (file->handle, &((qbyte*)buffer)[done], count);
+                       if (nb > 0)
+                       {
+                               done += nb;
+                               file->position += nb;
 
-               nb = (buffersize > count) ? count : buffersize;
-               memcpy (buffer, &ztk->output[ztk->out_ind], nb);
-               ztk->out_ind += nb;
-               file->position += nb;
+                               // Purge cached data
+                               FS_Purge (file);
+                       }
+               }
+               else
+               {
+                       if (count > (fs_offset_t)sizeof (file->buff))
+                               count = (fs_offset_t)sizeof (file->buff);
+                       lseek (file->handle, file->offset + file->position, SEEK_SET);
+                       nb = read (file->handle, file->buff, count);
+                       if (nb > 0)
+                       {
+                               file->buff_len = nb;
+                               file->position += nb;
+
+                               // Copy the requested data in "buffer" (as much as we can)
+                               count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
+                               memcpy (&((qbyte*)buffer)[done], file->buff, count);
+                               file->buff_ind = count;
+                               done += count;
+                       }
+               }
+
+               return done;
        }
-       else
-               nb = 0;
 
-       // We cycle through a few operations until we have inflated enough data
-       while (nb < buffersize)
+       // If the file is compressed, it's more complicated...
+       // We cycle through a few operations until we have read enough data
+       while (buffersize > 0)
        {
-               // NOTE: at this point, "output" should always be empty
+               ztoolkit_t *ztk = file->ztk;
+               int error;
 
-               // If "input" is also empty, we need to fill it
-               if (ztk->in_ind == ztk->in_max)
-               {
-                       size_t remain;
+               // NOTE: at this point, the read buffer is always empty
 
+               // If "input" is also empty, we need to refill it
+               if (ztk->in_ind == ztk->in_len)
+               {
                        // If we are at the end of the file
-                       if (ztk->out_position == ztk->real_length)
-                               return nb;
-
-                       remain = file->length - ztk->in_position;
-                       count = (remain > sizeof (ztk->input)) ? sizeof (ztk->input) : remain;
-#ifdef FS_USESYSCALLS
-                       read (file->stream, ztk->input, count);
-#else
-                       fread (ztk->input, 1, count, file->stream);
-#endif
+                       if (file->position == file->real_length)
+                               return done;
+
+                       count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
+                       if (count > (fs_offset_t)sizeof (ztk->input))
+                               count = (fs_offset_t)sizeof (ztk->input);
+                       lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
+                       if (read (file->handle, ztk->input, count) != count)
+                       {
+                               Con_Printf ("FS_Read: unexpected end of file");
+                               break;
+                       }
 
-                       // Update indexes and counters
                        ztk->in_ind = 0;
-                       ztk->in_max = count;
+                       ztk->in_len = count;
                        ztk->in_position += count;
                }
 
-               // Now that we are sure we have compressed data available, we need to determine
-               // if it's better to inflate it in "output" or directly in "buffer" (we are in this
-               // case if we still need more bytes than "output" can contain)
-
                ztk->zstream.next_in = &ztk->input[ztk->in_ind];
-               ztk->zstream.avail_in = ztk->in_max - ztk->in_ind;
+               ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
 
-               // If output will be able to contain at least 1 more byte than the data we need
-               if (buffersize - nb < sizeof (ztk->output))
-               {
-                       int error;
+               // Now that we are sure we have compressed data available, we need to determine
+               // if it's better to inflate it in "file->buff" or directly in "buffer"
 
-                       // Inflate the data in "output"
-                       ztk->zstream.next_out = ztk->output;
-                       ztk->zstream.avail_out = sizeof (ztk->output);
+               // Inflate the data in "file->buff"
+               if (buffersize < sizeof (file->buff) / 2)
+               {
+                       ztk->zstream.next_out = file->buff;
+                       ztk->zstream.avail_out = sizeof (file->buff);
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
-                               Sys_Error ("Can't inflate file");
-                       ztk->in_ind = ztk->in_max - ztk->zstream.avail_in;
-                       ztk->out_max = sizeof (ztk->output) - ztk->zstream.avail_out;
-                       ztk->out_position += ztk->out_max;
+                       {
+                               Con_Printf ("FS_Read: Can't inflate file");
+                               break;
+                       }
+                       ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
+
+                       file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
+                       file->position += file->buff_len;
 
                        // Copy the requested data in "buffer" (as much as we can)
-                       count = (buffersize - nb > ztk->out_max) ? ztk->out_max : buffersize - nb;
-                       memcpy (&((qbyte*)buffer)[nb], ztk->output, count);
-                       ztk->out_ind = count;
+                       count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
+                       memcpy (&((qbyte*)buffer)[done], file->buff, count);
+                       file->buff_ind = count;
                }
 
                // Else, we inflate directly in "buffer"
                else
                {
-                       int error;
-
-                       // Inflate the data in "buffer"
-                       ztk->zstream.next_out = &((qbyte*)buffer)[nb];
-                       ztk->zstream.avail_out = buffersize - nb;
+                       ztk->zstream.next_out = &((qbyte*)buffer)[done];
+                       ztk->zstream.avail_out = (unsigned int)buffersize;
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
-                               Sys_Error ("Can't inflate file");
-                       ztk->in_ind = ztk->in_max - ztk->zstream.avail_in;
-
-                       // Invalidate the output data (for FS_Seek)
-                       ztk->out_max = 0;
-                       ztk->out_ind = 0;
+                       {
+                               Con_Printf ("FS_Read: Can't inflate file");
+                               break;
+                       }
+                       ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
 
                        // How much data did it inflate?
-                       count = buffersize - nb - ztk->zstream.avail_out;
-                       ztk->out_position += count;
+                       count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
+                       file->position += count;
+
+                       // Purge cached data
+                       FS_Purge (file);
                }
 
-               nb += count;
-               file->position += count;
+               done += count;
+               buffersize -= count;
        }
 
-       return nb;
-}
-
-
-/*
-====================
-FS_Flush
-
-Flush the file output stream
-====================
-*/
-int FS_Flush (qfile_t* file)
-{
-#ifdef FS_USESYSCALLS
-       return 0;
-#else
-       return fflush (file->stream);
-#endif
+       return done;
 }
 
 
@@ -1597,9 +1694,9 @@ FS_Print
 Print a string into a file
 ====================
 */
-int FS_Print(qfile_t* file, const char *msg)
+int FS_Print (qfile_t* file, const char *msg)
 {
-       return FS_Write(file, msg, strlen(msg));
+       return (int)FS_Write (file, msg, strlen (msg));
 }
 
 /*
@@ -1615,7 +1712,7 @@ int FS_Printf(qfile_t* file, const char* format, ...)
        va_list args;
 
        va_start (args, format);
-       result = FS_VPrintf(file, format, args);
+       result = FS_VPrintf (file, format, args);
        va_end (args);
 
        return result;
@@ -1629,28 +1726,27 @@ FS_VPrintf
 Print a string into a file
 ====================
 */
-int FS_VPrintf(qfile_t* file, const char* format, va_list ap)
-{
-#ifdef FS_USESYSCALLS
+int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
 {
        int len;
-       char tempstring[1024];
-       len = vsnprintf (tempstring, sizeof(tempstring), format, ap);
-       if (len >= sizeof(tempstring))
+       fs_offset_t buff_size;
+       char *tempbuff = NULL;
+
+       buff_size = 1024;
+       tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
+       len = dpvsnprintf (tempbuff, buff_size, format, ap);
+       while (len < 0)
        {
-               int result;
-               char *temp = Mem_Alloc(tempmempool, len + 1);
-               len = vsnprintf (temp, len + 1, format, ap);
-               result = write (file->stream, temp, len);
-               Mem_Free(temp);
-               return result;
+               Mem_Free (tempbuff);
+               buff_size *= 2;
+               tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
+               len = dpvsnprintf (tempbuff, buff_size, format, ap);
        }
-       else
-               return write (file->stream, tempstring, len);
-}
-#else
-       return vfprintf (file->stream, format, ap);
-#endif
+
+       len = write (file->handle, tempbuff, len);
+       Mem_Free (tempbuff);
+
+       return len;
 }
 
 
@@ -1674,260 +1770,142 @@ int FS_Getc (qfile_t* file)
 
 /*
 ====================
-FS_Seek
+FS_UnGetc
 
-Move the position index in a file
+Put a character back into the read buffer (only supports one character!)
 ====================
 */
-int FS_Seek (qfile_t* file, long offset, int whence)
+int FS_UnGetc (qfile_t* file, unsigned char c)
 {
-       // Quick path for unpacked files
-       if (! (file->flags & FS_FLAG_PACKED))
-#ifdef FS_USESYSCALLS
-       {
-               if (lseek (file->stream, offset, whence) == -1)
-                       return -1;
-               return 0;
-       }
-#else
-               return fseek (file->stream, offset, whence);
-#endif
-
-       // Seeking in compressed files is more a hack than anything else,
-       // but we need to support it, so here it is.
-       if (file->flags & FS_FLAG_DEFLATED)
-       {
-               ztoolkit_t *ztk = file->z;
-               qbyte buffer [sizeof (ztk->output)];  // it's big to force inflating into buffer directly
-
-               switch (whence)
-               {
-                       case SEEK_CUR:
-                               offset += file->position;
-                               break;
-
-                       case SEEK_SET:
-                               break;
-
-                       case SEEK_END:
-                               offset += ztk->real_length;
-                               break;
-
-                       default:
-                               return -1;
-               }
-               if (offset < 0 || offset > (long) ztk->real_length)
-                       return -1;
-
-               // If we need to go back in the file
-               if (offset <= (long) file->position)
-               {
-                       // If we still have the data we need in the output buffer
-                       if (file->position - offset <= ztk->out_ind)
-                       {
-                               ztk->out_ind -= file->position - offset;
-                               file->position = offset;
-                               return 0;
-                       }
-
-                       // Else, we restart from the beginning of the file
-                       ztk->in_ind = 0;
-                       ztk->in_max = 0;
-                       ztk->in_position = 0;
-                       ztk->out_ind = 0;
-                       ztk->out_max = 0;
-                       ztk->out_position = 0;
-                       file->position = 0;
-#ifdef FS_USESYSCALLS
-                       lseek (file->stream, file->offset, SEEK_SET);
-#else
-                       fseek (file->stream, file->offset, SEEK_SET);
-#endif
+       // If there's already a character waiting to be read
+       if (file->ungetc != EOF)
+               return EOF;
 
-                       // Reset the Zlib stream
-                       ztk->zstream.next_in = ztk->input;
-                       ztk->zstream.avail_in = 0;
-                       qz_inflateReset (&ztk->zstream);
-               }
+       file->ungetc = c;
+       return c;
+}
 
-               // Skip all data until we reach the requested offset
-               while ((long) file->position < offset)
-               {
-                       size_t diff = offset - file->position;
-                       size_t count, len;
 
-                       count = (diff > sizeof (buffer)) ? sizeof (buffer) : diff;
-                       len = FS_Read (file, buffer, count);
-                       if (len != count)
-                               return -1;
-               }
+/*
+====================
+FS_Seek
 
-               return 0;
-       }
+Move the position index in a file
+====================
+*/
+int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
+{
+       ztoolkit_t *ztk;
+       qbyte* buffer;
+       fs_offset_t buffersize;
 
-       // Packed files receive a special treatment too, because
-       // we need to make sure it doesn't go outside of the file
+       // Compute the file offset
        switch (whence)
        {
                case SEEK_CUR:
-                       offset += file->position;
+                       offset += file->position - file->buff_len + file->buff_ind;
                        break;
 
                case SEEK_SET:
                        break;
 
                case SEEK_END:
-                       offset += file->length;
+                       offset += file->real_length;
                        break;
 
                default:
                        return -1;
        }
-       if (offset < 0 || offset > (long) file->length)
-               return -1;
-
-#ifdef FS_USESYSCALLS
-       if (lseek (file->stream, file->offset + offset, SEEK_SET) == -1)
-               return -1;
-#else
-       if (fseek (file->stream, file->offset + offset, SEEK_SET) == -1)
+       if (offset < 0 || offset > (long) file->real_length)
                return -1;
-#endif
-       file->position = offset;
-       return 0;
-}
 
+       // If we have the data in our read buffer, we don't need to actually seek
+       if (file->position - file->buff_len <= offset && offset <= file->position)
+       {
+               file->buff_ind = offset + file->buff_len - file->position;
+               return 0;
+       }
 
-/*
-====================
-FS_Tell
+       // Purge cached data
+       FS_Purge (file);
 
-Give the current position in a file
-====================
-*/
-long FS_Tell (qfile_t* file)
-{
-       if (file->flags & FS_FLAG_PACKED)
-               return file->position;
-
-#ifdef FS_USESYSCALLS
-       return lseek (file->stream, 0, SEEK_CUR);
-#else
-       return ftell (file->stream);
-#endif
-}
+       // Unpacked or uncompressed files can seek directly
+       if (! (file->flags & QFILE_FLAG_DEFLATED))
+       {
+               if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
+                       return -1;
+               file->position = offset;
+               return 0;
+       }
 
+       // Seeking in compressed files is more a hack than anything else,
+       // but we need to support it, so here we go.
+       ztk = file->ztk;
 
-/*
-====================
-FS_Gets
+       // If we have to go back in the file, we need to restart from the beginning
+       if (offset <= file->position)
+       {
+               ztk->in_ind = 0;
+               ztk->in_len = 0;
+               ztk->in_position = 0;
+               file->position = 0;
+               lseek (file->handle, file->offset, SEEK_SET);
 
-Extract a line from a file
-====================
-*/
-char* FS_Gets (qfile_t* file, char* buffer, int buffersize)
-{
-       size_t ind;
+               // Reset the Zlib stream
+               ztk->zstream.next_in = ztk->input;
+               ztk->zstream.avail_in = 0;
+               qz_inflateReset (&ztk->zstream);
+       }
 
-       // Quick path for unpacked files
-#ifndef FS_USESYSCALLS
-       if (! (file->flags & FS_FLAG_PACKED))
-               return fgets (buffer, buffersize, file->stream);
-#endif
+       // We need a big buffer to force inflating into it directly
+       buffersize = 2 * sizeof (file->buff);
+       buffer = (qbyte *)Mem_Alloc (tempmempool, buffersize);
 
-       for (ind = 0; ind < (size_t) buffersize - 1; ind++)
+       // Skip all data until we reach the requested offset
+       while (offset > file->position)
        {
-               int c = FS_Getc (file);
-               switch (c)
-               {
-                       // End of file
-                       case -1:
-                               if (!ind)
-                                       return NULL;
-
-                               buffer[ind] = '\0';
-                               return buffer;
-
-                       // End of line
-                       case '\r':
-                       case '\n':
-                               buffer[ind] = '\n';
-                               buffer[ind + 1] = '\0';
-                               return buffer;
+               fs_offset_t diff = offset - file->position;
+               fs_offset_t count, len;
 
-                       default:
-                               buffer[ind] = c;
+               count = (diff > buffersize) ? buffersize : diff;
+               len = FS_Read (file, buffer, count);
+               if (len != count)
+               {
+                       Mem_Free (buffer);
+                       return -1;
                }
-
        }
 
-       buffer[buffersize - 1] = '\0';
-       return buffer;
+       Mem_Free (buffer);
+       return 0;
 }
 
 
 /*
-==========
-FS_Getline
+====================
+FS_Tell
 
-Dynamic length version of fgets. DO NOT free the buffer.
-==========
+Give the current position in a file
+====================
 */
-char *FS_Getline (qfile_t *file)
+fs_offset_t FS_Tell (qfile_t* file)
 {
-       static int  size = 256;
-       static char *buf = 0;
-       char        *t;
-       int         len;
-
-       if (!buf)
-               buf = Mem_Alloc (fs_mempool, size);
-
-       if (!FS_Gets (file, buf, size))
-               return 0;
-
-       len = strlen (buf);
-       while (buf[len - 1] != '\n' && buf[len - 1] != '\r')
-       {
-               t = Mem_Alloc (fs_mempool, size + 256);
-               memcpy(t, buf, size);
-               Mem_Free(buf);
-               size += 256;
-               buf = t;
-               if (!FS_Gets (file, buf + len, size - len))
-                       break;
-               len = strlen (buf);
-       }
-       while ((len = strlen(buf)) && (buf[len - 1] == '\n' || buf[len - 1] == '\r'))
-               buf[len - 1] = 0;
-       return buf;
+       return file->position - file->buff_len + file->buff_ind;
 }
 
 
 /*
 ====================
-FS_Eof
+FS_Purge
 
-Extract a line from a file
+Erases any buffered input or output data
 ====================
 */
-// FIXME: remove this function?
-int FS_Eof (qfile_t* file)
+void FS_Purge (qfile_t* file)
 {
-       if (file->flags & FS_FLAG_PACKED)
-       {
-               if (file->flags & FS_FLAG_DEFLATED)
-                       return (file->position == file->z->real_length);
-
-               return (file->position == file->length);
-       }
-
-#ifdef FS_USESYSCALLS
-       Sys_Error("FS_Eof: not implemented using syscalls\n");
-       return false;
-#else
-       return feof (file->stream);
-#endif
+       file->buff_len = 0;
+       file->buff_ind = 0;
+       file->ungetc = EOF;
 }
 
 
@@ -1941,22 +1919,18 @@ Always appends a 0 byte.
 */
 qbyte *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet)
 {
-       qfile_t *h;
+       qfile_t *file;
        qbyte *buf;
 
-       // look for it in the filesystem or pack files
-       h = FS_Open (path, "rb", quiet);
-       if (!h)
+       file = FS_Open (path, "rb", quiet, false);
+       if (!file)
                return NULL;
 
-       buf = Mem_Alloc(pool, fs_filesize+1);
-       if (!buf)
-               Sys_Error ("FS_LoadFile: not enough available memory for %s (size %i)", path, fs_filesize);
+       buf = (qbyte *)Mem_Alloc (pool, fs_filesize + 1);
+       buf[fs_filesize] = '\0';
 
-       ((qbyte *)buf)[fs_filesize] = 0;
-
-       FS_Read (h, buf, fs_filesize);
-       FS_Close (h);
+       FS_Read (file, buf, fs_filesize);
+       FS_Close (file);
 
        return buf;
 }
@@ -1969,20 +1943,20 @@ FS_WriteFile
 The filename will be prefixed by the current game directory
 ============
 */
-qboolean FS_WriteFile (const char *filename, void *data, int len)
+qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
 {
-       qfile_t *handle;
+       qfile_t *file;
 
-       handle = FS_Open (filename, "wb", false);
-       if (!handle)
+       file = FS_Open (filename, "wb", false, false);
+       if (!file)
        {
                Con_Printf("FS_WriteFile: failed on %s\n", filename);
                return false;
        }
 
        Con_DPrintf("FS_WriteFile: %s\n", filename);
-       FS_Write (handle, data, len);
-       FS_Close (handle);
+       FS_Write (file, data, len);
+       FS_Close (file);
        return true;
 }
 
@@ -2070,16 +2044,15 @@ Look for a file in the filesystem only
 qboolean FS_SysFileExists (const char *path)
 {
 #if WIN32
-       FILE *f;
+       int desc;
 
-       f = fopen (path, "rb");
-       if (f)
-       {
-               fclose (f);
-               return true;
-       }
+       // TODO: use another function instead, to avoid opening the file
+       desc = open (path, O_RDONLY | O_BINARY);
+       if (desc < 0)
+               return false;
 
-       return false;
+       close (desc);
+       return true;
 #else
        struct stat buf;
 
@@ -2118,10 +2091,14 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
        char netpath[MAX_OSPATH];
        char temp[MAX_OSPATH];
 
-       while(!strncmp(pattern, "./", 2))
-               pattern += 2;
-       while(!strncmp(pattern, ".\\", 2))
-               pattern += 2;
+       for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
+               ;
+
+       if (i > 0)
+       {
+               Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
+               return NULL;
+       }
 
        search = NULL;
        liststart = NULL;
@@ -2130,15 +2107,10 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
        slash = strrchr(pattern, '/');
        backslash = strrchr(pattern, '\\');
        colon = strrchr(pattern, ':');
-       separator = pattern;
-       if (separator < slash)
-               separator = slash;
-       if (separator < backslash)
-               separator = backslash;
-       if (separator < colon)
-               separator = colon;
-       basepathlength = separator - pattern;
-       basepath = Mem_Alloc (tempmempool, basepathlength + 1);
+       separator = max(slash, backslash);
+       separator = max(separator, colon);
+       basepathlength = separator ? (separator + 1 - pattern) : 0;
+       basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
        if (basepathlength)
                memcpy(basepath, pattern, basepathlength);
        basepath[basepathlength] = 0;
@@ -2189,12 +2161,12 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                else
                {
                        // get a directory listing and look at each name
-                       snprintf(netpath, sizeof (netpath), "%s/%s", searchpath->filename, basepath);
+                       dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
                        if ((dir = listdirectory(netpath)))
                        {
                                for (dirfile = dir;dirfile;dirfile = dirfile->next)
                                {
-                                       snprintf(temp, sizeof(temp), "%s/%s", basepath, dirfile->text);
+                                       dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirfile->text);
                                        if (matchpattern(temp, (char *)pattern, true))
                                        {
                                                for (listtemp = liststart;listtemp;listtemp = listtemp->next)
@@ -2223,12 +2195,12 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                for (listtemp = liststart;listtemp;listtemp = listtemp->next)
                {
                        numfiles++;
-                       numchars += strlen(listtemp->text) + 1;
+                       numchars += (int)strlen(listtemp->text) + 1;
                }
-               search = Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
+               search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
                search->filenames = (char **)((char *)search + sizeof(fssearch_t));
                search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
-               search->numfilenames = numfiles;
+               search->numfilenames = (int)numfiles;
                numfiles = 0;
                numchars = 0;
                for (listtemp = liststart;listtemp;listtemp = listtemp->next)
@@ -2236,7 +2208,7 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                        search->filenames[numfiles] = search->filenamesbuffer + numchars;
                        strcpy(search->filenames[numfiles], listtemp->text);
                        numfiles++;
-                       numchars += strlen(listtemp->text) + 1;
+                       numchars += (int)strlen(listtemp->text) + 1;
                }
                if (liststart)
                        stringlistfree(liststart);
@@ -2277,7 +2249,7 @@ int FS_ListDirectory(const char *pattern, int oneperline)
                columnwidth = 0;
                for (i = 0;i < numfiles;i++)
                {
-                       l = strlen(search->filenames[i]);
+                       l = (int)strlen(search->filenames[i]);
                        if (columnwidth < l)
                                columnwidth = l;
                }
@@ -2298,11 +2270,11 @@ int FS_ListDirectory(const char *pattern, int oneperline)
                                        if (l < numfiles)
                                        {
                                                name = search->filenames[l];
-                                               for (j = 0;name[j] && j < (int)sizeof(linebuf) - 1;j++)
+                                               for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
                                                        linebuf[linebufpos++] = name[j];
                                                // space out name unless it's the last on the line
-                                               if (k < (numcolumns - 1) && l < (numfiles - 1))
-                                                       for (;j < columnwidth && j < (int)sizeof(linebuf) - 1;j++)
+                                               if (k + 1 < numcolumns && l + 1 < numfiles)
+                                                       for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
                                                                linebuf[linebufpos++] = ' ';
                                        }
                                }
@@ -2317,7 +2289,7 @@ int FS_ListDirectory(const char *pattern, int oneperline)
                for (i = 0;i < numfiles;i++)
                        Con_Printf("%s\n", search->filenames[i]);
        FS_FreeSearch(search);
-       return numfiles;
+       return (int)numfiles;
 }
 
 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)