X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=fs.c;h=a5281f584be580bb33e8073bfdc906094730c974;hp=119499f9b445d62c5723aac1a8bca8590863bd4a;hb=05b2bea177017a0e9f6a03609e9f9521e2e2941f;hpb=2712912e8219e96a09a172b87ec2f4f6cff5ad97

diff --git a/fs.c b/fs.c
index 119499f9..a5281f58 100644
--- 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"
 
@@ -66,7 +66,7 @@
 # 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.
@@ -106,6 +106,19 @@ 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
@@ -141,67 +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
+/// 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.
 
-	// for data files
-	const unsigned char *data;
+	const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
 };
 
 
@@ -213,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;
 
 
@@ -237,12 +255,14 @@ 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
+/// file is a symbolic link
 #define PACKFILE_FLAG_SYMLINK (1 << 2)
 
 typedef struct packfile_s
@@ -250,8 +270,8 @@ 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
@@ -259,13 +279,14 @@ 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
@@ -285,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,
@@ -303,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)"};
 
 
 /*
@@ -325,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
@@ -339,12 +370,14 @@ 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[] =
@@ -359,8 +392,9 @@ static dllfunction_t zlibfuncs[] =
 	{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);
@@ -381,7 +415,9 @@ Unload the Zlib DLL
 */
 void PK3_CloseLibrary (void)
 {
+#ifndef LINK_TO_ZLIB
 	Sys_UnloadLibrary (&zlib_dll);
+#endif
 }
 
 
@@ -394,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",
@@ -420,6 +457,7 @@ qboolean PK3_OpenLibrary (void)
 
 	// Load the DLL
 	return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
+#endif
 }
 
 /*
@@ -431,8 +469,12 @@ 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
 }
 
 /*
@@ -491,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);
 
@@ -514,7 +558,7 @@ 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);
-	if(read (pack->handle, central_dir, eocd->cdir_size) != (ssize_t) eocd->cdir_size)
+	if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
 	{
 		Mem_Free (central_dir);
 		return -1;
@@ -584,7 +628,7 @@ 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]);
 
@@ -625,21 +669,12 @@ 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)
 {
-	int packhandle;
 	pk3_endOfCentralDir_t eocd;
 	pack_t *pack;
 	int real_nb_files;
 
-#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;
-
 	if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
 	{
 		Con_Printf ("%s is not a PK3 file\n", packfile);
@@ -683,9 +718,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);
+}
 
 
 /*
@@ -822,7 +869,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);
 	}
@@ -832,13 +884,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;
@@ -913,29 +964,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
 ================
 */
+/*! 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)
 	{
@@ -950,16 +1024,19 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 	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)
 		{
@@ -983,7 +1060,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 			if(!insertion_point)
 			{
 				search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-				search->pack = pak;
 				search->next = fs_searchpaths;
 				fs_searchpaths = search;
 			}
@@ -991,7 +1067,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 			// 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;
 			}
@@ -999,10 +1074,24 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 		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
@@ -1016,20 +1105,20 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 /*
 ================
 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;
 
@@ -1082,7 +1171,7 @@ void FS_AddGameDirectory (const char *dir)
 	// 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], list.strings[i] + strlen(dir), NULL, false);
 		}
@@ -1106,86 +1195,11 @@ FS_AddGameHierarchy
 */
 void FS_AddGameHierarchy (const char *dir)
 {
-	int i;
-	char userdir[MAX_QPATH];
-#ifdef WIN32
-	TCHAR mydocsdir[MAX_PATH + 1];
-#if _MSC_VER >= 1400
-	size_t homedirlen;
-#endif
-#endif
-	char *homedir;
-
 	// Add the common game directory
 	FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
 
-	*userdir = 0;
-
-	// Add the personal game directory
-#ifdef WIN32
-	if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
-	{
-		dpsnprintf(userdir, sizeof(userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
-		Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", userdir);
-	}
-	else
-	{
-		// use the environment
-#if _MSC_VER >= 1400
-		_dupenv_s (&homedir, &homedirlen, "USERPROFILE");
-#else
-		homedir = getenv("USERPROFILE");
-#endif
-
-		if(homedir)
-		{
-			dpsnprintf(userdir, sizeof(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", userdir);
-		}
-		else
-			*userdir = 0; // just to make sure it hasn't been written to by SHGetFolderPath returning failure
-	}
-
-	if(!*userdir)
-		Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
-#else
-	homedir = getenv ("HOME");
-	if(homedir)
-		dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
-
-	if(!*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, dir), 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, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
-#endif
-		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));
 }
 
 
@@ -1248,19 +1262,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;
+	}
+}
+
 
 /*
 ================
@@ -1271,6 +1300,7 @@ void FS_Rescan (void)
 {
 	int i;
 	qboolean fs_modified = false;
+	char gamedirbuf[MAX_INPUTLINE];
 
 	FS_ClearSearchPath();
 
@@ -1292,13 +1322,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
@@ -1306,24 +1345,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
@@ -1345,6 +1400,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)
 	{
@@ -1365,17 +1421,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]);
@@ -1447,23 +1500,173 @@ void FS_GameDir_f (void)
 	FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
 }
 
+static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking);
+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);
+		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);
+		}
+	}
+}
 
 /*
 ================
@@ -1472,7 +1675,15 @@ 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;
 
 #ifdef WIN32
 	const char* dllnames [] =
@@ -1484,7 +1695,70 @@ void FS_Init (void)
 	// don't care for the result; if it fails, %USERPROFILE% will be used instead
 #endif
 
-	fs_mempool = Mem_AllocPool("file management", 0, NULL);
+	// 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));
 
@@ -1492,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?
@@ -1509,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)
@@ -1527,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))
+	FS_ListGameDirs();
+
+	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 && !FS_CheckGameDir(gamedirname2))
-		Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
+	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
@@ -1543,9 +1822,10 @@ 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]))
+			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]));
@@ -1561,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");
 }
 
 /*
@@ -1587,16 +1869,9 @@ void FS_Shutdown (void)
 #endif
 }
 
-/*
-====================
-FS_SysOpen
-
-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;
 
@@ -1617,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++)
 	{
@@ -1638,25 +1913,40 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean non
 	if (nonblocking)
 		opt |= O_NONBLOCK;
 
-	file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
-	memset (file, 0, sizeof (*file));
-	file->ungetc = EOF;
-
 #if _MSC_VER >= 1400
-	_sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+	_sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
 #else
-	file->handle = open (filepath, mod | opt, 0666);
+	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
+====================
+*/
+static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
+{
+	qfile_t* file;
+
+	file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
+	file->ungetc = EOF;
+	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);
@@ -1685,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))
 	{
@@ -1693,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
@@ -1845,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;
@@ -1869,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)
@@ -1899,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;
@@ -1909,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;
@@ -1939,6 +2231,7 @@ 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);
@@ -2049,7 +2342,7 @@ qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet
 		return NULL;
 	}
 
-	dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
+	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.
@@ -2115,6 +2408,14 @@ int FS_Close (qfile_t* file)
 	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);
@@ -2125,6 +2426,10 @@ int FS_Close (qfile_t* file)
 	return 0;
 }
 
+void FS_RemoveOnClose(qfile_t* file)
+{
+	file->flags |= QFILE_FLAG_REMOVE;
+}
 
 /*
 ====================
@@ -2628,9 +2933,11 @@ 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_OpenRealFile(filename, "wb", false);
 	if (!file)
@@ -2639,12 +2946,21 @@ qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
 		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);
+}
+
 
 /*
 =============================================================================
@@ -2718,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);
@@ -2775,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;
 
@@ -2842,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;
@@ -3101,6 +3420,34 @@ 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;
@@ -3128,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;
@@ -3191,6 +3539,12 @@ unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflat
 	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;
@@ -3208,7 +3562,7 @@ unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflat
 	strm.next_in = (unsigned char*)data;
 	strm.avail_in = size;
 
-	tmp = Mem_Alloc(tempmempool, size);
+	tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
 	if(!tmp)
 	{
 		Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
@@ -3241,7 +3595,7 @@ unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflat
 		return NULL;
 	}
 
-	out = Mem_Alloc(mempool, strm.total_out);
+	out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
 	if(!out)
 	{
 		Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
@@ -3266,7 +3620,7 @@ static void AssertBufsize(sizebuf_t *buf, int length)
 		unsigned char *olddata;
 		olddata = buf->data;
 		buf->maxsize += length;
-		buf->data = Mem_Alloc(tempmempool, buf->maxsize);
+		buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
 		if(olddata)
 		{
 			memcpy(buf->data, olddata, oldsize);
@@ -3284,8 +3638,14 @@ unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflat
 	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 = Mem_Alloc(tempmempool, sizeof(tmp));
+	outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
 	outbuf.maxsize = sizeof(tmp);
 
 	memset(&strm, 0, sizeof(strm));
@@ -3347,7 +3707,7 @@ unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflat
 
 	qz_inflateEnd(&strm);
 
-	out = Mem_Alloc(mempool, outbuf.cursize);
+	out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
 	if(!out)
 	{
 		Con_Printf("FS_Inflate: not enough memory in target mempool!\n");