make infobar height configurable
[divverent/darkplaces.git] / fs.c
diff --git a/fs.c b/fs.c
index 0c6901b..a0dd2c8 100644 (file)
--- a/fs.c
+++ b/fs.c
                Boston, MA  02111-1307, USA
 */
 
-// on UNIX platforms we need to define this so that video saving does not cause a SIGFSZ (file size) signal when a video clip exceeds 2GB
-#define _FILE_OFFSET_BITS 64
-
-#include "quakedef.h"
-
 #include <limits.h>
 #include <fcntl.h>
 
 #ifdef WIN32
 # include <direct.h>
 # include <io.h>
+# include <shlobj.h>
 #else
 # include <pwd.h>
 # include <sys/stat.h>
 # include <unistd.h>
 #endif
 
+#include "quakedef.h"
+
 #include "fs.h"
+#include "wad.h"
 
 // Win32 requires us to add O_BINARY, but the other OSes don't have it
 #ifndef O_BINARY
 # define O_NONBLOCK 0
 #endif
 
+// largefile support for Win32
+#ifdef WIN32
+# define lseek _lseeki64
+#endif
 
-/*
+#if _MSC_VER >= 1400
+// suppress deprecated warnings
+# include <sys/stat.h>
+# include <share.h>
+# define read _read
+# define write _write
+# define close _close
+# define unlink _unlink
+# define dup _dup
+#endif
+
+/** \page fs File System
 
 All of Quake's data access is through a hierchal file system, but the contents
 of the file system can be transparently merged from several sources.
@@ -92,13 +106,41 @@ CONSTANTS
 #define ZIP_CDIR_CHUNK_BASE_SIZE       46
 #define ZIP_LOCAL_CHUNK_BASE_SIZE      30
 
+#ifdef LINK_TO_ZLIB
+#include <zlib.h>
+
+#define qz_inflate inflate
+#define qz_inflateEnd inflateEnd
+#define qz_inflateInit2_ inflateInit2_
+#define qz_inflateReset inflateReset
+#define qz_deflateInit2_ deflateInit2_
+#define qz_deflateEnd deflateEnd
+#define qz_deflate deflate
+#define Z_MEMLEVEL_DEFAULT 8
+#else
+
 // Zlib constants (from zlib.h)
 #define Z_SYNC_FLUSH   2
 #define MAX_WBITS              15
 #define Z_OK                   0
 #define Z_STREAM_END   1
+#define Z_STREAM_ERROR  (-2)
+#define Z_DATA_ERROR    (-3)
+#define Z_MEM_ERROR     (-4)
+#define Z_BUF_ERROR     (-5)
 #define ZLIB_VERSION   "1.2.3"
 
+#define Z_BINARY 0
+#define Z_DEFLATED 8
+#define Z_MEMLEVEL_DEFAULT 8
+
+#define Z_NULL 0
+#define Z_DEFAULT_COMPRESSION (-1)
+#define Z_NO_FLUSH 0
+#define Z_SYNC_FLUSH 2
+#define Z_FULL_FLUSH 3
+#define Z_FINISH 4
+
 // 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
@@ -112,62 +154,71 @@ TYPES
 =============================================================================
 */
 
-// Zlib stream (from zlib.h)
-// Warning: some pointers we don't use directly have
-// been cast to "void*" for a matter of simplicity
+/*! Zlib stream (from zlib.h)
+ * \warning: some pointers we don't use directly have
+ * been cast to "void*" for a matter of simplicity
+ */
 typedef struct
 {
-       unsigned char                   *next_in;       // next input byte
-       unsigned int    avail_in;       // number of bytes available at next_in
-       unsigned long   total_in;       // total nb of input bytes read so far
+       unsigned char                   *next_in;       ///< next input byte
+       unsigned int    avail_in;       ///< number of bytes available at next_in
+       unsigned long   total_in;       ///< total nb of input bytes read so far
 
-       unsigned char                   *next_out;      // next output byte should be put there
-       unsigned int    avail_out;      // remaining free space at next_out
-       unsigned long   total_out;      // total nb of bytes output so far
+       unsigned char                   *next_out;      ///< next output byte should be put there
+       unsigned int    avail_out;      ///< remaining free space at next_out
+       unsigned long   total_out;      ///< total nb of bytes output so far
 
-       char                    *msg;           // last error message, NULL if no error
-       void                    *state;         // not visible by applications
+       char                    *msg;           ///< last error message, NULL if no error
+       void                    *state;         ///< not visible by applications
 
-       void                    *zalloc;        // used to allocate the internal state
-       void                    *zfree;         // used to free the internal state
-       void                    *opaque;        // private data object passed to zalloc and zfree
+       void                    *zalloc;        ///< used to allocate the internal state
+       void                    *zfree;         ///< used to free the internal state
+       void                    *opaque;        ///< private data object passed to zalloc and zfree
 
-       int                             data_type;      // best guess about the data type: ascii or binary
-       unsigned long   adler;          // adler32 value of the uncompressed data
-       unsigned long   reserved;       // reserved for future use
+       int                             data_type;      ///< best guess about the data type: ascii or binary
+       unsigned long   adler;          ///< adler32 value of the uncompressed data
+       unsigned long   reserved;       ///< reserved for future use
 } z_stream;
+#endif
 
 
-// inside a package (PAK or PK3)
+/// inside a package (PAK or PK3)
 #define QFILE_FLAG_PACKED (1 << 0)
-// file is compressed using the deflate algorithm (PK3 only)
+/// file is compressed using the deflate algorithm (PK3 only)
 #define QFILE_FLAG_DEFLATED (1 << 1)
+/// file is actually already loaded data
+#define QFILE_FLAG_DATA (1 << 2)
+/// real file will be removed on close
+#define QFILE_FLAG_REMOVE (1 << 3)
 
 #define FILE_BUFF_SIZE 2048
 typedef struct
 {
        z_stream        zstream;
-       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          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
        unsigned char           input [FILE_BUFF_SIZE];
 } ztoolkit_t;
 
 struct qfile_s
 {
        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
+       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
+       fs_offset_t             buff_ind, buff_len;             ///< buffer current index and length
        unsigned char                   buff [FILE_BUFF_SIZE];
 
-       // For zipped files
-       ztoolkit_t*             ztk;
+       ztoolkit_t*             ztk;    ///< For zipped files.
+
+       const unsigned char *data;      ///< For data files.
+
+       const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
 };
 
 
@@ -179,12 +230,13 @@ typedef struct pk3_endOfCentralDir_s
 {
        unsigned int signature;
        unsigned short disknum;
-       unsigned short cdir_disknum;    // number of the disk with the start of the central directory
-       unsigned short localentries;    // number of entries in the central directory on this disk
-       unsigned short nbentries;               // total number of entries in the central directory on this disk
-       unsigned int cdir_size;                 // size of the central directory
-       unsigned int cdir_offset;               // with respect to the starting disk number
+       unsigned short cdir_disknum;    ///< number of the disk with the start of the central directory
+       unsigned short localentries;    ///< number of entries in the central directory on this disk
+       unsigned short nbentries;               ///< total number of entries in the central directory on this disk
+       unsigned int cdir_size;                 ///< size of the central directory
+       unsigned int cdir_offset;               ///< with respect to the starting disk number
        unsigned short comment_size;
+       fs_offset_t prepended_garbage;
 } pk3_endOfCentralDir_t;
 
 
@@ -203,32 +255,38 @@ typedef struct dpackheader_s
 } dpackheader_t;
 
 
-// Packages in memory
-// the offset in packfile_t is the true contents offset
+/*! \name Packages in memory
+ * @{
+ */
+/// the offset in packfile_t is the true contents offset
 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
-// file compressed using the deflate algorithm
+/// file compressed using the deflate algorithm
 #define PACKFILE_FLAG_DEFLATED (1 << 1)
+/// file is a symbolic link
+#define PACKFILE_FLAG_SYMLINK (1 << 2)
 
 typedef struct packfile_s
 {
        char name [MAX_QPATH];
        int flags;
        fs_offset_t offset;
-       fs_offset_t packsize;   // size in the package
-       fs_offset_t realsize;   // real file size (uncompressed)
+       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];
+       char shortname [MAX_QPATH];
        int handle;
-       int ignorecase;  // PK3 ignores case
+       int ignorecase;  ///< PK3 ignores case
        int numfiles;
+       qboolean vpack;
        packfile_t *files;
 } pack_t;
+//@}
 
-
-// Search paths for files (including packages)
+/// Search paths for files (including packages)
 typedef struct searchpath_s
 {
        // only one of filename / pack will be used
@@ -248,6 +306,7 @@ FUNCTION PROTOTYPES
 
 void FS_Dir_f(void);
 void FS_Ls_f(void);
+void FS_Which_f(void);
 
 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
@@ -266,18 +325,26 @@ VARIABLES
 mempool_t *fs_mempool;
 
 searchpath_t *fs_searchpaths = NULL;
+const char *const fs_checkgamedir_missing = "missing";
 
 #define MAX_FILES_IN_PACK      65536
 
+char fs_userdir[MAX_OSPATH];
 char fs_gamedir[MAX_OSPATH];
 char fs_basedir[MAX_OSPATH];
+static pack_t *fs_selfpack = NULL;
 
 // list of active game directories (empty if not running a mod)
-#define MAX_GAMEDIRS 16
 int fs_numgamedirs = 0;
 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
 
-cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running)"};
+// list of all gamedirs with modinfo.txt
+gamedir_t *fs_all_gamedirs = NULL;
+int fs_all_gamedirs_count = 0;
+
+cvar_t scr_screenshot_name = {CVAR_NORESETTODEFAULTS, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
+cvar_t fs_empty_files_in_pack_mark_deletions = {0, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
+cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
 
 
 /*
@@ -288,6 +355,7 @@ PRIVATE FUNCTIONS - PK3 HANDLING
 =============================================================================
 */
 
+#ifndef LINK_TO_ZLIB
 // Functions exported from zlib
 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
 # define ZEXPORT WINAPI
@@ -299,9 +367,18 @@ static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
+static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
+static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
+static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
+#endif
 
 #define qz_inflateInit2(strm, windowBits) \
         qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
+
+#ifndef LINK_TO_ZLIB
+//        qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
 
 static dllfunction_t zlibfuncs[] =
 {
@@ -309,12 +386,25 @@ static dllfunction_t zlibfuncs[] =
        {"inflateEnd",          (void **) &qz_inflateEnd},
        {"inflateInit2_",       (void **) &qz_inflateInit2_},
        {"inflateReset",        (void **) &qz_inflateReset},
+       {"deflateInit2_",   (void **) &qz_deflateInit2_},
+       {"deflateEnd",      (void **) &qz_deflateEnd},
+       {"deflate",         (void **) &qz_deflate},
        {NULL, NULL}
 };
 
-// Handle for Zlib DLL
+/// Handle for Zlib DLL
 static dllhandle_t zlib_dll = NULL;
+#endif
 
+#ifdef WIN32
+static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
+static dllfunction_t shfolderfuncs[] =
+{
+       {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
+       {NULL, NULL}
+};
+static dllhandle_t shfolder_dll = NULL;
+#endif
 
 /*
 ====================
@@ -325,7 +415,9 @@ Unload the Zlib DLL
 */
 void PK3_CloseLibrary (void)
 {
+#ifndef LINK_TO_ZLIB
        Sys_UnloadLibrary (&zlib_dll);
+#endif
 }
 
 
@@ -338,11 +430,12 @@ Try to load the Zlib DLL
 */
 qboolean PK3_OpenLibrary (void)
 {
+#ifdef LINK_TO_ZLIB
+       return true;
+#else
        const char* dllnames [] =
        {
-#if defined(WIN64)
-               "zlib64.dll",
-#elif defined(WIN32)
+#if defined(WIN32)
 # ifdef ZLIB_USES_WINAPI
                "zlibwapi.dll",
                "zlib.dll",
@@ -363,17 +456,27 @@ qboolean PK3_OpenLibrary (void)
                return true;
 
        // Load the DLL
-       if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
-       {
-               Con_Printf ("Compressed files support disabled\n");
-               return false;
-       }
+       return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
+#endif
+}
 
-       Con_Printf ("Compressed files support enabled\n");
+/*
+====================
+FS_HasZlib
+
+See if zlib is available
+====================
+*/
+qboolean FS_HasZlib(void)
+{
+#ifdef LINK_TO_ZLIB
        return true;
+#else
+       PK3_OpenLibrary(); // to be safe
+       return (zlib_dll != 0);
+#endif
 }
 
-
 /*
 ====================
 PK3_GetEndOfCentralDir
@@ -430,6 +533,8 @@ qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOf
        eocd->cdir_size = LittleLong (eocd->cdir_size);
        eocd->cdir_offset = LittleLong (eocd->cdir_offset);
        eocd->comment_size = LittleShort (eocd->comment_size);
+       eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
+       eocd->cdir_offset += eocd->prepended_garbage;
 
        Mem_Free (buffer);
 
@@ -453,7 +558,11 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
        // Load the central directory in memory
        central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
        lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
-       read (pack->handle, central_dir, eocd->cdir_size);
+       if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
+       {
+               Mem_Free (central_dir);
+               return -1;
+       }
 
        // Extract the files properties
        // The parsing is done "by hand" because some fields have variable sizes and
@@ -485,9 +594,16 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                // Check encryption, compression, and attributes
                // 1st uint8  : general purpose bit flag
                //    Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
+               //
+               // LordHavoc: bit 3 would be a problem if we were scanning the archive
+               // but is not a problem in the central directory where the values are
+               // always real.
+               //
+               // bit 3 seems to always be set by the standard Mac OSX zip maker
+               //
                // 2nd uint8 : external file attributes
                //    Check bits 3 (file is a directory) and 5 (file is a volume (?))
-               if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
+               if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
                {
                        // Still enough bytes for the name?
                        if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
@@ -512,9 +628,21 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                                        flags = PACKFILE_FLAG_DEFLATED;
                                else
                                        flags = 0;
-                               offset = BuffLittleLong (&ptr[42]);
+                               offset = BuffLittleLong (&ptr[42]) + eocd->prepended_garbage;
                                packsize = BuffLittleLong (&ptr[20]);
                                realsize = BuffLittleLong (&ptr[24]);
+
+                               switch(ptr[5]) // C_VERSION_MADE_BY_1
+                               {
+                                       case 3: // UNIX_
+                                       case 2: // VMS_
+                                       case 16: // BEOS_
+                                               if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
+                                                       // can't use S_ISLNK here, as this has to compile on non-UNIX too
+                                                       flags |= PACKFILE_FLAG_SYMLINK;
+                                               break;
+                               }
+
                                FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
                        }
                }
@@ -541,20 +669,16 @@ FS_LoadPackPK3
 Create a package entry associated with a PK3 file
 ====================
 */
-pack_t *FS_LoadPackPK3 (const char *packfile)
+pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
 {
-       int packhandle;
        pk3_endOfCentralDir_t eocd;
        pack_t *pack;
        int real_nb_files;
 
-       packhandle = open (packfile, O_RDONLY | O_BINARY);
-       if (packhandle < 0)
-               return NULL;
-
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
        {
-               Con_Printf ("%s is not a PK3 file\n", packfile);
+               if(!silent)
+                       Con_Printf ("%s is not a PK3 file\n", packfile);
                close(packhandle);
                return NULL;
        }
@@ -595,9 +719,21 @@ pack_t *FS_LoadPackPK3 (const char *packfile)
                return NULL;
        }
 
-       Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
+       Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
        return pack;
 }
+pack_t *FS_LoadPackPK3 (const char *packfile)
+{
+       int packhandle;
+#if _MSC_VER >= 1400
+       _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#else
+       packhandle = open (packfile, O_RDONLY | O_BINARY);
+#endif
+       if (packhandle < 0)
+               return NULL;
+       return FS_LoadPackPK3FromFD(packfile, packhandle, false);
+}
 
 
 /*
@@ -699,7 +835,7 @@ static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
 ============
 FS_CreatePath
 
-Only used for FS_Open.
+Only used for FS_OpenRealFile.
 ============
 */
 void FS_CreatePath (char *path)
@@ -734,7 +870,12 @@ 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);
+               {
+                       if(s->pack->vpack)
+                               Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
+                       else
+                               Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
+               }
                else
                        Con_Printf("%s\n", s->filename);
        }
@@ -744,13 +885,12 @@ void FS_Path_f (void)
 /*
 =================
 FS_LoadPackPAK
-
-Takes an explicit (not game tree related) path to a pak file.
-
-Loads the header and directory, adding the files at the beginning
-of the list so they override previous pack files.
 =================
 */
+/*! Takes an explicit (not game tree related) path to a pak file.
+ *Loads the header and directory, adding the files at the beginning
+ *of the list so they override previous pack files.
+ */
 pack_t *FS_LoadPackPAK (const char *packfile)
 {
        dpackheader_t header;
@@ -759,10 +899,19 @@ pack_t *FS_LoadPackPAK (const char *packfile)
        pack_t *pack;
        dpackfile_t *info;
 
+#if _MSC_VER >= 1400
+       _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#else
        packhandle = open (packfile, O_RDONLY | O_BINARY);
+#endif
        if (packhandle < 0)
                return NULL;
-       read (packhandle, (void *)&header, sizeof(header));
+       if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
+       {
+               Con_Printf ("%s is not a packfile\n", packfile);
+               close(packhandle);
+               return NULL;
+       }
        if (memcmp(header.id, "PACK", 4))
        {
                Con_Printf ("%s is not a packfile\n", packfile);
@@ -816,29 +965,52 @@ pack_t *FS_LoadPackPAK (const char *packfile)
 
        Mem_Free(info);
 
-       Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
+       Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
        return pack;
 }
 
 /*
-================
-FS_AddPack_Fullpath
-
-Adds the given pack to the search path.
-The pack type is autodetected by the file extension.
+====================
+FS_LoadPackVirtual
 
-Returns true if the file was successfully added to the
-search path or if it was already included.
+Create a package entry associated with a directory file
+====================
+*/
+pack_t *FS_LoadPackVirtual (const char *dirname)
+{
+       pack_t *pack;
+       pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
+       pack->vpack = true;
+       pack->ignorecase = false;
+       strlcpy (pack->filename, dirname, sizeof(pack->filename));
+       pack->handle = -1;
+       pack->numfiles = -1;
+       pack->files = NULL;
+       Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
+       return pack;
+}
 
-If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
-plain directories.
+/*
+================
+FS_AddPack_Fullpath
 ================
 */
-static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
+/*! Adds the given pack to the search path.
+ * The pack type is autodetected by the file extension.
+ *
+ * Returns true if the file was successfully added to the
+ * search path or if it was already included.
+ *
+ * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
+ * plain directories.
+ *
+ */
+static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
 {
        searchpath_t *search;
        pack_t *pak = NULL;
        const char *ext = FS_FileExtension(pakfile);
+       size_t l;
 
        for(search = fs_searchpaths; search; search = search->next)
        {
@@ -853,15 +1025,20 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loade
        if(already_loaded)
                *already_loaded = false;
 
-       if(!strcasecmp(ext, "pak"))
+       if(!strcasecmp(ext, "pk3dir"))
+               pak = FS_LoadPackVirtual (pakfile);
+       else if(!strcasecmp(ext, "pak"))
                pak = FS_LoadPackPAK (pakfile);
        else if(!strcasecmp(ext, "pk3"))
                pak = FS_LoadPackPK3 (pakfile);
        else
                Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
 
-       if (pak)
+       if(pak)
        {
+               strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
+
+               //Con_DPrintf("  Registered pack with short name %s\n", shortname);
                if(keep_plain_dirs)
                {
                        // find the first item whose next one is a pack or NULL
@@ -884,7 +1061,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loade
                        if(!insertion_point)
                        {
                                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                               search->pack = pak;
                                search->next = fs_searchpaths;
                                fs_searchpaths = search;
                        }
@@ -892,7 +1068,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loade
                        // otherwise we want to append directly after insertion_point.
                        {
                                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                               search->pack = pak;
                                search->next = insertion_point->next;
                                insertion_point->next = search;
                        }
@@ -900,10 +1075,24 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loade
                else
                {
                        search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                       search->pack = pak;
                        search->next = fs_searchpaths;
                        fs_searchpaths = search;
                }
+               search->pack = pak;
+               if(pak->vpack)
+               {
+                       dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
+                       // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
+                       // same goes for the name inside the pack structure
+                       l = strlen(pak->shortname);
+                       if(l >= 7)
+                               if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
+                                       pak->shortname[l - 3] = 0;
+                       l = strlen(pak->filename);
+                       if(l >= 7)
+                               if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
+                                       pak->filename[l - 3] = 0;
+               }
                return true;
        }
        else
@@ -917,20 +1106,20 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loade
 /*
 ================
 FS_AddPack
-
-Adds the given pack to the search path and searches for it in the game path.
-The pack type is autodetected by the file extension.
-
-Returns true if the file was successfully added to the
-search path or if it was already included.
-
-If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
-plain directories.
 ================
 */
+/*! Adds the given pack to the search path and searches for it in the game path.
+ * The pack type is autodetected by the file extension.
+ *
+ * Returns true if the file was successfully added to the
+ * search path or if it was already included.
+ *
+ * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
+ * plain directories.
+ */
 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
 {
-       char fullpath[MAX_QPATH];
+       char fullpath[MAX_OSPATH];
        int index;
        searchpath_t *search;
 
@@ -947,7 +1136,7 @@ qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep
 
        dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
 
-       return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
+       return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
 }
 
 
@@ -964,12 +1153,11 @@ void FS_AddGameDirectory (const char *dir)
        int i;
        stringlist_t list;
        searchpath_t *search;
-       char pakfile[MAX_OSPATH];
 
        strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
 
        stringlistinit(&list);
-       listdirectory(&list, dir);
+       listdirectory(&list, "", dir);
        stringlistsort(&list);
 
        // add any PAK package in the directory
@@ -977,18 +1165,16 @@ void FS_AddGameDirectory (const char *dir)
        {
                if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
                {
-                       dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
-                       FS_AddPack_Fullpath(pakfile, NULL, false);
+                       FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
                }
        }
 
        // add any PK3 package in the directory
        for (i = 0;i < list.numstrings;i++)
        {
-               if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
+               if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
                {
-                       dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
-                       FS_AddPack_Fullpath(pakfile, NULL, false);
+                       FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
                }
        }
 
@@ -1010,19 +1196,11 @@ 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
+       if (*fs_userdir)
+               FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
 }
 
 
@@ -1078,20 +1256,41 @@ FS_ClearSearchPath
 */
 void FS_ClearSearchPath (void)
 {
+       // unload all packs and directory information, close all pack files
+       // (if a qfile is still reading a pack it won't be harmed because it used
+       //  dup() to get its own handle already)
        while (fs_searchpaths)
        {
                searchpath_t *search = fs_searchpaths;
                fs_searchpaths = search->next;
-               if (search->pack)
+               if (search->pack && search->pack != fs_selfpack)
                {
-                       if (search->pack->files)
-                               Mem_Free(search->pack->files);
+                       if(!search->pack->vpack)
+                       {
+                               // close the file
+                               close(search->pack->handle);
+                               // free any memory associated with it
+                               if (search->pack->files)
+                                       Mem_Free(search->pack->files);
+                       }
                        Mem_Free(search->pack);
                }
                Mem_Free(search);
        }
 }
 
+static void FS_AddSelfPack(void)
+{
+       if(fs_selfpack)
+       {
+               searchpath_t *search;
+               search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
+               search->next = fs_searchpaths;
+               search->pack = fs_selfpack;
+               fs_searchpaths = search;
+       }
+}
+
 
 /*
 ================
@@ -1102,6 +1301,7 @@ void FS_Rescan (void)
 {
        int i;
        qboolean fs_modified = false;
+       char gamedirbuf[MAX_INPUTLINE];
 
        FS_ClearSearchPath();
 
@@ -1123,13 +1323,22 @@ void FS_Rescan (void)
        // Adds basedir/gamedir as an override game
        // LordHavoc: now supports multiple -game directories
        // set the com_modname (reported in server info)
+       *gamedirbuf = 0;
        for (i = 0;i < fs_numgamedirs;i++)
        {
                fs_modified = true;
                FS_AddGameHierarchy (fs_gamedirs[i]);
                // update the com_modname (used server info)
                strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
+               if(i)
+                       strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
+               else
+                       strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
        }
+       Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
+
+       // add back the selfpack as new first item
+       FS_AddSelfPack();
 
        // set the default screenshot name to either the mod name or the
        // gamemode screenshot name
@@ -1137,25 +1346,44 @@ void FS_Rescan (void)
                Cvar_SetQuick (&scr_screenshot_name, com_modname);
        else
                Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
+       
+       if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
+               strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
 
        // If "-condebug" is in the command line, remove the previous log file
        if (COM_CheckParm ("-condebug") != 0)
                unlink (va("%s/qconsole.log", fs_gamedir));
 
        // look for the pop.lmp file and set registered to true if it is found
-       if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
+       if (FS_FileExists("gfx/pop.lmp"))
+               Cvar_Set ("registered", "1");
+       switch(gamemode)
        {
-               if (fs_modified)
-                       Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+       case GAME_NORMAL:
+       case GAME_HIPNOTIC:
+       case GAME_ROGUE:
+               if (!registered.integer)
+               {
+                       if (fs_modified)
+                               Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+                       else
+                               Con_Print("Playing shareware version.\n");
+               }
                else
-                       Con_Print("Playing shareware version.\n");
-       }
-       else
-       {
-               Cvar_Set ("registered", "1");
-               if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
                        Con_Print("Playing registered version.\n");
+               break;
+       case GAME_STEELSTORM:
+               if (registered.integer)
+                       Con_Print("Playing registered version.\n");
+               else
+                       Con_Print("Playing shareware version.\n");
+               break;
+       default:
+               break;
        }
+
+       // unload all wads so that future queries will return the new data
+       W_UnloadAll();
 }
 
 void FS_Rescan_f(void)
@@ -1168,11 +1396,12 @@ void FS_Rescan_f(void)
 FS_ChangeGameDirs
 ================
 */
-extern void Host_SaveConfig_f (void);
+extern void Host_SaveConfig (void);
 extern void Host_LoadConfig_f (void);
 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
 {
        int i;
+       const char *p;
 
        if (fs_numgamedirs == numgamedirs)
        {
@@ -1193,17 +1422,14 @@ qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean
        for (i = 0;i < numgamedirs;i++)
        {
                // if string is nasty, reject it
-               if(FS_CheckNastyPath(gamedirs[i], true))
+               p = FS_CheckGameDir(gamedirs[i]);
+               if(!p)
                {
                        if (complain)
                                Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
                        return false; // nasty gamedirs
                }
-       }
-
-       for (i = 0;i < numgamedirs;i++)
-       {
-               if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
+               if(p == fs_checkgamedir_missing && failmissing)
                {
                        if (complain)
                                Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
@@ -1211,7 +1437,7 @@ qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean
                }
        }
 
-       Host_SaveConfig_f();
+       Host_SaveConfig();
 
        fs_numgamedirs = numgamedirs;
        for (i = 0;i < fs_numgamedirs;i++)
@@ -1223,8 +1449,8 @@ qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean
        // exec the new config
        Host_LoadConfig_f();
 
-       // reinitialize the loaded sounds
-       S_Reload_f();
+       // unload all sounds so they will be reloaded from the new files as needed
+       S_UnloadAllSounds_f();
 
        // reinitialize renderer (this reloads hud/console background/etc)
        R_Modules_Restart();
@@ -1262,37 +1488,185 @@ void FS_GameDir_f (void)
        for (i = 0;i < numgamedirs;i++)
                strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
 
-       // allow gamedir change during demo loop
-       if (cls.demoplayback)
-               CL_Disconnect();
-
-       if (cls.state == ca_connected || sv.active)
+       if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
        {
                // actually, changing during game would work fine, but would be stupid
                Con_Printf("Can not change gamedir while client is connected or server is running!\n");
                return;
        }
 
+       // halt demo playback to close the file
+       CL_Disconnect();
+
        FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
 }
 
+static const char *FS_SysCheckGameDir(const char *gamedir)
+{
+       static char buf[8192];
+       qboolean success;
+       qfile_t *f;
+       stringlist_t list;
+       fs_offset_t n;
+
+       stringlistinit(&list);
+       listdirectory(&list, gamedir, "");
+       success = list.numstrings > 0;
+       stringlistfreecontents(&list);
+
+       if(success)
+       {
+               f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
+               if(f)
+               {
+                       n = FS_Read (f, buf, sizeof(buf) - 1);
+                       if(n >= 0)
+                               buf[n] = 0;
+                       else
+                               *buf = 0;
+                       FS_Close(f);
+               }
+               else
+                       *buf = 0;
+               return buf;
+       }
+
+       return NULL;
+}
 
 /*
 ================
 FS_CheckGameDir
 ================
 */
-qboolean FS_CheckGameDir(const char *gamedir)
+const char *FS_CheckGameDir(const char *gamedir)
 {
-       qboolean success;
-       stringlist_t list;
+       const char *ret;
+
+       if (FS_CheckNastyPath(gamedir, true))
+               return NULL;
+
+       ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
+       if(ret)
+       {
+               if(!*ret)
+               {
+                       // get description from basedir
+                       ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+                       if(ret)
+                               return ret;
+                       return "";
+               }
+               return ret;
+       }
+
+       ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+       if(ret)
+               return ret;
+       
+       return fs_checkgamedir_missing;
+}
+
+static void FS_ListGameDirs(void)
+{
+       stringlist_t list, list2;
+       int i, j;
+       const char *info;
+
+       fs_all_gamedirs_count = 0;
+       if(fs_all_gamedirs)
+               Mem_Free(fs_all_gamedirs);
+
        stringlistinit(&list);
-       listdirectory(&list, va("%s%s/", fs_basedir, gamedir));
-       success = list.numstrings > 0;
+       listdirectory(&list, va("%s/", fs_basedir), "");
+       listdirectory(&list, va("%s/", fs_userdir), "");
+       stringlistsort(&list);
+
+       stringlistinit(&list2);
+       for(i = 0; i < list.numstrings; ++i)
+       {
+               if(i)
+                       if(!strcmp(list.strings[i-1], list.strings[i]))
+                               continue;
+               info = FS_CheckGameDir(list.strings[i]);
+               if(!info)
+                       continue;
+               if(info == fs_checkgamedir_missing)
+                       continue;
+               if(!*info)
+                       continue;
+               stringlistappend(&list2, list.strings[i]); 
+       }
        stringlistfreecontents(&list);
-       return success;
+
+       fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
+       for(i = 0; i < list2.numstrings; ++i)
+       {
+               info = FS_CheckGameDir(list2.strings[i]);
+               // all this cannot happen any more, but better be safe than sorry
+               if(!info)
+                       continue;
+               if(info == fs_checkgamedir_missing)
+                       continue;
+               if(!*info)
+                       continue;
+               strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
+               strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
+               ++fs_all_gamedirs_count;
+       }
 }
 
+/*
+================
+FS_Init_SelfPack
+================
+*/
+void FS_Init_SelfPack (void)
+{
+       PK3_OpenLibrary ();
+       fs_mempool = Mem_AllocPool("file management", 0, NULL);
+       if(com_selffd >= 0)
+       {
+               fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
+               if(fs_selfpack)
+               {
+                       char *buf, *q;
+                       const char *p;
+                       FS_AddSelfPack();
+                       buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
+                       if(buf)
+                       {
+                               const char **new_argv;
+                               int i = 0;
+                               int args_left = 256;
+                               new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
+                               if(com_argc == 0)
+                               {
+                                       new_argv[0] = "dummy";
+                                       com_argc = 1;
+                               }
+                               else
+                               {
+                                       memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
+                               }
+                               p = buf;
+                               while(COM_ParseToken_Console(&p))
+                               {
+                                       if(i >= args_left)
+                                               break;
+                                       q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
+                                       strlcpy(q, com_token, strlen(com_token) + 1);
+                                       new_argv[com_argc + i] = q;
+                                       ++i;
+                               }
+                               new_argv[i+com_argc] = NULL;
+                               com_argv = new_argv;
+                               com_argc = com_argc + i;
+                       }
+                       Mem_Free(buf);
+               }
+       }
+}
 
 /*
 ================
@@ -1301,9 +1675,90 @@ FS_Init
 */
 void FS_Init (void)
 {
+       const char *p;
        int i;
+#ifdef WIN32
+       TCHAR mydocsdir[MAX_PATH + 1];
+#if _MSC_VER >= 1400
+       size_t homedirlen;
+#endif
+#endif
+       char *homedir;
 
-       fs_mempool = Mem_AllocPool("file management", 0, NULL);
+#ifdef WIN32
+       const char* dllnames [] =
+       {
+               "shfolder.dll",  // IE 4, or Win NT and higher
+               NULL
+       };
+       Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
+       // don't care for the result; if it fails, %USERPROFILE% will be used instead
+#endif
+
+       // Add the personal game directory
+       if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
+       {
+               dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
+       }
+       else if(COM_CheckParm("-nohome"))
+       {
+               *fs_userdir = 0;
+       }
+       else
+       {
+#ifdef WIN32
+               if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
+               {
+                       dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
+                       Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
+               }
+               else
+               {
+                       // use the environment
+#if _MSC_VER >= 1400
+                       _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
+#else
+                       homedir = getenv("USERPROFILE");
+#endif
+
+                       if(homedir)
+                       {
+                               dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
+#if _MSC_VER >= 1400
+                               free(homedir);
+#endif
+                               Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
+                       }
+               }
+
+               if(!*fs_userdir)
+                       Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
+#else
+               homedir = getenv ("HOME");
+               if(homedir)
+                       dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
+
+               if(!*fs_userdir)
+                       Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
+#endif
+
+#ifdef WIN32
+               if(!COM_CheckParm("-mygames"))
+               {
+#if _MSC_VER >= 1400
+                       int fd;
+                       _sopen_s(&fd, va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
+#else
+                       int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
+#endif
+                       if(fd >= 0)
+                       {
+                               close(fd);
+                               *fs_userdir = 0; // we have write access to the game dir, so let's use it
+                       }
+               }
+#endif
+       }
 
        strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
 
@@ -1311,7 +1766,7 @@ void FS_Init (void)
 #ifdef DP_FS_BASEDIR
        strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
 #else
-       strlcpy(fs_basedir, "", sizeof(fs_basedir));
+       *fs_basedir = 0;
 
 #ifdef MACOSX
        // FIXME: is there a better way to find the directory outside the .app?
@@ -1328,8 +1783,6 @@ void FS_Init (void)
 #endif
 #endif
 
-       PK3_OpenLibrary ();
-
        // -basedir <path>
        // Overrides the system supplied base directory (under GAMENAME)
 // COMMANDLINEOPTION: Filesystem: -basedir <path> chooses what base directory the game data is in, inside this there should be a data directory for the game (for example id1)
@@ -1346,11 +1799,18 @@ void FS_Init (void)
        if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
                strlcat(fs_basedir, "/", sizeof(fs_basedir));
 
-       if (!FS_CheckGameDir(gamedirname1))
-               Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
+       FS_ListGameDirs();
 
-       if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
-               Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
+       p = FS_CheckGameDir(gamedirname1);
+       if(!p || p == fs_checkgamedir_missing)
+               Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
+
+       if(gamedirname2)
+       {
+               p = FS_CheckGameDir(gamedirname2);
+               if(!p || p == fs_checkgamedir_missing)
+                       Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
+       }
 
        // -game <gamedir>
        // Adds basedir/gamedir as an override game
@@ -1362,10 +1822,11 @@ void FS_Init (void)
                if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
                {
                        i++;
-                       if (FS_CheckNastyPath(com_argv[i], true))
-                               Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
-                       if (!FS_CheckGameDir(com_argv[i]))
-                               Sys_Error("-game %s%s/ not found!\n", fs_basedir, com_argv[i]);
+                       p = FS_CheckGameDir(com_argv[i]);
+                       if(!p)
+                               Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
+                       if(p == fs_checkgamedir_missing)
+                               Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
                        // add the gamedir to the list of active gamedirs
                        strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
                        fs_numgamedirs++;
@@ -1379,12 +1840,15 @@ void FS_Init (void)
 void FS_Init_Commands(void)
 {
        Cvar_RegisterVariable (&scr_screenshot_name);
+       Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
+       Cvar_RegisterVariable (&cvar_fs_gamedir);
 
        Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
        Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
        Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
        Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
        Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
+       Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
 }
 
 /*
@@ -1394,19 +1858,20 @@ FS_Shutdown
 */
 void FS_Shutdown (void)
 {
+       // close all pack files and such
+       // (hopefully there aren't any other open files, but they'll be cleaned up
+       //  by the OS anyway)
+       FS_ClearSearchPath();
        Mem_FreePool (&fs_mempool);
-}
 
-/*
-====================
-FS_SysOpen
+#ifdef WIN32
+       Sys_UnloadLibrary (&shfolder_dll);
+#endif
+}
 
-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, qboolean nonblocking)
+int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
 {
-       qfile_t* file;
+       int handle;
        int mod, opt;
        unsigned int ind;
 
@@ -1427,7 +1892,7 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean non
                        break;
                default:
                        Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
-                       return NULL;
+                       return -1;
        }
        for (ind = 1; mode[ind] != '\0'; ind++)
        {
@@ -1448,21 +1913,40 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean non
        if (nonblocking)
                opt |= O_NONBLOCK;
 
+#if _MSC_VER >= 1400
+       _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#else
+       handle = open (filepath, mod | opt, 0666);
+#endif
+       return handle;
+}
+
+/*
+====================
+FS_SysOpen
+
+Internal function used to create a qfile_t and open the relevant non-packed file on disk
+====================
+*/
+qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
+{
+       qfile_t* file;
+
        file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
-       memset (file, 0, sizeof (*file));
        file->ungetc = EOF;
-
-       file->handle = open (filepath, mod | opt, 0666);
+       file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
        if (file->handle < 0)
        {
                Mem_Free (file);
                return NULL;
        }
 
+       file->filename = Mem_strdup(fs_mempool, filepath);
+
        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)
+       if (mode[0] == 'a')
                file->position = file->real_length;
        else
                lseek (file->handle, 0, SEEK_SET);
@@ -1491,6 +1975,7 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                if (!PK3_GetTrueFileOffset (pfile, pack))
                        return NULL;
 
+#ifndef LINK_TO_ZLIB
        // No Zlib DLL = no compressed files
        if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
        {
@@ -1499,6 +1984,7 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                                        pfile->name);
                return NULL;
        }
+#endif
 
        // 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
@@ -1651,7 +2137,7 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
        for (search = fs_searchpaths;search;search = search->next)
        {
                // is the element a pak file?
-               if (search->pack)
+               if (search->pack && !search->pack->vpack)
                {
                        int (*strcmp_funct) (const char* str1, const char* str2);
                        int left, right, middle;
@@ -1672,8 +2158,19 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                                // Found it
                                if (!diff)
                                {
-                                       if (!quiet && developer.integer >= 10)
-                                               Con_Printf("FS_FindFile: %s in %s\n",
+                                       if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
+                                       {
+                                               // yes, but the first one is empty so we treat it as not being there
+                                               if (!quiet && developer_extra.integer)
+                                                       Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
+
+                                               if (index != NULL)
+                                                       *index = -1;
+                                               return NULL;
+                                       }
+
+                                       if (!quiet && developer_extra.integer)
+                                               Con_DPrintf("FS_FindFile: %s in %s\n",
                                                                        pak->files[middle].name, pak->filename);
 
                                        if (index != NULL)
@@ -1694,8 +2191,8 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                        dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
                        if (FS_SysFileExists (netpath))
                        {
-                               if (!quiet && developer.integer >= 10)
-                                       Con_Printf("FS_FindFile: %s\n", netpath);
+                               if (!quiet && developer_extra.integer)
+                                       Con_DPrintf("FS_FindFile: %s\n", netpath);
 
                                if (index != NULL)
                                        *index = -1;
@@ -1704,8 +2201,8 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                }
        }
 
-       if (!quiet && developer.integer >= 10)
-               Con_Printf("FS_FindFile: can't find %s\n", name);
+       if (!quiet && developer_extra.integer)
+               Con_DPrintf("FS_FindFile: can't find %s\n", name);
 
        if (index != NULL)
                *index = -1;
@@ -1720,7 +2217,7 @@ FS_OpenReadFile
 Look for a file in the search paths and open it in read-only mode
 ===========
 */
-qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
+qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
 {
        searchpath_t *search;
        int pack_ind;
@@ -1734,12 +2231,87 @@ qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonbloc
        // Found in the filesystem?
        if (pack_ind < 0)
        {
+               // this works with vpacks, so we are fine
                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...
+
+       // Is it a PK3 symlink?
+       // TODO also handle directory symlinks by parsing the whole structure...
+       // but heck, file symlinks are good enough for now
+       if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
+       {
+               if(symlinkLevels <= 0)
+               {
+                       Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
+                       return NULL;
+               }
+               else
+               {
+                       char linkbuf[MAX_QPATH];
+                       fs_offset_t count;
+                       qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
+                       const char *mergeslash;
+                       char *mergestart;
+
+                       if(!linkfile)
+                               return NULL;
+                       count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
+                       FS_Close(linkfile);
+                       if(count < 0)
+                               return NULL;
+                       linkbuf[count] = 0;
+                       
+                       // Now combine the paths...
+                       mergeslash = strrchr(filename, '/');
+                       mergestart = linkbuf;
+                       if(!mergeslash)
+                               mergeslash = filename;
+                       while(!strncmp(mergestart, "../", 3))
+                       {
+                               mergestart += 3;
+                               while(mergeslash > filename)
+                               {
+                                       --mergeslash;
+                                       if(*mergeslash == '/')
+                                               break;
+                               }
+                       }
+                       // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
+                       if(mergeslash == filename)
+                       {
+                               // Either mergeslash == filename, then we just replace the name (done below)
+                       }
+                       else
+                       {
+                               // Or, we append the name after mergeslash;
+                               // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
+                               int spaceNeeded = mergeslash - filename + 1;
+                               int spaceRemoved = mergestart - linkbuf;
+                               if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
+                               {
+                                       Con_DPrintf("symlink: too long path rejected\n");
+                                       return NULL;
+                               }
+                               memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
+                               memcpy(linkbuf, filename, spaceNeeded);
+                               linkbuf[count - spaceRemoved + spaceNeeded] = 0;
+                               mergestart = linkbuf;
+                       }
+                       if (!quiet && developer_loading.integer)
+                               Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
+                       if(FS_CheckNastyPath (mergestart, false))
+                       {
+                               Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
+                               return NULL;
+                       }
+                       return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
+               }
+       }
+
        return FS_OpenPackedFile (search->pack, pack_ind);
 }
 
@@ -1754,38 +2326,70 @@ MAIN PUBLIC FUNCTIONS
 
 /*
 ====================
-FS_Open
+FS_OpenRealFile
 
-Open a file. The syntax is the same as fopen
+Open a file in the userpath. The syntax is the same as fopen
+Used for savegame scanning in menu, and all file writing.
 ====================
 */
-qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
+qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
 {
+       char real_path [MAX_OSPATH];
+
        if (FS_CheckNastyPath(filepath, false))
        {
-               Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
+               Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
                return NULL;
        }
 
-       // If the file is opened in "write", "append", or "read/write" mode
+       dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
+
+       // If the file is opened in "write", "append", or "read/write" mode,
+       // create directories up to the file.
        if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
-       {
-               char real_path [MAX_OSPATH];
+               FS_CreatePath (real_path);
+       return FS_SysOpen (real_path, mode, false);
+}
 
-               // Open the file on disk directly
-               dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
 
-               // Create directories up to the file
-               FS_CreatePath (real_path);
+/*
+====================
+FS_OpenVirtualFile
 
-               return FS_SysOpen (real_path, mode, nonblocking);
+Open a file. The syntax is the same as fopen
+====================
+*/
+qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
+{
+       if (FS_CheckNastyPath(filepath, false))
+       {
+               Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
+               return NULL;
        }
-       // Else, we look at the various search paths and open the file in read-only mode
-       else
-               return FS_OpenReadFile (filepath, quiet, nonblocking);
+
+       return FS_OpenReadFile (filepath, quiet, false, 16);
 }
 
 
+/*
+====================
+FS_FileFromData
+
+Open a file. The syntax is the same as fopen
+====================
+*/
+qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
+{
+       qfile_t* file;
+       file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
+       memset (file, 0, sizeof (*file));
+       file->flags = QFILE_FLAG_DATA;
+       file->ungetc = EOF;
+       file->real_length = size;
+       file->data = data;
+       return file;
+}
+
 /*
 ====================
 FS_Close
@@ -1795,9 +2399,23 @@ Close a file
 */
 int FS_Close (qfile_t* file)
 {
+       if(file->flags & QFILE_FLAG_DATA)
+       {
+               Mem_Free(file);
+               return 0;
+       }
+
        if (close (file->handle))
                return EOF;
 
+       if (file->filename)
+       {
+               if (file->flags & QFILE_FLAG_REMOVE)
+                       remove(file->filename);
+
+               Mem_Free((void *) file->filename);
+       }
+
        if (file->ztk)
        {
                qz_inflateEnd (&file->ztk->zstream);
@@ -1808,6 +2426,10 @@ int FS_Close (qfile_t* file)
        return 0;
 }
 
+void FS_RemoveOnClose(qfile_t* file)
+{
+       file->flags |= QFILE_FLAG_REMOVE;
+}
 
 /*
 ====================
@@ -1865,16 +2487,26 @@ fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
        else
                done = 0;
 
+       if(file->flags & QFILE_FLAG_DATA)
+       {
+               size_t left = file->real_length - file->position;
+               if(buffersize > left)
+                       buffersize = left;
+               memcpy(buffer, file->data + file->position, buffersize);
+               file->position += buffersize;
+               return buffersize;
+       }
+
        // 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;
+               count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
+               done += count;
+               memcpy (buffer, &file->buff[file->buff_ind], count);
+               file->buff_ind += count;
 
-               done += ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
-               memcpy (buffer, &file->buff[file->buff_ind], done);
-               file->buff_ind += done;
-
-               buffersize -= done;
+               buffersize -= count;
                if (buffersize == 0)
                        return done;
        }
@@ -2086,7 +2718,7 @@ Get the next character of a file
 */
 int FS_Getc (qfile_t* file)
 {
-       char c;
+       unsigned char c;
 
        if (FS_Read (file, &c, 1) != 1)
                return EOF;
@@ -2143,9 +2775,15 @@ int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
                default:
                        return -1;
        }
-       if (offset < 0 || offset > (long) file->real_length)
+       if (offset < 0 || offset > file->real_length)
                return -1;
 
+       if(file->flags & QFILE_FLAG_DATA)
+       {
+               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)
        {
@@ -2263,14 +2901,23 @@ unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, f
        unsigned char *buf = NULL;
        fs_offset_t filesize = 0;
 
-       file = FS_Open (path, "rb", quiet, false);
+       file = FS_OpenVirtualFile(path, quiet);
        if (file)
        {
                filesize = file->real_length;
+               if(filesize < 0)
+               {
+                       Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
+                       FS_Close(file);
+                       return NULL;
+               }
+
                buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
                buf[filesize] = '\0';
                FS_Read (file, buf, filesize);
                FS_Close (file);
+               if (developer_loadfile.integer)
+                       Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
        }
 
        if (filesizepointer)
@@ -2286,23 +2933,34 @@ FS_WriteFile
 The filename will be prefixed by the current game directory
 ============
 */
-qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
+qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
 {
        qfile_t *file;
+       size_t i;
+       fs_offset_t lentotal;
 
-       file = FS_Open (filename, "wb", false, false);
+       file = FS_OpenRealFile(filename, "wb", false);
        if (!file)
        {
                Con_Printf("FS_WriteFile: failed on %s\n", filename);
                return false;
        }
 
-       Con_DPrintf("FS_WriteFile: %s\n", filename);
-       FS_Write (file, data, len);
+       lentotal = 0;
+       for(i = 0; i < count; ++i)
+               lentotal += len[i];
+       Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
+       for(i = 0; i < count; ++i)
+               FS_Write (file, data[i], len[i]);
        FS_Close (file);
        return true;
 }
 
+qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
+{
+       return FS_WriteFileInBlocks(filename, &data, &len, 1);
+}
+
 
 /*
 =============================================================================
@@ -2366,6 +3024,30 @@ void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
 }
 
 
+/*
+==================
+FS_FileType
+
+Look for a file in the packages and in the filesystem
+==================
+*/
+int FS_FileType (const char *filename)
+{
+       searchpath_t *search;
+       char fullpath[MAX_OSPATH];
+
+       search = FS_FindFile (filename, NULL, true);
+       if(!search)
+               return FS_FILETYPE_NONE;
+
+       if(search->pack && !search->pack->vpack)
+               return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
+
+       dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
+       return FS_SysFileType(fullpath);
+}
+
+
 /*
 ==================
 FS_FileExists
@@ -2386,26 +3068,42 @@ FS_SysFileExists
 Look for a file in the filesystem only
 ==================
 */
-qboolean FS_SysFileExists (const char *path)
+int FS_SysFileType (const char *path)
 {
 #if WIN32
-       int desc;
+// Sajt - some older sdks are missing this define
+# ifndef INVALID_FILE_ATTRIBUTES
+#  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+# endif
 
-       // TODO: use another function instead, to avoid opening the file
-       desc = open (path, O_RDONLY | O_BINARY);
-       if (desc < 0)
-               return false;
+       DWORD result = GetFileAttributes(path);
 
-       close (desc);
-       return true;
+       if(result == INVALID_FILE_ATTRIBUTES)
+               return FS_FILETYPE_NONE;
+
+       if(result & FILE_ATTRIBUTE_DIRECTORY)
+               return FS_FILETYPE_DIRECTORY;
+
+       return FS_FILETYPE_FILE;
 #else
        struct stat buf;
 
        if (stat (path,&buf) == -1)
-               return false;
+               return FS_FILETYPE_NONE;
 
-       return true;
+#ifndef S_ISDIR
+#define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
 #endif
+       if(S_ISDIR(buf.st_mode))
+               return FS_FILETYPE_DIRECTORY;
+
+       return FS_FILETYPE_FILE;
+#endif
+}
+
+qboolean FS_SysFileExists (const char *path)
+{
+       return FS_SysFileType (path) != FS_FILETYPE_NONE;
 }
 
 void FS_mkdir (const char *path)
@@ -2434,7 +3132,6 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
        stringlist_t dirlist;
        const char *slash, *backslash, *colon, *separator;
        char *basepath;
-       char netpath[MAX_OSPATH];
        char temp[MAX_OSPATH];
 
        for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
@@ -2464,7 +3161,7 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
        for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
        {
                // is the element a pak file?
-               if (searchpath->pack)
+               if (searchpath->pack && !searchpath->pack->vpack)
                {
                        // look through all the pak file elements
                        pak = searchpath->pack;
@@ -2481,8 +3178,8 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                                                if (resultlistindex == resultlist.numstrings)
                                                {
                                                        stringlistappend(&resultlist, temp);
-                                                       if (!quiet)
-                                                               Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
+                                                       if (!quiet && developer_loading.integer)
+                                                               Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
                                                }
                                        }
                                        // strip off one path element at a time until empty
@@ -2503,13 +3200,80 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                }
                else
                {
-                       // get a directory listing and look at each name
-                       dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
-                       stringlistinit(&dirlist);
-                       listdirectory(&dirlist, netpath);
-                       for (dirlistindex = 0;dirlistindex < dirlist.numstrings;dirlistindex++)
+                       stringlist_t matchedSet, foundSet;
+                       const char *start = pattern;
+
+                       stringlistinit(&matchedSet);
+                       stringlistinit(&foundSet);
+                       // add a first entry to the set
+                       stringlistappend(&matchedSet, "");
+                       // iterate through pattern's path
+                       while (*start)
                        {
-                               dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirlist.strings[dirlistindex]);
+                               const char *asterisk, *wildcard, *nextseparator, *prevseparator;
+                               char subpath[MAX_OSPATH];
+                               char subpattern[MAX_OSPATH];
+
+                               // find the next wildcard
+                               wildcard = strchr(start, '?');
+                               asterisk = strchr(start, '*');
+                               if (asterisk && (!wildcard || asterisk < wildcard))
+                               {
+                                       wildcard = asterisk;
+                               }
+
+                               if (wildcard)
+                               {
+                                       nextseparator = strchr( wildcard, '/' );
+                               }
+                               else
+                               {
+                                       nextseparator = NULL;
+                               }
+
+                               if( !nextseparator ) {
+                                       nextseparator = start + strlen( start );
+                               }
+
+                               // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
+                               // copy everything up except nextseperator
+                               strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
+                               // find the last '/' before the wildcard
+                               prevseparator = strrchr( subpattern, '/' );
+                               if (!prevseparator)
+                                       prevseparator = subpattern;
+                               else
+                                       prevseparator++;
+                               // copy everything from start to the previous including the '/' (before the wildcard)
+                               // everything up to start is already included in the path of matchedSet's entries
+                               strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
+
+                               // for each entry in matchedSet try to open the subdirectories specified in subpath
+                               for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
+                                       strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
+                                       strlcat( temp, subpath, sizeof(temp) );
+                                       listdirectory( &foundSet, searchpath->filename, temp );
+                               }
+                               if( dirlistindex == 0 ) {
+                                       break;
+                               }
+                               // reset the current result set
+                               stringlistfreecontents( &matchedSet );
+                               // match against the pattern
+                               for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
+                                       const char *direntry = foundSet.strings[ dirlistindex ];
+                                       if (matchpattern(direntry, subpattern, true)) {
+                                               stringlistappend( &matchedSet, direntry );
+                                       }
+                               }
+                               stringlistfreecontents( &foundSet );
+
+                               start = nextseparator;
+                       }
+
+                       for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
+                       {
+                               const char *temp = matchedSet.strings[dirlistindex];
                                if (matchpattern(temp, (char *)pattern, true))
                                {
                                        for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
@@ -2518,12 +3282,12 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                                        if (resultlistindex == resultlist.numstrings)
                                        {
                                                stringlistappend(&resultlist, temp);
-                                               if (!quiet)
-                                                       Con_DPrintf("SearchDirFile: %s\n", temp);
+                                               if (!quiet && developer_loading.integer)
+                                                       Con_Printf("SearchDirFile: %s\n", temp);
                                        }
                                }
                        }
-                       stringlistfreecontents(&dirlist);
+                       stringlistfreecontents( &matchedSet );
                }
        }
 
@@ -2656,12 +3420,40 @@ void FS_Ls_f(void)
        FS_ListDirectoryCmd("ls", false);
 }
 
+void FS_Which_f(void)
+{
+       const char *filename;
+       int index;
+       searchpath_t *sp;
+       if (Cmd_Argc() != 2)
+       {
+               Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
+               return;
+       }  
+       filename = Cmd_Argv(1);
+       sp = FS_FindFile(filename, &index, true);
+       if (!sp) {
+               Con_Printf("%s isn't anywhere\n", filename);
+               return;
+       }
+       if (sp->pack)
+       {
+               if(sp->pack->vpack)
+                       Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
+               else
+                       Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
+       }
+       else
+               Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
+}
+
+
 const char *FS_WhichPack(const char *filename)
 {
        int index;
        searchpath_t *sp = FS_FindFile(filename, &index, true);
        if(sp && sp->pack)
-               return sp->pack->filename;
+               return sp->pack->shortname;
        else
                return 0;
 }
@@ -2683,7 +3475,8 @@ qboolean FS_IsRegisteredQuakePack(const char *name)
        // search through the path, one element at a time
        for (search = fs_searchpaths;search;search = search->next)
        {
-               if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
+               if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
+                       // TODO do we want to support vpacks in here too?
                {
                        int (*strcmp_funct) (const char* str1, const char* str2);
                        int left, right, middle;
@@ -2740,3 +3533,193 @@ int FS_CRCFile(const char *filename, size_t *filesizepointer)
        return crc;
 }
 
+unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
+{
+       z_stream strm;
+       unsigned char *out = NULL;
+       unsigned char *tmp;
+
+       *deflated_size = 0;
+#ifndef LINK_TO_ZLIB
+       if(!zlib_dll)
+               return NULL;
+#endif
+
+       memset(&strm, 0, sizeof(strm));
+       strm.zalloc = Z_NULL;
+       strm.zfree = Z_NULL;
+       strm.opaque = Z_NULL;
+
+       if(level < 0)
+               level = Z_DEFAULT_COMPRESSION;
+
+       if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
+       {
+               Con_Printf("FS_Deflate: deflate init error!\n");
+               return NULL;
+       }
+
+       strm.next_in = (unsigned char*)data;
+       strm.avail_in = size;
+
+       tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
+       if(!tmp)
+       {
+               Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
+               qz_deflateEnd(&strm);
+               return NULL;
+       }
+
+       strm.next_out = tmp;
+       strm.avail_out = size;
+
+       if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
+       {
+               Con_Printf("FS_Deflate: deflate failed!\n");
+               qz_deflateEnd(&strm);
+               Mem_Free(tmp);
+               return NULL;
+       }
+       
+       if(qz_deflateEnd(&strm) != Z_OK)
+       {
+               Con_Printf("FS_Deflate: deflateEnd failed\n");
+               Mem_Free(tmp);
+               return NULL;
+       }
+
+       if(strm.total_out >= size)
+       {
+               Con_Printf("FS_Deflate: deflate is useless on this data!\n");
+               Mem_Free(tmp);
+               return NULL;
+       }
+
+       out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
+       if(!out)
+       {
+               Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
+               Mem_Free(tmp);
+               return NULL;
+       }
+
+       if(deflated_size)
+               *deflated_size = (size_t)strm.total_out;
+
+       memcpy(out, tmp, strm.total_out);
+       Mem_Free(tmp);
+       
+       return out;
+}
+
+static void AssertBufsize(sizebuf_t *buf, int length)
+{
+       if(buf->cursize + length > buf->maxsize)
+       {
+               int oldsize = buf->maxsize;
+               unsigned char *olddata;
+               olddata = buf->data;
+               buf->maxsize += length;
+               buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
+               if(olddata)
+               {
+                       memcpy(buf->data, olddata, oldsize);
+                       Mem_Free(olddata);
+               }
+       }
+}
+
+unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
+{
+       int ret;
+       z_stream strm;
+       unsigned char *out = NULL;
+       unsigned char tmp[2048];
+       unsigned int have;
+       sizebuf_t outbuf;
+
+       *inflated_size = 0;
+#ifndef LINK_TO_ZLIB
+       if(!zlib_dll)
+               return NULL;
+#endif
+
+       memset(&outbuf, 0, sizeof(outbuf));
+       outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
+       outbuf.maxsize = sizeof(tmp);
+
+       memset(&strm, 0, sizeof(strm));
+       strm.zalloc = Z_NULL;
+       strm.zfree = Z_NULL;
+       strm.opaque = Z_NULL;
+
+       if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
+       {
+               Con_Printf("FS_Inflate: inflate init error!\n");
+               Mem_Free(outbuf.data);
+               return NULL;
+       }
+
+       strm.next_in = (unsigned char*)data;
+       strm.avail_in = size;
+
+       do
+       {
+               strm.next_out = tmp;
+               strm.avail_out = sizeof(tmp);
+               ret = qz_inflate(&strm, Z_NO_FLUSH);
+               // it either returns Z_OK on progress, Z_STREAM_END on end
+               // or an error code
+               switch(ret)
+               {
+                       case Z_STREAM_END:
+                       case Z_OK:
+                               break;
+                               
+                       case Z_STREAM_ERROR:
+                               Con_Print("FS_Inflate: stream error!\n");
+                               break;
+                       case Z_DATA_ERROR:
+                               Con_Print("FS_Inflate: data error!\n");
+                               break;
+                       case Z_MEM_ERROR:
+                               Con_Print("FS_Inflate: mem error!\n");
+                               break;
+                       case Z_BUF_ERROR:
+                               Con_Print("FS_Inflate: buf error!\n");
+                               break;
+                       default:
+                               Con_Print("FS_Inflate: unknown error!\n");
+                               break;
+                               
+               }
+               if(ret != Z_OK && ret != Z_STREAM_END)
+               {
+                       Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
+                       Mem_Free(outbuf.data);
+                       qz_inflateEnd(&strm);
+                       return NULL;
+               }
+               have = sizeof(tmp) - strm.avail_out;
+               AssertBufsize(&outbuf, max(have, sizeof(tmp)));
+               SZ_Write(&outbuf, tmp, have);
+       } while(ret != Z_STREAM_END);
+
+       qz_inflateEnd(&strm);
+
+       out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
+       if(!out)
+       {
+               Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
+               Mem_Free(outbuf.data);
+               return NULL;
+       }
+
+       memcpy(out, outbuf.data, outbuf.cursize);
+       Mem_Free(outbuf.data);
+
+       if(inflated_size)
+               *inflated_size = (size_t)outbuf.cursize;
+       
+       return out;
+}