Boston, MA 02111-1307, USA
*/
-#include "quakedef.h"
-
#include <limits.h>
#include <fcntl.h>
# include <direct.h>
# include <io.h>
# include <shlobj.h>
+# include <sys/stat.h>
+# include <share.h>
#else
# include <pwd.h>
# include <sys/stat.h>
# include <unistd.h>
#endif
+#include "quakedef.h"
+
+#if TARGET_OS_IPHONE
+// include SDL for IPHONEOS code
+# include <SDL.h>
+#endif
+
+#include "thread.h"
+
#include "fs.h"
#include "wad.h"
// largefile support for Win32
#ifdef WIN32
+#undef lseek
# define lseek _lseeki64
#endif
-#if _MSC_VER >= 1400
// suppress deprecated warnings
-# include <sys/stat.h>
-# include <share.h>
+#if _MSC_VER >= 1400
# define read _read
# define write _write
# define close _close
# 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.
#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
=============================================================================
*/
-// 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
};
{
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;
} 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
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,
*/
mempool_t *fs_mempool;
+void *fs_mutex = NULL;
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)"};
/*
=============================================================================
*/
+#ifndef LINK_TO_ZLIB
// Functions exported from zlib
#if defined(WIN32) && defined(ZLIB_USES_WINAPI)
# define ZEXPORT WINAPI
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[] =
{
{"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);
{"SHGetFolderPathA", (void **) &qSHGetFolderPath},
{NULL, NULL}
};
+static const char* shfolderdllnames [] =
+{
+ "shfolder.dll", // IE 4, or Win NT and higher
+ NULL
+};
static dllhandle_t shfolder_dll = NULL;
+
+const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
+#define qREFKNOWNFOLDERID const GUID *
+#define qKF_FLAG_CREATE 0x8000
+#define qKF_FLAG_NO_ALIAS 0x1000
+static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
+static dllfunction_t shell32funcs[] =
+{
+ {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
+ {NULL, NULL}
+};
+static const char* shell32dllnames [] =
+{
+ "shell32.dll", // Vista and higher
+ NULL
+};
+static dllhandle_t shell32_dll = NULL;
+
+static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
+static void (WINAPI *qCoUninitialize)(void);
+static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
+static dllfunction_t ole32funcs[] =
+{
+ {"CoInitializeEx", (void **) &qCoInitializeEx},
+ {"CoUninitialize", (void **) &qCoUninitialize},
+ {"CoTaskMemFree", (void **) &qCoTaskMemFree},
+ {NULL, NULL}
+};
+static const char* ole32dllnames [] =
+{
+ "ole32.dll", // 2000 and higher
+ NULL
+};
+static dllhandle_t ole32_dll = NULL;
#endif
/*
Unload the Zlib DLL
====================
*/
-void PK3_CloseLibrary (void)
+static void PK3_CloseLibrary (void)
{
+#ifndef LINK_TO_ZLIB
Sys_UnloadLibrary (&zlib_dll);
+#endif
}
Try to load the Zlib DLL
====================
*/
-qboolean PK3_OpenLibrary (void)
+static 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",
// 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
+}
/*
====================
Extract the end of the central directory from a PK3 package
====================
*/
-qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
+static qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
{
fs_offset_t filesize, maxsize;
unsigned char *buffer, *ptr;
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);
+ if (
+ eocd->cdir_size < 0 || eocd->cdir_size > filesize ||
+ eocd->cdir_offset < 0 || eocd->cdir_offset >= filesize ||
+ eocd->cdir_offset + eocd->cdir_size > filesize
+ )
+ {
+ // Obviously invalid central directory.
+ return false;
+ }
+
return true;
}
Extract the file list from a PK3 file
====================
*/
-int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
+static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
{
unsigned char *central_dir, *ptr;
unsigned int ind;
// 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 (lseek (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
+ {
+ Mem_Free (central_dir);
+ return -1;
+ }
+ 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
if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
{
// Still enough bytes for the name?
- if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
+ if (namesize < 0 || remaining < namesize || namesize >= (int)sizeof (*pack->files))
{
Mem_Free (central_dir);
return -1;
flags = PACKFILE_FLAG_DEFLATED;
else
flags = 0;
- offset = BuffLittleLong (&ptr[42]);
- packsize = BuffLittleLong (&ptr[20]);
- realsize = BuffLittleLong (&ptr[24]);
+ offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
+ packsize = (unsigned int)BuffLittleLong (&ptr[20]);
+ realsize = (unsigned int)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);
}
}
Create a package entry associated with a PK3 file
====================
*/
-pack_t *FS_LoadPackPK3 (const char *packfile)
+static pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
{
- 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);
+ if(!silent)
+ Con_Printf ("%s is not a PK3 file\n", packfile);
close(packhandle);
return NULL;
}
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;
}
+static pack_t *FS_LoadPackPK3 (const char *packfile)
+{
+ int packhandle;
+ packhandle = FS_SysOpenFD (packfile, "rb", false);
+ if (packhandle < 0)
+ return NULL;
+ return FS_LoadPackPK3FromFD(packfile, packhandle, false);
+}
/*
Find where the true file data offset is
====================
*/
-qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
+static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
{
unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
fs_offset_t count;
return true;
// Load the local file description
- lseek (pack->handle, pfile->offset, SEEK_SET);
+ if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
+ {
+ Con_Printf ("Can't seek in package %s\n", pack->filename);
+ return false;
+ }
count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
{
}
+static void FS_mkdir (const char *path)
+{
+ if(COM_CheckParm("-readonly"))
+ return;
+
+#if WIN32
+ if (_mkdir (path) == -1)
+#else
+ if (mkdir (path, 0777) == -1)
+#endif
+ {
+ // No logging for this. The only caller is FS_CreatePath (which
+ // calls it in ways that will intentionally produce EEXIST),
+ // and its own callers always use the directory afterwards and
+ // thus will detect failure that way.
+ }
+}
+
+
/*
============
FS_CreatePath
-Only used for FS_Open.
+Only used for FS_OpenRealFile.
============
*/
void FS_CreatePath (char *path)
============
*/
-void FS_Path_f (void)
+static void FS_Path_f (void)
{
searchpath_t *s;
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);
}
/*
=================
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.
=================
*/
-pack_t *FS_LoadPackPAK (const char *packfile)
+/*! 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.
+ */
+static pack_t *FS_LoadPackPAK (const char *packfile)
{
dpackheader_t header;
int i, numpackfiles;
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
+ packhandle = FS_SysOpenFD(packfile, "rb", false);
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);
numpackfiles = header.dirlen / sizeof(dpackfile_t);
- if (numpackfiles > MAX_FILES_IN_PACK)
+ if (numpackfiles < 0 || numpackfiles > MAX_FILES_IN_PACK)
{
Con_Printf ("%s has %i files\n", packfile, numpackfiles);
close(packhandle);
}
pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
- pack->ignorecase = false; // PAK is case sensitive
+ pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
strlcpy (pack->filename, packfile, sizeof (pack->filename));
pack->handle = packhandle;
pack->numfiles = 0;
// parse the directory
for (i = 0;i < numpackfiles;i++)
{
- fs_offset_t offset = LittleLong (info[i].filepos);
- fs_offset_t size = LittleLong (info[i].filelen);
+ fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
+ fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
+
+ // Ensure a zero terminated file name (required by format).
+ info[i].name[sizeof(info[i].name) - 1] = 0;
FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
}
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
+====================
+*/
+static 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)
{
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 if(!strcasecmp(ext, "obb")) // android apk expansion
+ 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
if(!insertion_point)
{
search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
- search->pack = pak;
search->next = fs_searchpaths;
fs_searchpaths = search;
}
// 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;
}
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
/*
================
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;
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);
}
then loads and adds pak1.pak pak2.pak ...
================
*/
-void FS_AddGameDirectory (const char *dir)
+static void FS_AddGameDirectory (const char *dir)
{
int i;
stringlist_t list;
stringlistinit(&list);
listdirectory(&list, "", dir);
- stringlistsort(&list);
+ stringlistsort(&list, false);
// add any PAK package in the directory
for (i = 0;i < list.numstrings;i++)
{
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]), "obb") || !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);
}
}
FS_AddGameHierarchy
================
*/
-void FS_AddGameHierarchy (const char *dir)
+static 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;
-
+ char vabuf[1024];
// 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]);
+ FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
- if (*userdir)
- FS_AddGameDirectory(va("%s%s/", userdir, dir));
+ if (*fs_userdir)
+ FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
}
FS_ClearSearchPath
================
*/
-void FS_ClearSearchPath (void)
+static void FS_ClearSearchPath (void)
{
// unload all packs and directory information, close all pack files
// (if a qfile is still reading a pack it won't be harmed because it used
{
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;
+ }
+}
+
/*
================
{
int i;
qboolean fs_modified = false;
+ qboolean reset = false;
+ char gamedirbuf[MAX_INPUTLINE];
+ char vabuf[1024];
+ if (fs_searchpaths)
+ reset = true;
FS_ClearSearchPath();
+ // automatically activate gamemode for the gamedirs specified
+ if (reset)
+ COM_ChangeGameTypeForGameDirs();
+
// add the game-specific paths
// gamedirname1 (typically id1)
FS_AddGameHierarchy (gamedirname1);
// update the com_modname (used for server info)
- strlcpy(com_modname, gamedirname1, sizeof(com_modname));
+ if (gamedirname2 && gamedirname2[0])
+ strlcpy(com_modname, gamedirname2, sizeof(com_modname));
+ else
+ strlcpy(com_modname, gamedirname1, sizeof(com_modname));
// add the game-specific path, if any
// (only used for mission packs and the like, which should set fs_modified)
- if (gamedirname2)
+ if (gamedirname2 && gamedirname2[0])
{
fs_modified = true;
FS_AddGameHierarchy (gamedirname2);
// 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(vabuf, sizeof(vabuf), " %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
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));
+ unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
// look for the pop.lmp file and set registered to true if it is found
- if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
+ if (FS_FileExists("gfx/pop.lmp"))
+ Cvar_Set ("registered", "1");
+ switch(gamemode)
{
- if (fs_modified)
- Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+ case GAME_NORMAL:
+ case GAME_HIPNOTIC:
+ case GAME_ROGUE:
+ if (!registered.integer)
+ {
+ if (fs_modified)
+ Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+ else
+ Con_Print("Playing shareware version.\n");
+ }
else
- Con_Print("Playing shareware version.\n");
- }
- else
- {
- Cvar_Set ("registered", "1");
- if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
Con_Print("Playing registered version.\n");
+ break;
+ case GAME_STEELSTORM:
+ if (registered.integer)
+ Con_Print("Playing registered version.\n");
+ else
+ Con_Print("Playing shareware version.\n");
+ break;
+ default:
+ break;
}
// unload all wads so that future queries will return the new data
W_UnloadAll();
}
-void FS_Rescan_f(void)
+static void FS_Rescan_f(void)
{
FS_Rescan();
}
FS_ChangeGameDirs
================
*/
-extern void Host_SaveConfig (void);
-extern void Host_LoadConfig_f (void);
+extern qboolean vid_opened;
qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
{
int i;
+ const char *p;
if (fs_numgamedirs == numgamedirs)
{
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]);
// reinitialize filesystem to detect the new paks
FS_Rescan();
- // exec the new config
- Host_LoadConfig_f();
+ if (cls.demoplayback)
+ {
+ CL_Disconnect_f();
+ cls.demonum = 0;
+ }
// unload all sounds so they will be reloaded from the new files as needed
S_UnloadAllSounds_f();
- // reinitialize renderer (this reloads hud/console background/etc)
- R_Modules_Restart();
+ // close down the video subsystem, it will start up again when the config finishes...
+ VID_Stop();
+ vid_opened = false;
+
+ // restart the video subsystem after the config is executed
+ Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
return true;
}
FS_GameDir_f
================
*/
-void FS_GameDir_f (void)
+static void FS_GameDir_f (void)
{
int i;
int numgamedirs;
FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
}
+static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
+{
+ qboolean success;
+ qfile_t *f;
+ stringlist_t list;
+ fs_offset_t n;
+ char vabuf[1024];
+
+ stringlistinit(&list);
+ listdirectory(&list, gamedir, "");
+ success = list.numstrings > 0;
+ stringlistfreecontents(&list);
+
+ if(success)
+ {
+ f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
+ if(f)
+ {
+ n = FS_Read (f, buf, buflength - 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;
+ char buf[8192];
+ char vabuf[1024];
+
+ if (FS_CheckNastyPath(gamedir, true))
+ return NULL;
+
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
+ if(ret)
+ {
+ if(!*ret)
+ {
+ // get description from basedir
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
+ if(ret)
+ return ret;
+ return "";
+ }
+ return ret;
+ }
+
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
+ if(ret)
+ return ret;
+
+ return fs_checkgamedir_missing;
+}
+
+static void FS_ListGameDirs(void)
+{
+ stringlist_t list, list2;
+ int i;
+ const char *info;
+ char vabuf[1024];
+
+ 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(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
+ listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
+ stringlistsort(&list, false);
+
+ 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[fs_all_gamedirs_count].name));
+ strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
+ ++fs_all_gamedirs_count;
+ }
}
+/*
+#ifdef WIN32
+#pragma comment(lib, "shell32.lib")
+#include <ShlObj.h>
+#endif
+*/
/*
================
-FS_Init
+FS_Init_SelfPack
================
*/
-void FS_Init (void)
+void FS_Init_SelfPack (void)
{
- int i;
+ 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))
+ {
+ size_t sz = strlen(com_token) + 1; // shut up clang
+ if(i >= args_left)
+ break;
+ q = (char *)Mem_Alloc(fs_mempool, sz);
+ strlcpy(q, com_token, sz);
+ 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);
+ }
+ }
+}
-#ifdef WIN32
- const char* dllnames [] =
+static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
+{
+#if defined(__IPHONEOS__)
+ if (userdirmode == USERDIRMODE_HOME)
{
- "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
+ // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
+ // fs_userdir stores configurations to the Documents folder of the app
+ strlcpy(userdir, "../Documents/", MAX_OSPATH);
+ return 1;
+ }
+ return -1;
+
+#elif defined(WIN32)
+ char *homedir;
+#if _MSC_VER >= 1400
+ size_t homedirlen;
#endif
+ TCHAR mydocsdir[MAX_PATH + 1];
+ wchar_t *savedgamesdirw;
+ char savedgamesdir[MAX_OSPATH];
+ int fd;
+ char vabuf[1024];
- fs_mempool = Mem_AllocPool("file management", 0, NULL);
+ userdir[0] = 0;
+ switch(userdirmode)
+ {
+ default:
+ return -1;
+ case USERDIRMODE_NOHOME:
+ strlcpy(userdir, fs_basedir, userdirsize);
+ break;
+ case USERDIRMODE_MYGAMES:
+ if (!shfolder_dll)
+ Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
+ mydocsdir[0] = 0;
+ if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
+ {
+ dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
+ break;
+ }
+#if _MSC_VER >= 1400
+ _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
+ if(homedir)
+ {
+ dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
+ free(homedir);
+ break;
+ }
+#else
+ homedir = getenv("USERPROFILE");
+ if(homedir)
+ {
+ dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
+ break;
+ }
+#endif
+ return -1;
+ case USERDIRMODE_SAVEDGAMES:
+ if (!shell32_dll)
+ Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
+ if (!ole32_dll)
+ Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
+ if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
+ {
+ savedgamesdir[0] = 0;
+ qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+/*
+#ifdef __cplusplus
+ if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+#else
+ if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+#endif
+*/
+ if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+ {
+ memset(savedgamesdir, 0, sizeof(savedgamesdir));
+#if _MSC_VER >= 1400
+ wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
+#else
+ wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
+#endif
+ qCoTaskMemFree(savedgamesdirw);
+ }
+ qCoUninitialize();
+ if (savedgamesdir[0])
+ {
+ dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
+ break;
+ }
+ }
+ return -1;
+ }
+#else
+ int fd;
+ char *homedir;
+ char vabuf[1024];
+ userdir[0] = 0;
+ switch(userdirmode)
+ {
+ default:
+ return -1;
+ case USERDIRMODE_NOHOME:
+ strlcpy(userdir, fs_basedir, userdirsize);
+ break;
+ case USERDIRMODE_HOME:
+ homedir = getenv("HOME");
+ if(homedir)
+ {
+ dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
+ break;
+ }
+ return -1;
+ case USERDIRMODE_SAVEDGAMES:
+ homedir = getenv("HOME");
+ if(homedir)
+ {
+#ifdef MACOSX
+ dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
+#else
+ // the XDG say some files would need to go in:
+ // XDG_CONFIG_HOME (or ~/.config/%s/)
+ // XDG_DATA_HOME (or ~/.local/share/%s/)
+ // XDG_CACHE_HOME (or ~/.cache/%s/)
+ // and also search the following global locations if defined:
+ // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
+ // XDG_DATA_DIRS (normally /usr/share/%s/)
+ // this would be too complicated...
+ return -1;
+#endif
+ break;
+ }
+ return -1;
+ }
+#endif
- strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
-// If the base directory is explicitly defined by the compilation process
-#ifdef DP_FS_BASEDIR
- strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
-#else
- strlcpy(fs_basedir, "", sizeof(fs_basedir));
+#if !defined(__IPHONEOS__)
-#ifdef MACOSX
- // FIXME: is there a better way to find the directory outside the .app?
- if (strstr(com_argv[0], ".app/"))
- {
- char *split;
+#ifdef WIN32
+ // historical behavior...
+ if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
+ return 0; // don't bother checking if the basedir folder is writable, it's annoying... unless it is Quake on Windows where NOHOME is the default preferred and we have to check for an error case
+#endif
- split = strstr(com_argv[0], ".app/");
- while (split > com_argv[0] && *split != '/')
- split--;
- strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
- fs_basedir[split - com_argv[0]] = 0;
- }
+ // see if we can write to this path (note: won't create path)
+#ifdef WIN32
+ // no access() here, we must try to open the file for appending
+ fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
+ if(fd >= 0)
+ close(fd);
+#else
+ // on Unix, we don't need to ACTUALLY attempt to open the file
+ if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
+ fd = 1;
+ else
+ fd = -1;
#endif
+ if(fd >= 0)
+ {
+ return 1; // good choice - the path exists and is writable
+ }
+ else
+ {
+ if (userdirmode == USERDIRMODE_NOHOME)
+ return -1; // path usually already exists, we lack permissions
+ else
+ return 0; // probably good - failed to write but maybe we need to create path
+ }
#endif
+}
- PK3_OpenLibrary ();
+/*
+================
+FS_Init
+================
+*/
+void FS_Init (void)
+{
+ const char *p;
+ int i;
+
+ *fs_basedir = 0;
+ *fs_userdir = 0;
+ *fs_gamedir = 0;
// -basedir <path>
// Overrides the system supplied base directory (under GAMENAME)
if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
fs_basedir[i-1] = 0;
}
+ else
+ {
+// If the base directory is explicitly defined by the compilation process
+#ifdef DP_FS_BASEDIR
+ strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
+#elif defined(__ANDROID__)
+ dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
+#elif defined(MACOSX)
+ // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
+ if (strstr(com_argv[0], ".app/"))
+ {
+ char *split;
+ strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
+ split = strstr(fs_basedir, ".app/");
+ if (split)
+ {
+ struct stat statresult;
+ char vabuf[1024];
+ // truncate to just after the .app/
+ split[5] = 0;
+ // see if gamedir exists in Resources
+ if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
+ {
+ // found gamedir inside Resources, use it
+ strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
+ }
+ else
+ {
+ // no gamedir found in Resources, gamedir is probably
+ // outside the .app, remove .app part of path
+ while (split > fs_basedir && *split != '/')
+ split--;
+ *split = 0;
+ }
+ }
+ }
+#endif
+ }
+
+ // make sure the appending of a path separator won't create an unterminated string
+ memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
+ // add a path separator to the end of the basedir if it lacks one
+ if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
+ strlcat(fs_basedir, "/", sizeof(fs_basedir));
+
+ // 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; // user wants roaming installation, no userdir
+ else
+ {
+ int dirmode;
+ int highestuserdirmode = USERDIRMODE_COUNT - 1;
+ int preferreduserdirmode = USERDIRMODE_COUNT - 1;
+ int userdirstatus[USERDIRMODE_COUNT];
+#ifdef WIN32
+ // historical behavior...
+ if (!strcmp(gamedirname1, "id1"))
+ preferreduserdirmode = USERDIRMODE_NOHOME;
+#endif
+ // check what limitations the user wants to impose
+ if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
+ if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
+ if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
+ // gather the status of the possible userdirs
+ for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
+ {
+ userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
+ if (userdirstatus[dirmode] == 1)
+ Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
+ else if (userdirstatus[dirmode] == 0)
+ Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
+ else
+ Con_DPrintf("userdir %i (not applicable)\n", dirmode);
+ }
+ // some games may prefer writing to basedir, but if write fails we
+ // have to search for a real userdir...
+ if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
+ preferreduserdirmode = highestuserdirmode;
+ // check for an existing userdir and continue using it if possible...
+ for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
+ if (userdirstatus[dirmode] == 1)
+ break;
+ // if no existing userdir found, make a new one...
+ if (dirmode == 0 && preferreduserdirmode > 0)
+ for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
+ if (userdirstatus[dirmode] >= 0)
+ break;
+ // and finally, we picked one...
+ FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
+ Con_DPrintf("userdir %i is the winner\n", dirmode);
+ }
- // add a path separator to the end of the basedir if it lacks one
- if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
- strlcat(fs_basedir, "/", sizeof(fs_basedir));
+ // if userdir equal to basedir, clear it to avoid confusion later
+ if (!strcmp(fs_basedir, fs_userdir))
+ fs_userdir[0] = 0;
+
+ FS_ListGameDirs();
- if (!FS_CheckGameDir(gamedirname1))
+ 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
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]));
// generate the searchpath
FS_Rescan();
+
+ if (Thread_HasThreads())
+ fs_mutex = Thread_CreateMutex();
}
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");
}
/*
// by the OS anyway)
FS_ClearSearchPath();
Mem_FreePool (&fs_mempool);
+ PK3_CloseLibrary ();
#ifdef WIN32
Sys_UnloadLibrary (&shfolder_dll);
+ Sys_UnloadLibrary (&shell32_dll);
+ Sys_UnloadLibrary (&ole32_dll);
#endif
-}
-/*
-====================
-FS_SysOpen
+ if (fs_mutex)
+ Thread_DestroyMutex(fs_mutex);
+}
-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 = -1;
int mod, opt;
unsigned int ind;
+ qboolean dolock = false;
// Parse the mode string
switch (mode[0])
break;
default:
Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
- return NULL;
+ return -1;
}
for (ind = 1; mode[ind] != '\0'; ind++)
{
case 'b':
opt |= O_BINARY;
break;
+ case 'l':
+ dolock = true;
+ break;
default:
Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
filepath, mode, mode[ind]);
if (nonblocking)
opt |= O_NONBLOCK;
- file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
- memset (file, 0, sizeof (*file));
- file->ungetc = EOF;
+ if(COM_CheckParm("-readonly") && mod != O_RDONLY)
+ return -1;
-#if _MSC_VER >= 1400
- _sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#ifdef WIN32
+# if _MSC_VER >= 1400
+ _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
+# else
+ handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
+# endif
#else
- file->handle = open (filepath, mod | opt, 0666);
+ handle = open (filepath, mod | opt, 0666);
+ if(handle >= 0 && dolock)
+ {
+ struct flock l;
+ l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
+ l.l_whence = SEEK_SET;
+ l.l_start = 0;
+ l.l_len = 0;
+ if(fcntl(handle, F_SETLK, &l) == -1)
+ {
+ close(handle);
+ handle = -1;
+ }
+ }
#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));
+ 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);
Open a packed file using its package file descriptor
===========
*/
-qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
+static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
{
packfile_t *pfile;
int dup_handle;
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))
{
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
if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
{
- Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
- pfile->name, pack->filename, (int) pfile->offset);
+ Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
+ pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
return NULL;
}
if (path[0] == '/')
return 2; // attempt to go outside the game directory
- // all: don't allow . characters before the last slash (it should only be used in filenames, not path elements), this catches all imaginable cases of ./, ../, .../, etc
- if (strchr(path, '.'))
- {
- if (isgamedir)
- {
- // gamedir is entirely path elements, so simply forbid . entirely
- return 2;
- }
- if (strchr(path, '.') < strrchr(path, '/'))
- return 2; // possible attempt to go outside the game directory
- }
+ // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
+ if (strstr(path, "./"))
+ return 2; // possible attempt to go outside the game directory
// all: forbid trailing slash on gamedir
if (isgamedir && path[strlen(path)-1] == '/')
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;
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)
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;
}
}
- 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;
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)
+static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
{
searchpath_t *search;
int pack_ind;
// 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);
}
/*
====================
-FS_Open
+FS_OpenRealFile
-Open a file. The syntax is the same as fopen
+Open a file in the userpath. The syntax is the same as fopen
+Used for savegame scanning in menu, and all file writing.
====================
*/
-qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
+qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
{
+ char real_path [MAX_OSPATH];
+
if (FS_CheckNastyPath(filepath, false))
{
- Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
+ Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
return NULL;
}
- // If the file is opened in "write", "append", or "read/write" mode
+ dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
+
+ // If the file is opened in "write", "append", or "read/write" mode,
+ // create directories up to the file.
if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
- {
- char real_path [MAX_OSPATH];
+ FS_CreatePath (real_path);
+ return FS_SysOpen (real_path, mode, false);
+}
- // Open the file on disk directly
- dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
- // Create directories up to the file
- FS_CreatePath (real_path);
+/*
+====================
+FS_OpenVirtualFile
- return FS_SysOpen (real_path, mode, nonblocking);
+Open a file. The syntax is the same as fopen
+====================
+*/
+qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
+{
+ qfile_t *result = NULL;
+ 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);
+
+ if (fs_mutex) Thread_LockMutex(fs_mutex);
+ result = FS_OpenReadFile (filepath, quiet, false, 16);
+ if (fs_mutex) Thread_UnlockMutex(fs_mutex);
+ return result;
}
+/*
+====================
+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
*/
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)
+ {
+ if (remove(file->filename) == -1)
+ {
+ // No need to report this. If removing a just
+ // written file failed, this most likely means
+ // someone else deleted it first - which we
+ // like.
+ }
+ }
+
+ Mem_Free((void *) file->filename);
+ }
+
if (file->ztk)
{
qz_inflateEnd (&file->ztk->zstream);
return 0;
}
+void FS_RemoveOnClose(qfile_t* file)
+{
+ file->flags |= QFILE_FLAG_REMOVE;
+}
/*
====================
*/
fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
{
- fs_offset_t result;
+ fs_offset_t written = 0;
// If necessary, seek to the exact file position we're supposed to be
if (file->buff_ind != file->buff_len)
- lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
+ {
+ if (lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
+ {
+ Con_Printf("WARNING: could not seek in %s.\n");
+ }
+ }
// Purge cached data
FS_Purge (file);
// Write the buffer and update the position
- result = write (file->handle, data, (fs_offset_t)datasize);
+ // LordHavoc: to hush a warning about passing size_t to an unsigned int parameter on Win64 we do this as multiple writes if the size would be too big for an integer (we never write that big in one go, but it's a theory)
+ while (written < (fs_offset_t)datasize)
+ {
+ // figure out how much to write in one chunk
+ fs_offset_t maxchunk = 1<<30; // 1 GiB
+ int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
+ int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
+ // if at least some was written, add it to our accumulator
+ if (result > 0)
+ written += result;
+ // if the result is not what we expected, consider the write to be incomplete
+ if (result != chunk)
+ break;
+ }
file->position = lseek (file->handle, 0, SEEK_CUR);
if (file->real_length < file->position)
file->real_length = file->position;
- if (result < 0)
- return 0;
-
- return result;
+ // note that this will never be less than 0 even if the write failed
+ return written;
}
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)
{
{
if (count > (fs_offset_t)buffersize)
count = (fs_offset_t)buffersize;
- lseek (file->handle, file->offset + file->position, SEEK_SET);
+ if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
+ {
+ // Seek failed. When reading from a pipe, and
+ // the caller never called FS_Seek, this still
+ // works fine. So no reporting this error.
+ }
nb = read (file->handle, &((unsigned char*)buffer)[done], count);
if (nb > 0)
{
{
if (count > (fs_offset_t)sizeof (file->buff))
count = (fs_offset_t)sizeof (file->buff);
- lseek (file->handle, file->offset + file->position, SEEK_SET);
+ if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
+ {
+ // Seek failed. When reading from a pipe, and
+ // the caller never called FS_Seek, this still
+ // works fine. So no reporting this error.
+ }
nb = read (file->handle, file->buff, count);
if (nb > 0)
{
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)
{
ztk->in_len = 0;
ztk->in_position = 0;
file->position = 0;
- lseek (file->handle, file->offset, SEEK_SET);
+ if (lseek (file->handle, file->offset, SEEK_SET) == -1)
+ Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
// Reset the Zlib stream
ztk->zstream.next_in = ztk->input;
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);
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);
+}
+
/*
=============================================================================
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);
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;
return FS_SysFileType (path) != FS_FILETYPE_NONE;
}
-void FS_mkdir (const char *path)
-{
-#if WIN32
- _mkdir (path);
-#else
- mkdir (path, 0777);
-#endif
-}
-
/*
===========
FS_Search
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;
if (resultlist.numstrings)
{
- stringlistsort(&resultlist);
+ stringlistsort(&resultlist, true);
numfiles = resultlist.numstrings;
numchars = 0;
for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
}
extern int con_linewidth;
-int FS_ListDirectory(const char *pattern, int oneperline)
+static int FS_ListDirectory(const char *pattern, int oneperline)
{
int numfiles;
int numcolumns;
static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
{
const char *pattern;
- if (Cmd_Argc() > 3)
+ if (Cmd_Argc() >= 3)
{
Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
return;
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 if(sp)
+ return "";
else
return 0;
}
// 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;
int diff;
middle = (left + right) / 2;
- diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
+ diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
// Found it
if (!diff)
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 = (unsigned int)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 = (unsigned int)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 = (unsigned int)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;
+}
projects / xonotic / darkplaces.git / blobdiff