make infobar height configurable
[divverent/darkplaces.git] / fs.c
diff --git a/fs.c b/fs.c
index ad80668..a0dd2c8 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -22,8 +22,6 @@
                Boston, MA  02111-1307, USA
 */
 
-#include "quakedef.h"
-
 #include <limits.h>
 #include <fcntl.h>
 
@@ -37,6 +35,8 @@
 # include <unistd.h>
 #endif
 
+#include "quakedef.h"
+
 #include "fs.h"
 #include "wad.h"
 
 # 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.
@@ -95,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
@@ -115,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
 };
 
 
@@ -182,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;
 
 
@@ -206,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
@@ -251,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,
@@ -269,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)
 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)"};
 
 
 /*
@@ -291,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
@@ -302,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[] =
 {
@@ -312,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
 
 /*
 ====================
@@ -328,7 +415,9 @@ Unload the Zlib DLL
 */
 void PK3_CloseLibrary (void)
 {
+#ifndef LINK_TO_ZLIB
        Sys_UnloadLibrary (&zlib_dll);
+#endif
 }
 
 
@@ -341,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",
@@ -367,8 +457,25 @@ qboolean PK3_OpenLibrary (void)
 
        // Load the DLL
        return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
+#endif
 }
 
+/*
+====================
+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
+}
 
 /*
 ====================
@@ -426,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);
 
@@ -449,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
@@ -481,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))
@@ -508,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);
                        }
                }
@@ -537,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;
        }
@@ -591,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);
+}
 
 
 /*
@@ -695,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)
@@ -730,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);
        }
@@ -740,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;
@@ -755,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);
@@ -812,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)
        {
@@ -849,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
@@ -880,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;
                        }
@@ -888,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;
                        }
@@ -896,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
@@ -913,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;
 
@@ -943,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);
 }
 
 
@@ -972,16 +1165,16 @@ void FS_AddGameDirectory (const char *dir)
        {
                if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
                {
-                       FS_AddPack_Fullpath(list.strings[i], 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"))
                {
-                       FS_AddPack_Fullpath(list.strings[i], NULL, false);
+                       FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
                }
        }
 
@@ -1003,50 +1196,11 @@ FS_AddGameHierarchy
 */
 void FS_AddGameHierarchy (const char *dir)
 {
-       int i;
-       char userdir[MAX_QPATH];
-#ifdef WIN32
-       TCHAR mydocsdir[MAX_PATH + 1];
-#else
-       const char *homedir;
-#endif
-
        // Add the common game directory
        FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
 
-       *userdir = 0;
-
-       // Add the personal game directory
-#ifdef WIN32
-       if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
-               dpsnprintf(userdir, sizeof(userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
-       fprintf(stderr, "userdir = %s\n", userdir);
-#else
-       homedir = getenv ("HOME");
-       if(homedir)
-               dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
-#endif
-
-#ifdef WIN32
-       if(!COM_CheckParm("-mygames"))
-       {
-               int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
-               if(fd >= 0)
-               {
-                       close(fd);
-                       *userdir = 0; // we have write access to the game dir, so let's use it
-               }
-       }
-#endif
-
-       if(COM_CheckParm("-nohome"))
-               *userdir = 0;
-       
-       if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
-               dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
-
-       if (*userdir)
-               FS_AddGameDirectory(va("%s%s/", userdir, dir));
+       if (*fs_userdir)
+               FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
 }
 
 
@@ -1109,19 +1263,34 @@ void FS_ClearSearchPath (void)
        {
                searchpath_t *search = fs_searchpaths;
                fs_searchpaths = search->next;
-               if (search->pack)
+               if (search->pack && search->pack != fs_selfpack)
                {
-                       // close the file
-                       close(search->pack->handle);
-                       // free any memory associated with it
-                       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;
+       }
+}
+
 
 /*
 ================
@@ -1132,6 +1301,7 @@ void FS_Rescan (void)
 {
        int i;
        qboolean fs_modified = false;
+       char gamedirbuf[MAX_INPUTLINE];
 
        FS_ClearSearchPath();
 
@@ -1153,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
@@ -1167,24 +1346,40 @@ 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
@@ -1206,6 +1401,7 @@ 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)
        {
@@ -1226,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]);
@@ -1244,9 +1437,6 @@ qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean
                }
        }
 
-       // halt demo playback to close the file
-       CL_Disconnect();
-
        Host_SaveConfig();
 
        fs_numgamedirs = numgamedirs;
@@ -1305,26 +1495,178 @@ void FS_GameDir_f (void)
                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);
+               }
+       }
+}
 
 /*
 ================
@@ -1333,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));
 
@@ -1343,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?
@@ -1360,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)
@@ -1378,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
@@ -1394,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++;
@@ -1412,12 +1841,14 @@ 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");
 }
 
 /*
@@ -1432,18 +1863,15 @@ void FS_Shutdown (void)
        //  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;
 
@@ -1464,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++)
        {
@@ -1485,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);
@@ -1528,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))
        {
@@ -1536,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
@@ -1688,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;
@@ -1712,16 +2161,16 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                                        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.integer >= 10)
-                                                       Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
+                                               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.integer >= 10)
-                                               Con_Printf("FS_FindFile: %s in %s\n",
+                                       if (!quiet && developer_extra.integer)
+                                               Con_DPrintf("FS_FindFile: %s in %s\n",
                                                                        pak->files[middle].name, pak->filename);
 
                                        if (index != NULL)
@@ -1742,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;
@@ -1752,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;
@@ -1768,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;
@@ -1782,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);
 }
 
@@ -1802,49 +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)
-{
-#ifdef FS_FIX_PATHS
-       char fixedFileName[MAX_QPATH];
-       char *d;
-       strlcpy( fixedFileName, filepath, MAX_QPATH );
-       // try to fix common mistakes (\ instead of /)
-       for( d = fixedFileName ; *d ; d++ )
-               if( *d == '\\' )
-                       *d = '/';
-       filepath = fixedFileName;
-#endif
+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
@@ -1854,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);
@@ -1867,6 +2426,10 @@ int FS_Close (qfile_t* file)
        return 0;
 }
 
+void FS_RemoveOnClose(qfile_t* file)
+{
+       file->flags |= QFILE_FLAG_REMOVE;
+}
 
 /*
 ====================
@@ -1924,6 +2487,16 @@ 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)
        {
@@ -2205,6 +2778,12 @@ int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
        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)
        {
@@ -2322,10 +2901,17 @@ 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);
@@ -2347,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 (%u bytes)\n", filename, (unsigned int)len);
-       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);
+}
+
 
 /*
 =============================================================================
@@ -2437,13 +3034,13 @@ Look for a file in the packages and in the filesystem
 int FS_FileType (const char *filename)
 {
        searchpath_t *search;
-       char fullpath[MAX_QPATH];
+       char fullpath[MAX_OSPATH];
 
        search = FS_FindFile (filename, NULL, true);
        if(!search)
                return FS_FILETYPE_NONE;
 
-       if(search->pack)
+       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);
@@ -2474,6 +3071,11 @@ Look for a file in the filesystem only
 int FS_SysFileType (const char *path)
 {
 #if WIN32
+// Sajt - some older sdks are missing this define
+# ifndef INVALID_FILE_ATTRIBUTES
+#  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+# endif
+
        DWORD result = GetFileAttributes(path);
 
        if(result == INVALID_FILE_ATTRIBUTES)
@@ -2489,6 +3091,9 @@ int FS_SysFileType (const char *path)
        if (stat (path,&buf) == -1)
                return FS_FILETYPE_NONE;
 
+#ifndef S_ISDIR
+#define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
+#endif
        if(S_ISDIR(buf.st_mode))
                return FS_FILETYPE_DIRECTORY;
 
@@ -2556,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;
@@ -2596,7 +3201,6 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                else
                {
                        stringlist_t matchedSet, foundSet;
-                       int resultindex = 0;
                        const char *start = pattern;
 
                        stringlistinit(&matchedSet);
@@ -2631,23 +3235,24 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
                                        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), nextseparator - pattern + 1));
-                               // find the last /
-                               prevseparator = strrchr( subpattern, '/' ) + 1;
+                               strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
+                               // find the last '/' before the wildcard
+                               prevseparator = strrchr( subpattern, '/' );
                                if (!prevseparator)
-                               {
                                        prevseparator = subpattern;
-                               }
-                               // copy everything including the last '/'
-                               strlcpy(subpath, start, min(sizeof(subpath), (prevseparator - subpattern) - (start - pattern) + 1));
+                               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)));
 
-                               // prevseparator points to the one right before the wildcard and nextseparator to the one following it (or past the end of the string (at \0))
-                               // start to prevseparator can be opened now and added to the other resultset
+                               // 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 );                         
+                                       listdirectory( &foundSet, searchpath->filename, temp );
                                }
                                if( dirlistindex == 0 ) {
                                        break;
@@ -2665,7 +3270,7 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
 
                                start = nextseparator;
                        }
-                       
+
                        for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
                        {
                                const char *temp = matchedSet.strings[dirlistindex];
@@ -2815,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;
 }
@@ -2842,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;
@@ -2899,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;
+}