blendo/quadrilateralcowboy
0
0
Fork 0
mirror of https://github.com/blendogames/quadrilateralcowboy.git synced 2024-11-10 06:41:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
quadrilateralcowboy/framework/FileSystem.cpp
Ethan Lee 69420a703a Port Linux/macOS to 64-bit, using new CMake build system. 
Huge shoutout to dhewm3 and RBDOOM-3-BFG for doing 99% of this work before us!
2020-10-22 13:16:42 -04:00

4273 lines
No EOL
122 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "Unzip.h"
#ifdef WIN32
#include <io.h> // for _read
#else
#if !__MACH__ && __MWERKS__
#include <types.h>
#include <stat.h>
#else
#include <sys/types.h>
#include <sys/stat.h>
#endif
#include <unistd.h>
#endif
#if ID_ENABLE_CURL
#include "../curl/include/curl/curl.h"
#endif
/*
=============================================================================
DOOM FILESYSTEM
All of Doom's data access is through a hierarchical file system, but the contents of
the file system can be transparently merged from several sources.
A "relativePath" is a reference to game file data, which must include a terminating zero.
"..", "\\", and ":" are explicitly illegal in qpaths to prevent any references
outside the Doom directory system.
The "base path" is the path to the directory holding all the game directories and
usually the executable. It defaults to the current directory, but can be overridden
with "+set fs_basepath c:\doom" on the command line. The base path cannot be modified
at all after startup.
The "save path" is the path to the directory where game files will be saved. It defaults
to the base path, but can be overridden with a "+set fs_savepath c:\doom" on the
command line. Any files that are created during the game (demos, screenshots, etc.) will
be created reletive to the save path.
The "cd path" is the path to an alternate hierarchy that will be searched if a file
is not located in the base path. A user can do a partial install that copies some
data to a base path created on their hard drive and leave the rest on the cd. It defaults
to the current directory, but it can be overridden with "+set fs_cdpath g:\doom" on the
command line.
The "dev path" is the path to an alternate hierarchy where the editors and tools used
during development (Radiant, AF editor, dmap, runAAS) will write files to. It defaults to
the cd path, but can be overridden with a "+set fs_devpath c:\doom" on the command line.
If a user runs the game directly from a CD, the base path would be on the CD. This
should still function correctly, but all file writes will fail (harmlessly).
The "base game" is the directory under the paths where data comes from by default, and
can be either "base" or "demo".
The "current game" may be the same as the base game, or it may be the name of another
directory under the paths that should be searched for files before looking in the base
game. The game directory is set with "+set fs_game myaddon" on the command line. This is
the basis for addons.
No other directories outside of the base game and current game will ever be referenced by
filesystem functions.
To save disk space and speed up file loading, directory trees can be collapsed into zip
files. The files use a ".pk4" extension to prevent users from unzipping them accidentally,
but otherwise they are simply normal zip files. A game directory can have multiple zip
files of the form "pak0.pk4", "pak1.pk4", etc. Zip files are searched in decending order
from the highest number to the lowest, and will always take precedence over the filesystem.
This allows a pk4 distributed as a patch to override all existing data.
Because we will have updated executables freely available online, there is no point to
trying to restrict demo / oem versions of the game with code changes. Demo / oem versions
should be exactly the same executables as release versions, but with different data that
automatically restricts where game media can come from to prevent add-ons from working.
After the paths are initialized, Doom will look for the product.txt file. If not found
and verified, the game will run in restricted mode. In restricted mode, only files
contained in demo/pak0.pk4 will be available for loading, and only if the zip header is
verified to not have been modified. A single exception is made for DoomConfig.cfg. Files
can still be written out in restricted mode, so screenshots and demos are allowed.
Restricted mode can be tested by setting "+set fs_restrict 1" on the command line, even
if there is a valid product.txt under the basepath or cdpath.
If the "fs_copyfiles" cvar is set to 1, then every time a file is sourced from the cd
path, it will be copied over to the save path. This is a development aid to help build
test releases and to copy working sets of files.
If the "fs_copyfiles" cvar is set to 2, any file found in fs_cdpath that is newer than
it's fs_savepath version will be copied to fs_savepath (in addition to the fs_copyfiles 1
behaviour).
If the "fs_copyfiles" cvar is set to 3, files from both basepath and cdpath will be copied
over to the save path. This is useful when copying working sets of files mainly from base
path with an additional cd path (which can be a slower network drive for instance).
If the "fs_copyfiles" cvar is set to 4, files that exist in the cd path but NOT the base path
will be copied to the save path
NOTE: fs_copyfiles and case sensitivity. On fs_caseSensitiveOS 0 filesystems ( win32 ), the
copied files may change casing when copied over.
The relative path "sound/newstuff/test.wav" would be searched for in the following places:
for save path, dev path, base path, cd path:
for current game, base game:
search directory
search zip files
downloaded files, to be written to save path + current game's directory
The filesystem can be safely shutdown and reinitialized with different
basedir / cddir / game combinations, but all other subsystems that rely on it
(sound, video) must also be forced to restart.
"fs_caseSensitiveOS":
This cvar is set on operating systems that use case sensitive filesystems (Linux and OSX)
It is a common situation to have the media reference filenames, whereas the file on disc
only matches in a case-insensitive way. When "fs_caseSensitiveOS" is set, the filesystem
will always do a case insensitive search.
IMPORTANT: This only applies to files, and not to directories. There is no case-insensitive
matching of directories. All directory names should be lowercase, when "com_developer" is 1,
the filesystem will warn when it catches bad directory situations (regardless of the
"fs_caseSensitiveOS" setting)
When bad casing in directories happen and "fs_caseSensitiveOS" is set, BuildOSPath will
attempt to correct the situation by forcing the path to lowercase. This assumes the media
is stored all lowercase.
"additional mod path search":
fs_game_base can be used to set an additional search path
in search order, fs_game, fs_game_base, BASEGAME
for instance to base a mod of D3 + D3XP assets, fs_game mymod, fs_game_base d3xp
=============================================================================
*/
idCVar com_developer( "com_developer", "0", CVAR_INTEGER|CVAR_SYSTEM|CVAR_NOCHEAT, "developer mode" );
// define to fix special-cases for GetPackStatus so that files that shipped in
// the wrong place for Doom 3 don't break pure servers.
#define DOOM3_PURE_SPECIAL_CASES
typedef bool (*pureExclusionFunc_t)( const struct pureExclusion_s &excl, int l, const idStr &name );
typedef struct pureExclusion_s {
int nameLen;
int extLen;
const char * name;
const char * ext;
pureExclusionFunc_t func;
} pureExclusion_t;
bool excludeExtension( const pureExclusion_t &excl, int l, const idStr &name ) {
if ( l > excl.extLen && !idStr::Icmp( name.c_str() + l - excl.extLen, excl.ext ) ) {
return true;
}
return false;
}
bool excludePathPrefixAndExtension( const pureExclusion_t &excl, int l, const idStr &name ) {
if ( l > excl.nameLen && !idStr::Icmp( name.c_str() + l - excl.extLen, excl.ext ) && !name.IcmpPrefixPath( excl.name ) ) {
return true;
}
return false;
}
bool excludeFullName( const pureExclusion_t &excl, int l, const idStr &name ) {
if ( l == excl.nameLen && !name.Icmp( excl.name ) ) {
return true;
}
return false;
}
static pureExclusion_t pureExclusions[] = {
{ 0, 0, NULL, "/", excludeExtension },
{ 0, 0, NULL, "\\", excludeExtension },
{ 0, 0, NULL, ".pda", excludeExtension },
{ 0, 0, NULL, ".gui", excludeExtension },
{ 0, 0, NULL, ".pd", excludeExtension },
{ 0, 0, NULL, ".lang", excludeExtension },
{ 0, 0, "sound/VO", ".ogg", excludePathPrefixAndExtension },
{ 0, 0, "sound/VO", ".wav", excludePathPrefixAndExtension },
#if defined DOOM3_PURE_SPECIAL_CASES
// add any special-case files or paths for pure servers here
{ 0, 0, "sound/ed/marscity/vo_intro_cutscene.ogg", NULL, excludeFullName },
{ 0, 0, "sound/weapons/soulcube/energize_01.ogg", NULL, excludeFullName },
{ 0, 0, "sound/xian/creepy/vocal_fx", ".ogg", excludePathPrefixAndExtension },
{ 0, 0, "sound/xian/creepy/vocal_fx", ".wav", excludePathPrefixAndExtension },
{ 0, 0, "sound/feedback", ".ogg", excludePathPrefixAndExtension },
{ 0, 0, "sound/feedback", ".wav", excludePathPrefixAndExtension },
{ 0, 0, "guis/assets/mainmenu/chnote.tga", NULL, excludeFullName },
{ 0, 0, "sound/levels/alphalabs2/uac_better_place.ogg", NULL, excludeFullName },
{ 0, 0, "textures/bigchars.tga", NULL, excludeFullName },
{ 0, 0, "dds/textures/bigchars.dds", NULL, excludeFullName },
{ 0, 0, "fonts", ".tga", excludePathPrefixAndExtension },
{ 0, 0, "dds/fonts", ".dds", excludePathPrefixAndExtension },
{ 0, 0, "default.cfg", NULL, excludeFullName },
// russian zpak001.pk4
{ 0, 0, "fonts", ".dat", excludePathPrefixAndExtension },
{ 0, 0, "guis/temp.guied", NULL, excludeFullName },
#endif
{ 0, 0, NULL, NULL, NULL }
};
// ensures that lengths for pure exclusions are correct
class idInitExclusions {
public:
idInitExclusions() {
for ( int i = 0; pureExclusions[i].func != NULL; i++ ) {
if ( pureExclusions[i].name ) {
pureExclusions[i].nameLen = idStr::Length( pureExclusions[i].name );
}
if ( pureExclusions[i].ext ) {
pureExclusions[i].extLen = idStr::Length( pureExclusions[i].ext );
}
}
}
};
static idInitExclusions initExclusions;
#define MAX_ZIPPED_FILE_NAME 2048
#define FILE_HASH_SIZE 1024
typedef struct fileInPack_s {
idStr name; // name of the file
unsigned long pos; // file info position in zip
struct fileInPack_s * next; // next file in the hash
} fileInPack_t;
typedef enum {
BINARY_UNKNOWN = 0,
BINARY_YES,
BINARY_NO
} binaryStatus_t;
typedef enum {
PURE_UNKNOWN = 0, // need to run the pak through GetPackStatus
PURE_NEUTRAL, // neutral regarding pureness. gets in the pure list if referenced
PURE_ALWAYS, // always referenced - for pak* named files, unless NEVER
PURE_NEVER // VO paks. may be referenced, won't be in the pure lists
} pureStatus_t;
typedef struct {
idList<int> depends;
idList<idDict *> mapDecls;
} addonInfo_t;
typedef struct {
idStr pakFilename; // c:\doom\base\pak0.pk4
unzFile handle;
int checksum;
int numfiles;
int length;
bool referenced;
binaryStatus_t binary;
bool addon; // this is an addon pack - addon_search tells if it's 'active'
bool addon_search; // is in the search list
addonInfo_t *addon_info;
pureStatus_t pureStatus;
bool isNew; // for downloaded paks
fileInPack_t *hashTable[FILE_HASH_SIZE];
fileInPack_t *buildBuffer;
} pack_t;
typedef struct {
idStr path; // c:\doom
idStr gamedir; // base
} directory_t;
typedef struct searchpath_s {
pack_t * pack; // only one of pack / dir will be non NULL
directory_t * dir;
struct searchpath_s *next;
} searchpath_t;
// search flags when opening a file
#define FSFLAG_SEARCH_DIRS ( 1 << 0 )
#define FSFLAG_SEARCH_PAKS ( 1 << 1 )
#define FSFLAG_PURE_NOREF ( 1 << 2 )
#define FSFLAG_BINARY_ONLY ( 1 << 3 )
#define FSFLAG_SEARCH_ADDONS ( 1 << 4 )
// 3 search path (fs_savepath fs_basepath fs_cdpath)
// + .jpg and .tga
#define MAX_CACHED_DIRS 6
// how many OSes to handle game paks for ( we don't have to know them precisely )
#define MAX_GAME_OS 6
#define BINARY_CONFIG "binary.conf"
#define ADDON_CONFIG "addon.conf"
class idDEntry : public idStrList {
public:
idDEntry() {}
virtual ~idDEntry() {}
bool Matches( const char *directory, const char *extension ) const;
void Init( const char *directory, const char *extension, const idStrList &list );
void Clear( void );
private:
idStr directory;
idStr extension;
};
class idFileSystemLocal : public idFileSystem {
public:
idFileSystemLocal( void );
virtual void Init( void );
virtual void StartBackgroundDownloadThread( void );
virtual void Restart( void );
virtual void Shutdown( bool reloading );
virtual bool IsInitialized( void ) const;
virtual bool PerformingCopyFiles( void ) const;
virtual idModList * ListMods( void );
virtual void FreeModList( idModList *modList );
virtual idFileList * ListFiles( const char *relativePath, const char *extension, bool sort = false, bool fullRelativePath = false, const char* gamedir = NULL );
virtual idFileList * ListFilesTree( const char *relativePath, const char *extension, bool sort = false, const char* gamedir = NULL );
virtual void FreeFileList( idFileList *fileList );
virtual const char * OSPathToRelativePath( const char *OSPath );
virtual const char * RelativePathToOSPath( const char *relativePath, const char *basePath );
virtual const char * BuildOSPath( const char *base, const char *game, const char *relativePath );
virtual void CreateOSPath( const char *OSPath );
virtual bool FileIsInPAK( const char *relativePath );
virtual void UpdatePureServerChecksums( void );
virtual bool UpdateGamePakChecksums( void );
virtual fsPureReply_t SetPureServerChecksums( const int pureChecksums[ MAX_PURE_PAKS ], int gamePakChecksum, int missingChecksums[ MAX_PURE_PAKS ], int *missingGamePakChecksum );
virtual void GetPureServerChecksums( int checksums[ MAX_PURE_PAKS ], int OS, int *gamePakChecksum );
virtual void SetRestartChecksums( const int pureChecksums[ MAX_PURE_PAKS ], int gamePakChecksum );
virtual void ClearPureChecksums( void );
virtual int GetOSMask( void );
virtual int ReadFile( const char *relativePath, void **buffer, ID_TIME_T *timestamp );
virtual void FreeFile( void *buffer );
virtual int WriteFile( const char *relativePath, const void *buffer, int size, const char *basePath = "fs_savepath" );
virtual void RemoveFile( const char *relativePath );
virtual idFile * OpenFileReadFlags( const char *relativePath, int searchFlags, pack_t **foundInPak = NULL, bool allowCopyFiles = true, const char* gamedir = NULL );
virtual idFile * OpenFileRead( const char *relativePath, bool allowCopyFiles = true, const char* gamedir = NULL );
virtual idFile * OpenFileWrite( const char *relativePath, const char *basePath = "fs_savepath" );
virtual idFile * OpenFileAppend( const char *relativePath, bool sync = false, const char *basePath = "fs_basepath" );
virtual idFile * OpenFileByMode( const char *relativePath, fsMode_t mode );
virtual idFile * OpenExplicitFileRead( const char *OSPath );
virtual idFile * OpenExplicitFileWrite( const char *OSPath );
virtual void CloseFile( idFile *f );
virtual void BackgroundDownload( backgroundDownload_t *bgl );
virtual void ResetReadCount( void ) { readCount = 0; }
virtual void AddToReadCount( int c ) { readCount += c; }
virtual int GetReadCount( void ) { return readCount; }
virtual void FindDLL( const char *basename, char dllPath[ MAX_OSPATH ], bool updateChecksum );
virtual void ClearDirCache( void );
virtual bool HasD3XP( void );
virtual bool RunningD3XP( void );
virtual void CopyFile( const char *fromOSPath, const char *toOSPath );
virtual int ValidateDownloadPakForChecksum( int checksum, char path[ MAX_STRING_CHARS ], bool isBinary );
virtual idFile * MakeTemporaryFile( void );
virtual int AddZipFile( const char *path );
virtual findFile_t FindFile( const char *path, bool scheduleAddons );
virtual int GetNumMaps();
virtual const idDict * GetMapDecl( int i );
virtual void FindMapScreenshot( const char *path, char *buf, int len );
virtual bool FilenameCompare( const char *s1, const char *s2 ) const;
static void Dir_f( const idCmdArgs &args );
static void DirTree_f( const idCmdArgs &args );
static void Path_f( const idCmdArgs &args );
static void TouchFile_f( const idCmdArgs &args );
static void TouchFileList_f( const idCmdArgs &args );
//bc
virtual idStr GetModDescription( idStr descPath );
private:
friend dword BackgroundDownloadThread( void *parms );
searchpath_t * searchPaths;
int readCount; // total bytes read
int loadCount; // total files read
int loadStack; // total files in memory
idStr gameFolder; // this will be a single name without separators
searchpath_t *addonPaks; // not loaded up, but we saw them
idDict mapDict; // for GetMapDecl
static idCVar fs_debug;
static idCVar fs_restrict;
static idCVar fs_copyfiles;
static idCVar fs_basepath;
static idCVar fs_savepath;
static idCVar fs_cdpath;
static idCVar fs_devpath;
static idCVar fs_game;
static idCVar fs_game_base;
static idCVar fs_caseSensitiveOS;
static idCVar fs_searchAddons;
backgroundDownload_t * backgroundDownloads;
backgroundDownload_t defaultBackgroundDownload;
xthreadInfo backgroundThread;
idList<pack_t *> serverPaks;
bool loadedFileFromDir; // set to true once a file was loaded from a directory - can't switch to pure anymore
idList<int> restartChecksums; // used during a restart to set things in right order
idList<int> addonChecksums; // list of checksums that should go to the search list directly ( for restarts )
int restartGamePakChecksum;
int gameDLLChecksum; // the checksum of the last loaded game DLL
int gamePakChecksum; // the checksum of the pak holding the loaded game DLL
int gamePakForOS[ MAX_GAME_OS ];
idDEntry dir_cache[ MAX_CACHED_DIRS ]; // fifo
int dir_cache_index;
int dir_cache_count;
int d3xp; // 0: didn't check, -1: not installed, 1: installed
private:
void ReplaceSeparators( idStr &path, char sep = PATHSEPERATOR_CHAR );
long HashFileName( const char *fname ) const;
int ListOSFiles( const char *directory, const char *extension, idStrList &list );
FILE * OpenOSFile( const char *name, const char *mode, idStr *caseSensitiveName = NULL );
FILE * OpenOSFileCorrectName( idStr &path, const char *mode );
int DirectFileLength( FILE *o );
void CopyFile( idFile *src, const char *toOSPath );
int AddUnique( const char *name, idStrList &list, idHashIndex &hashIndex ) const;
void GetExtensionList( const char *extension, idStrList &extensionList ) const;
int GetFileList( const char *relativePath, const idStrList &extensions, idStrList &list, idHashIndex &hashIndex, bool fullRelativePath, const char* gamedir = NULL );
int GetFileListTree( const char *relativePath, const idStrList &extensions, idStrList &list, idHashIndex &hashIndex, const char* gamedir = NULL );
pack_t * LoadZipFile( const char *zipfile );
void AddGameDirectory( const char *path, const char *dir );
void SetupGameDirectories( const char *gameName );
void Startup( void );
void SetRestrictions( void );
// some files can be obtained from directories without compromising si_pure
bool FileAllowedFromDir( const char *path );
// searches all the paks, no pure check
pack_t * GetPackForChecksum( int checksum, bool searchAddons = false );
// searches all the paks, no pure check
pack_t * FindPakForFileChecksum( const char *relativePath, int fileChecksum, bool bReference );
idFile_InZip * ReadFileFromZip( pack_t *pak, fileInPack_t *pakFile, const char *relativePath );
int GetFileChecksum( idFile *file );
pureStatus_t GetPackStatus( pack_t *pak );
addonInfo_t * ParseAddonDef( const char *buf, const int len );
void FollowAddonDependencies( pack_t *pak );
static size_t CurlWriteFunction( void *ptr, size_t size, size_t nmemb, void *stream );
// curl_progress_callback in curl.h
static int CurlProgressFunction( void *clientp, double dltotal, double dlnow, double ultotal, double ulnow );
};
idCVar idFileSystemLocal::fs_restrict( "fs_restrict", "", CVAR_SYSTEM | CVAR_INIT | CVAR_BOOL, "" );
idCVar idFileSystemLocal::fs_debug( "fs_debug", "0", CVAR_SYSTEM | CVAR_INTEGER, "", 0, 2, idCmdSystem::ArgCompletion_Integer<0,2> );
idCVar idFileSystemLocal::fs_copyfiles( "fs_copyfiles", "0", CVAR_SYSTEM | CVAR_INIT | CVAR_INTEGER, "", 0, 4, idCmdSystem::ArgCompletion_Integer<0,3> );
idCVar idFileSystemLocal::fs_basepath( "fs_basepath", "", CVAR_SYSTEM | CVAR_INIT, "" );
idCVar idFileSystemLocal::fs_savepath( "fs_savepath", "", CVAR_SYSTEM | CVAR_INIT, "" );
idCVar idFileSystemLocal::fs_cdpath( "fs_cdpath", "", CVAR_SYSTEM | CVAR_INIT, "" );
idCVar idFileSystemLocal::fs_devpath( "fs_devpath", "", CVAR_SYSTEM | CVAR_INIT, "" );
idCVar idFileSystemLocal::fs_game( "fs_game", "", CVAR_SYSTEM | CVAR_INIT | CVAR_SERVERINFO, "mod path" );
idCVar idFileSystemLocal::fs_game_base( "fs_game_base", "", CVAR_SYSTEM | CVAR_INIT | CVAR_SERVERINFO, "alternate mod path, searched after the main fs_game path, before the basedir" );
#ifdef WIN32
idCVar idFileSystemLocal::fs_caseSensitiveOS( "fs_caseSensitiveOS", "0", CVAR_SYSTEM | CVAR_BOOL, "" );
#else
idCVar idFileSystemLocal::fs_caseSensitiveOS( "fs_caseSensitiveOS", "1", CVAR_SYSTEM | CVAR_BOOL, "" );
#endif
idCVar idFileSystemLocal::fs_searchAddons( "fs_searchAddons", "0", CVAR_SYSTEM | CVAR_BOOL, "search all addon pk4s ( disables addon functionality )" );
idFileSystemLocal fileSystemLocal;
idFileSystem * fileSystem = &fileSystemLocal;
/*
================
idFileSystemLocal::idFileSystemLocal
================
*/
idFileSystemLocal::idFileSystemLocal( void ) {
searchPaths = NULL;
readCount = 0;
loadCount = 0;
loadStack = 0;
dir_cache_index = 0;
dir_cache_count = 0;
d3xp = 0;
loadedFileFromDir = false;
restartGamePakChecksum = 0;
memset( &backgroundThread, 0, sizeof( backgroundThread ) );
addonPaks = NULL;
}
/*
================
idFileSystemLocal::HashFileName
return a hash value for the filename
================
*/
long idFileSystemLocal::HashFileName( const char *fname ) const {
int i;
long hash;
char letter;
hash = 0;
i = 0;
while( fname[i] != '\0' ) {
letter = idStr::ToLower( fname[i] );
if ( letter == '.' ) {
break; // don't include extension
}
if ( letter == '\\' ) {
letter = '/'; // damn path names
}
hash += (long)(letter) * (i+119);
i++;
}
hash &= (FILE_HASH_SIZE-1);
return hash;
}
/*
===========
idFileSystemLocal::FilenameCompare
Ignore case and separator char distinctions
===========
*/
bool idFileSystemLocal::FilenameCompare( const char *s1, const char *s2 ) const {
int c1, c2;
do {
c1 = *s1++;
c2 = *s2++;
if ( c1 >= 'a' && c1 <= 'z' ) {
c1 -= ('a' - 'A');
}
if ( c2 >= 'a' && c2 <= 'z' ) {
c2 -= ('a' - 'A');
}
if ( c1 == '\\' || c1 == ':' ) {
c1 = '/';
}
if ( c2 == '\\' || c2 == ':' ) {
c2 = '/';
}
if ( c1 != c2 ) {
return true; // strings not equal
}
} while( c1 );
return false; // strings are equal
}
/*
================
idFileSystemLocal::OpenOSFile
optional caseSensitiveName is set to case sensitive file name as found on disc (fs_caseSensitiveOS only)
================
*/
FILE *idFileSystemLocal::OpenOSFile( const char *fileName, const char *mode, idStr *caseSensitiveName ) {
int i;
FILE *fp;
idStr fpath, entry;
idStrList list;
#ifndef __MWERKS__
#ifndef WIN32
// some systems will let you fopen a directory
struct stat buf;
if ( stat( fileName, &buf ) != -1 && !S_ISREG(buf.st_mode) ) {
return NULL;
}
#endif
#endif
fp = fopen( fileName, mode );
if ( !fp && fs_caseSensitiveOS.GetBool() ) {
fpath = fileName;
fpath.StripFilename();
fpath.StripTrailing( PATHSEPERATOR_CHAR );
if ( ListOSFiles( fpath, NULL, list ) == -1 ) {
return NULL;
}
for ( i = 0; i < list.Num(); i++ ) {
entry = fpath + PATHSEPERATOR_CHAR + list[i];
if ( !entry.Icmp( fileName ) ) {
fp = fopen( entry, mode );
if ( fp ) {
if ( caseSensitiveName ) {
*caseSensitiveName = entry;
caseSensitiveName->StripPath();
}
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystemLocal::OpenFileRead: changed %s to %s\n", fileName, entry.c_str() );
}
break;
} else {
// not supposed to happen if ListOSFiles is doing it's job correctly
common->Warning( "idFileSystemLocal::OpenFileRead: fs_caseSensitiveOS 1 could not open %s", entry.c_str() );
}
}
}
} else if ( caseSensitiveName ) {
*caseSensitiveName = fileName;
caseSensitiveName->StripPath();
}
return fp;
}
/*
================
idFileSystemLocal::OpenOSFileCorrectName
================
*/
FILE *idFileSystemLocal::OpenOSFileCorrectName( idStr &path, const char *mode ) {
idStr caseName;
FILE *f = OpenOSFile( path.c_str(), mode, &caseName );
if ( f ) {
path.StripFilename();
path += PATHSEPERATOR_STR;
path += caseName;
}
return f;
}
/*
================
idFileSystemLocal::DirectFileLength
================
*/
int idFileSystemLocal::DirectFileLength( FILE *o ) {
int pos;
int end;
pos = ftell( o );
fseek( o, 0, SEEK_END );
end = ftell( o );
fseek( o, pos, SEEK_SET );
return end;
}
/*
============
idFileSystemLocal::CreateOSPath
Creates any directories needed to store the given filename
============
*/
void idFileSystemLocal::CreateOSPath( const char *OSPath ) {
char *ofs;
// make absolutely sure that it can't back up the path
// FIXME: what about c: ?
if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
#ifdef _DEBUG
common->DPrintf( "refusing to create relative path \"%s\"\n", OSPath );
#endif
return;
}
idStr path( OSPath );
for( ofs = &path[ 1 ]; *ofs ; ofs++ ) {
if ( *ofs == PATHSEPERATOR_CHAR ) {
// create the directory
*ofs = 0;
Sys_Mkdir( path );
*ofs = PATHSEPERATOR_CHAR;
}
}
}
/*
=================
idFileSystemLocal::CopyFile
Copy a fully specified file from one place to another
=================
*/
void idFileSystemLocal::CopyFile( const char *fromOSPath, const char *toOSPath ) {
FILE *f;
int len;
byte *buf;
common->Printf( "copy %s to %s\n", fromOSPath, toOSPath );
f = OpenOSFile( fromOSPath, "rb" );
if ( !f ) {
return;
}
fseek( f, 0, SEEK_END );
len = ftell( f );
fseek( f, 0, SEEK_SET );
buf = (byte *)Mem_Alloc( len );
if ( fread( buf, 1, len, f ) != (unsigned int)len ) {
common->FatalError( "short read in idFileSystemLocal::CopyFile()\n" );
}
fclose( f );
CreateOSPath( toOSPath );
f = OpenOSFile( toOSPath, "wb" );
if ( !f ) {
common->Printf( "could not create destination file\n" );
Mem_Free( buf );
return;
}
if ( fwrite( buf, 1, len, f ) != (unsigned int)len ) {
common->FatalError( "short write in idFileSystemLocal::CopyFile()\n" );
}
fclose( f );
Mem_Free( buf );
}
/*
=================
idFileSystemLocal::CopyFile
=================
*/
void idFileSystemLocal::CopyFile( idFile *src, const char *toOSPath ) {
FILE *f;
int len;
byte *buf;
common->Printf( "copy %s to %s\n", src->GetName(), toOSPath );
src->Seek( 0, FS_SEEK_END );
len = src->Tell();
src->Seek( 0, FS_SEEK_SET );
buf = (byte *)Mem_Alloc( len );
if ( src->Read( buf, len ) != len ) {
common->FatalError( "Short read in idFileSystemLocal::CopyFile()\n" );
}
CreateOSPath( toOSPath );
f = OpenOSFile( toOSPath, "wb" );
if ( !f ) {
common->Printf( "could not create destination file\n" );
Mem_Free( buf );
return;
}
if ( fwrite( buf, 1, len, f ) != (unsigned int)len ) {
common->FatalError( "Short write in idFileSystemLocal::CopyFile()\n" );
}
fclose( f );
Mem_Free( buf );
}
/*
====================
idFileSystemLocal::ReplaceSeparators
Fix things up differently for win/unix/mac
====================
*/
void idFileSystemLocal::ReplaceSeparators( idStr &path, char sep ) {
char *s;
for( s = &path[ 0 ]; *s ; s++ ) {
if ( *s == '/' || *s == '\\' ) {
*s = sep;
}
}
}
/*
===================
idFileSystemLocal::BuildOSPath
===================
*/
const char *idFileSystemLocal::BuildOSPath( const char *base, const char *game, const char *relativePath ) {
static char OSPath[MAX_STRING_CHARS];
idStr newPath;
if ( fs_caseSensitiveOS.GetBool() || com_developer.GetBool() ) {
// extract the path, make sure it's all lowercase
idStr testPath, fileName;
// only test if the relative path is actually relative
if ( strlen( relativePath ) > 0 && strstr( relativePath, GAME_NAME ) == NULL ) // if the game name is in the path
{
sprintf( testPath, "%s/%s", game , relativePath );
testPath.StripFilename();
if ( testPath.HasUpper() ) {
common->DPrintf( "Non-portable: path contains uppercase characters: %s\n", testPath.c_str() );
// attempt a fixup on the fly
if ( fs_caseSensitiveOS.GetBool() ) {
testPath.ToLower();
fileName = relativePath;
fileName.StripPath();
sprintf( newPath, "%s/%s/%s", base, testPath.c_str(), fileName.c_str() );
ReplaceSeparators( newPath );
common->DPrintf( "Fixed up to %s\n", newPath.c_str() );
idStr::Copynz( OSPath, newPath, sizeof( OSPath ) );
return OSPath;
}
}
}
}
idStr strBase = base;
strBase.StripTrailing( '/' );
strBase.StripTrailing( '\\' );
sprintf( newPath, "%s/%s/%s", strBase.c_str(), game, relativePath );
ReplaceSeparators( newPath );
idStr::Copynz( OSPath, newPath, sizeof( OSPath ) );
return OSPath;
}
/*
================
idFileSystemLocal::OSPathToRelativePath
takes a full OS path, as might be found in data from a media creation
program, and converts it to a relativePath by stripping off directories
Returns false if the osPath tree doesn't match any of the existing
search paths.
================
*/
const char *idFileSystemLocal::OSPathToRelativePath( const char *OSPath ) {
static char relativePath[MAX_STRING_CHARS];
char *s, *base;
// skip a drive letter?
// search for anything with "base" in it
// Ase files from max may have the form of:
// "//Purgatory/purgatory/doom/base/models/mapobjects/bitch/hologirl.tga"
// which won't match any of our drive letter based search paths
bool ignoreWarning = false;
#ifdef ID_DEMO_BUILD
base = strstr( OSPath, BASE_GAMEDIR );
idStr tempStr = OSPath;
tempStr.ToLower();
if ( ( strstr( tempStr, "//" ) || strstr( tempStr, "w:" ) ) && strstr( tempStr, "/doom/base/") ) {
// will cause a warning but will load the file. ase models have
// hard coded doom/base/ in the material names
base = strstr( OSPath, "base" );
ignoreWarning = true;
}
#else
// look for the first complete directory name
base = (char *)strstr( OSPath, BASE_GAMEDIR );
while ( base ) {
char c1 = '\0', c2;
if ( base > OSPath ) {
c1 = *(base - 1);
}
c2 = *( base + strlen( BASE_GAMEDIR ) );
if ( ( c1 == '/' || c1 == '\\' ) && ( c2 == '/' || c2 == '\\' ) ) {
break;
}
base = strstr( base + 1, BASE_GAMEDIR );
}
#endif
// fs_game and fs_game_base support - look for first complete name with a mod path
// ( fs_game searched before fs_game_base )
const char *fsgame = NULL;
int igame = 0;
for ( igame = 0; igame < 2; igame++ ) {
if ( igame == 0 ) {
fsgame = fs_game.GetString();
} else if ( igame == 1 ) {
fsgame = fs_game_base.GetString();
}
if ( base == NULL && fsgame && strlen( fsgame ) ) {
base = (char *)strstr( OSPath, fsgame );
while ( base ) {
char c1 = '\0', c2;
if ( base > OSPath ) {
c1 = *(base - 1);
}
c2 = *( base + strlen( fsgame ) );
if ( ( c1 == '/' || c1 == '\\' ) && ( c2 == '/' || c2 == '\\' ) ) {
break;
}
base = strstr( base + 1, fsgame );
}
}
}
if ( base ) {
s = strstr( base, "/" );
if ( !s ) {
s = strstr( base, "\\" );
}
if ( s ) {
strcpy( relativePath, s + 1 );
if ( fs_debug.GetInteger() > 1 ) {
common->Printf( "idFileSystem::OSPathToRelativePath: %s becomes %s\n", OSPath, relativePath );
}
return relativePath;
}
}
if ( !ignoreWarning ) {
common->Warning( "idFileSystem::OSPathToRelativePath failed on %s", OSPath );
}
strcpy( relativePath, "" );
return relativePath;
}
/*
=====================
idFileSystemLocal::RelativePathToOSPath
Returns a fully qualified path that can be used with stdio libraries
=====================
*/
const char *idFileSystemLocal::RelativePathToOSPath( const char *relativePath, const char *basePath ) {
const char *path = cvarSystem->GetCVarString( basePath );
if ( !path[0] ) {
path = fs_savepath.GetString();
}
return BuildOSPath( path, gameFolder, relativePath );
}
/*
=================
idFileSystemLocal::RemoveFile
=================
*/
void idFileSystemLocal::RemoveFile( const char *relativePath ) {
idStr OSPath;
if ( fs_devpath.GetString()[0] ) {
OSPath = BuildOSPath( fs_devpath.GetString(), gameFolder, relativePath );
remove( OSPath );
}
OSPath = BuildOSPath( fs_savepath.GetString(), gameFolder, relativePath );
remove( OSPath );
ClearDirCache();
}
/*
================
idFileSystemLocal::FileIsInPAK
================
*/
bool idFileSystemLocal::FileIsInPAK( const char *relativePath ) {
searchpath_t *search;
pack_t *pak;
fileInPack_t *pakFile;
long hash;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !relativePath ) {
common->FatalError( "idFileSystemLocal::FileIsInPAK: NULL 'relativePath' parameter passed\n" );
}
// qpaths are not supposed to have a leading slash
if ( relativePath[0] == '/' || relativePath[0] == '\\' ) {
relativePath++;
}
// make absolutely sure that it can't back up the path.
// The searchpaths do guarantee that something will always
// be prepended, so we don't need to worry about "c:" or "//limbo"
if ( strstr( relativePath, ".." ) || strstr( relativePath, "::" ) ) {
return false;
}
//
// search through the path, one element at a time
//
hash = HashFileName( relativePath );
for ( search = searchPaths; search; search = search->next ) {
// is the element a pak file?
if ( search->pack && search->pack->hashTable[hash] ) {
// disregard if it doesn't match one of the allowed pure pak files - or is a localization file
if ( serverPaks.Num() ) {
GetPackStatus( search->pack );
if ( search->pack->pureStatus != PURE_NEVER && !serverPaks.Find( search->pack ) ) {
continue; // not on the pure server pak list
}
}
// look through all the pak file elements
pak = search->pack;
pakFile = pak->hashTable[hash];
do {
// case and separator insensitive comparisons
if ( !FilenameCompare( pakFile->name, relativePath ) ) {
return true;
}
pakFile = pakFile->next;
} while( pakFile != NULL );
}
}
return false;
}
/*
============
idFileSystemLocal::ReadFile
Filename are relative to the search path
a null buffer will just return the file length and time without loading
timestamp can be NULL if not required
============
*/
int idFileSystemLocal::ReadFile( const char *relativePath, void **buffer, ID_TIME_T *timestamp ) {
idFile * f;
byte * buf;
int len;
bool isConfig;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !relativePath || !relativePath[0] ) {
common->FatalError( "idFileSystemLocal::ReadFile with empty name\n" );
}
if ( timestamp ) {
*timestamp = FILE_NOT_FOUND_TIMESTAMP;
}
if ( buffer ) {
*buffer = NULL;
}
buf = NULL; // quiet compiler warning
// if this is a .cfg file and we are playing back a journal, read
// it from the journal file
if ( strstr( relativePath, ".cfg" ) == relativePath + strlen( relativePath ) - 4 ) {
isConfig = true;
if ( eventLoop && eventLoop->JournalLevel() == 2 ) {
int r;
loadCount++;
loadStack++;
common->DPrintf( "Loading %s from journal file.\n", relativePath );
len = 0;
r = eventLoop->com_journalDataFile->Read( &len, sizeof( len ) );
if ( r != sizeof( len ) ) {
*buffer = NULL;
return -1;
}
buf = (byte *)Mem_ClearedAlloc(len+1);
*buffer = buf;
r = eventLoop->com_journalDataFile->Read( buf, len );
if ( r != len ) {
common->FatalError( "Read from journalDataFile failed" );
}
// guarantee that it will have a trailing 0 for string operations
buf[len] = 0;
return len;
}
} else {
isConfig = false;
}
// look for it in the filesystem or pack files
f = OpenFileRead( relativePath, ( buffer != NULL ) );
if ( f == NULL ) {
if ( buffer ) {
*buffer = NULL;
}
return -1;
}
len = f->Length();
if ( timestamp ) {
*timestamp = f->Timestamp();
}
if ( !buffer ) {
CloseFile( f );
return len;
}
loadCount++;
loadStack++;
buf = (byte *)Mem_ClearedAlloc(len+1);
*buffer = buf;
f->Read( buf, len );
// guarantee that it will have a trailing 0 for string operations
buf[len] = 0;
CloseFile( f );
// if we are journalling and it is a config file, write it to the journal file
if ( isConfig && eventLoop && eventLoop->JournalLevel() == 1 ) {
common->DPrintf( "Writing %s to journal file.\n", relativePath );
eventLoop->com_journalDataFile->Write( &len, sizeof( len ) );
eventLoop->com_journalDataFile->Write( buf, len );
eventLoop->com_journalDataFile->Flush();
}
return len;
}
/*
=============
idFileSystemLocal::FreeFile
=============
*/
void idFileSystemLocal::FreeFile( void *buffer ) {
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !buffer ) {
common->FatalError( "idFileSystemLocal::FreeFile( NULL )" );
}
loadStack--;
Mem_Free( buffer );
}
/*
============
idFileSystemLocal::WriteFile
Filenames are relative to the search path
============
*/
int idFileSystemLocal::WriteFile( const char *relativePath, const void *buffer, int size, const char *basePath ) {
idFile *f;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !relativePath || !buffer ) {
common->FatalError( "idFileSystemLocal::WriteFile: NULL parameter" );
}
f = idFileSystemLocal::OpenFileWrite( relativePath, basePath );
if ( !f ) {
common->Printf( "Failed to open %s\n", relativePath );
return -1;
}
size = f->Write( buffer, size );
CloseFile( f );
return size;
}
/*
=================
idFileSystemLocal::ParseAddonDef
=================
*/
addonInfo_t *idFileSystemLocal::ParseAddonDef( const char *buf, const int len ) {
idLexer src;
idToken token, token2;
addonInfo_t *info;
src.LoadMemory( buf, len, "<addon.conf>" );
src.SetFlags( DECL_LEXER_FLAGS );
if ( !src.SkipUntilString( "addonDef" ) ) {
src.Warning( "ParseAddonDef: no addonDef" );
return NULL;
}
if ( !src.ReadToken( &token ) ) {
src.Warning( "Expected {" );
return NULL;
}
info = new addonInfo_t;
// read addonDef
while ( 1 ) {
if ( !src.ReadToken( &token ) ) {
delete info;
return NULL;
}
if ( !token.Icmp( "}" ) ) {
break;
}
if ( token.type != TT_STRING ) {
src.Warning( "Expected quoted string, but found '%s'", token.c_str() );
delete info;
return NULL;
}
int checksum;
if ( sscanf( token.c_str(), "0x%x", &checksum ) != 1 && sscanf( token.c_str(), "%x", &checksum ) != 1 ) {
src.Warning( "Could not parse checksum '%s'", token.c_str() );
delete info;
return NULL;
}
info->depends.Append( checksum );
}
// read any number of mapDef entries
while ( 1 ) {
if ( !src.SkipUntilString( "mapDef" ) ) {
return info;
}
if ( !src.ReadToken( &token ) ) {
src.Warning( "Expected map path" );
info->mapDecls.DeleteContents( true );
delete info;
return NULL;
}
idDict *dict = new idDict;
dict->Set( "path", token.c_str() );
if ( !src.ReadToken( &token ) ) {
src.Warning( "Expected {" );
info->mapDecls.DeleteContents( true );
delete dict;
delete info;
return NULL;
}
while ( 1 ) {
if ( !src.ReadToken( &token ) ) {
break;
}
if ( !token.Icmp( "}" ) ) {
break;
}
if ( token.type != TT_STRING ) {
src.Warning( "Expected quoted string, but found '%s'", token.c_str() );
info->mapDecls.DeleteContents( true );
delete dict;
delete info;
return NULL;
}
if ( !src.ReadToken( &token2 ) ) {
src.Warning( "Unexpected end of file" );
info->mapDecls.DeleteContents( true );
delete dict;
delete info;
return NULL;
}
if ( dict->FindKey( token ) ) {
src.Warning( "'%s' already defined", token.c_str() );
}
dict->Set( token, token2 );
}
info->mapDecls.Append( dict );
}
assert( false );
return NULL;
}
/*
=================
idFileSystemLocal::LoadZipFile
=================
*/
pack_t *idFileSystemLocal::LoadZipFile( const char *zipfile ) {
fileInPack_t * buildBuffer;
pack_t * pack;
unzFile uf;
int err;
unz_global_info gi;
char filename_inzip[MAX_ZIPPED_FILE_NAME];
unz_file_info file_info;
int i;
long hash;
int fs_numHeaderLongs;
int * fs_headerLongs;
FILE *f;
int len;
int confHash;
fileInPack_t *pakFile;
f = OpenOSFile( zipfile, "rb" );
if ( !f ) {
return NULL;
}
fseek( f, 0, SEEK_END );
len = ftell( f );
fclose( f );
fs_numHeaderLongs = 0;
uf = unzOpen( zipfile );
err = unzGetGlobalInfo( uf, &gi );
if ( err != UNZ_OK ) {
return NULL;
}
buildBuffer = new fileInPack_t[gi.number_entry];
pack = new pack_t;
for( i = 0; i < FILE_HASH_SIZE; i++ ) {
pack->hashTable[i] = NULL;
}
pack->pakFilename = zipfile;
pack->handle = uf;
pack->numfiles = gi.number_entry;
pack->buildBuffer = buildBuffer;
pack->referenced = false;
pack->binary = BINARY_UNKNOWN;
pack->addon = false;
pack->addon_search = false;
pack->addon_info = NULL;
pack->pureStatus = PURE_UNKNOWN;
pack->isNew = false;
pack->length = len;
unzGoToFirstFile(uf);
fs_headerLongs = (int *)Mem_ClearedAlloc( gi.number_entry * sizeof(int) );
for ( i = 0; i < (int)gi.number_entry; i++ ) {
err = unzGetCurrentFileInfo( uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0 );
if ( err != UNZ_OK ) {
break;
}
if ( file_info.uncompressed_size > 0 ) {
fs_headerLongs[fs_numHeaderLongs++] = LittleLong( file_info.crc );
}
hash = HashFileName( filename_inzip );
buildBuffer[i].name = filename_inzip;
buildBuffer[i].name.ToLower();
buildBuffer[i].name.BackSlashesToSlashes();
// store the file position in the zip
unzGetCurrentFileInfoPosition( uf, &buildBuffer[i].pos );
// add the file to the hash
buildBuffer[i].next = pack->hashTable[hash];
pack->hashTable[hash] = &buildBuffer[i];
// go to the next file in the zip
unzGoToNextFile(uf);
}
// check if this is an addon pak
pack->addon = false;
confHash = HashFileName( ADDON_CONFIG );
for ( pakFile = pack->hashTable[confHash]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, ADDON_CONFIG ) ) {
pack->addon = true;
idFile_InZip *file = ReadFileFromZip( pack, pakFile, ADDON_CONFIG );
// may be just an empty file if you don't bother about the mapDef
if ( file && file->Length() ) {
char *buf;
buf = new char[ file->Length() + 1 ];
file->Read( (void *)buf, file->Length() );
buf[ file->Length() ] = '\0';
pack->addon_info = ParseAddonDef( buf, file->Length() );
delete[] buf;
}
if ( file ) {
CloseFile( file );
}
break;
}
}
pack->checksum = MD4_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
pack->checksum = LittleLong( pack->checksum );
Mem_Free( fs_headerLongs );
return pack;
}
/*
===============
idFileSystemLocal::AddZipFile
adds a downloaded pak file to the list so we can work out what we have and what we still need
the isNew flag is set to true, indicating that we cannot add this pak to the search lists without a restart
===============
*/
int idFileSystemLocal::AddZipFile( const char *path ) {
idStr fullpath = fs_savepath.GetString();
pack_t *pak;
searchpath_t *search, *last;
fullpath.AppendPath( path );
pak = LoadZipFile( fullpath );
if ( !pak ) {
common->Warning( "AddZipFile %s failed\n", path );
return 0;
}
// insert the pak at the end of the search list - temporary until we restart
pak->isNew = true;
search = new searchpath_t;
search->dir = NULL;
search->pack = pak;
search->next = NULL;
last = searchPaths;
while ( last->next ) {
last = last->next;
}
last->next = search;
common->Printf( "Appended pk4 %s with checksum 0x%x\n", pak->pakFilename.c_str(), pak->checksum );
return pak->checksum;
}
/*
===============
idFileSystemLocal::AddUnique
===============
*/
int idFileSystemLocal::AddUnique( const char *name, idStrList &list, idHashIndex &hashIndex ) const {
int i, hashKey;
hashKey = hashIndex.GenerateKey( name );
for ( i = hashIndex.First( hashKey ); i >= 0; i = hashIndex.Next( i ) ) {
if ( list[i].Icmp( name ) == 0 ) {
return i;
}
}
i = list.Append( name );
hashIndex.Add( hashKey, i );
return i;
}
/*
===============
idFileSystemLocal::GetExtensionList
===============
*/
void idFileSystemLocal::GetExtensionList( const char *extension, idStrList &extensionList ) const {
int s, e, l;
l = idStr::Length( extension );
s = 0;
while( 1 ) {
e = idStr::FindChar( extension, '|', s, l );
if ( e != -1 ) {
extensionList.Append( idStr( extension, s, e ) );
s = e + 1;
} else {
extensionList.Append( idStr( extension, s, l ) );
break;
}
}
}
/*
===============
idFileSystemLocal::GetFileList
Does not clear the list first so this can be used to progressively build a file list.
When 'sort' is true only the new files added to the list are sorted.
===============
*/
int idFileSystemLocal::GetFileList( const char *relativePath, const idStrList &extensions, idStrList &list, idHashIndex &hashIndex, bool fullRelativePath, const char* gamedir ) {
searchpath_t * search;
fileInPack_t * buildBuffer;
int i, j;
int pathLength;
int length;
const char * name;
pack_t * pak;
idStr work;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !extensions.Num() ) {
return 0;
}
if ( !relativePath ) {
return 0;
}
pathLength = strlen( relativePath );
if ( pathLength ) {
pathLength++; // for the trailing '/'
}
// search through the path, one element at a time, adding to list
for( search = searchPaths; search != NULL; search = search->next ) {
if ( search->dir ) {
if(gamedir && strlen(gamedir)) {
if(search->dir->gamedir != gamedir) {
continue;
}
}
idStrList sysFiles;
idStr netpath;
netpath = BuildOSPath( search->dir->path, search->dir->gamedir, relativePath );
for ( i = 0; i < extensions.Num(); i++ ) {
// scan for files in the filesystem
ListOSFiles( netpath, extensions[i], sysFiles );
// if we are searching for directories, remove . and ..
if ( extensions[i][0] == '/' && extensions[i][1] == 0 ) {
sysFiles.Remove( "." );
sysFiles.Remove( ".." );
}
for( j = 0; j < sysFiles.Num(); j++ ) {
// unique the match
if ( fullRelativePath ) {
work = relativePath;
work += "/";
work += sysFiles[j];
AddUnique( work, list, hashIndex );
}
else {
AddUnique( sysFiles[j], list, hashIndex );
}
}
}
} else if ( search->pack ) {
// look through all the pak file elements
// exclude any extra packs if we have server paks to search
if ( serverPaks.Num() ) {
GetPackStatus( search->pack );
if ( search->pack->pureStatus != PURE_NEVER && !serverPaks.Find( search->pack ) ) {
continue; // not on the pure server pak list
}
}
pak = search->pack;
buildBuffer = pak->buildBuffer;
for( i = 0; i < pak->numfiles; i++ ) {
length = buildBuffer[i].name.Length();
// if the name is not long anough to at least contain the path
if ( length <= pathLength ) {
continue;
}
name = buildBuffer[i].name;
// check for a path match without the trailing '/'
if ( pathLength && idStr::Icmpn( name, relativePath, pathLength - 1 ) != 0 ) {
continue;
}
// ensure we have a path, and not just a filename containing the path
if ( name[ pathLength ] == '\0' || name[pathLength - 1] != '/' ) {
continue;
}
// make sure the file is not in a subdirectory
for ( j = pathLength; name[j+1] != '\0'; j++ ) {
if ( name[j] == '/' ) {
break;
}
}
if ( name[j+1] ) {
continue;
}
// check for extension match
for ( j = 0; j < extensions.Num(); j++ ) {
if ( length >= extensions[j].Length() && extensions[j].Icmp( name + length - extensions[j].Length() ) == 0 ) {
break;
}
}
if ( j >= extensions.Num() ) {
continue;
}
// unique the match
if ( fullRelativePath ) {
work = relativePath;
work += "/";
work += name + pathLength;
work.StripTrailing( '/' );
AddUnique( work, list, hashIndex );
} else {
work = name + pathLength;
work.StripTrailing( '/' );
AddUnique( work, list, hashIndex );
}
}
}
}
return list.Num();
}
/*
===============
idFileSystemLocal::ListFiles
===============
*/
idFileList *idFileSystemLocal::ListFiles( const char *relativePath, const char *extension, bool sort, bool fullRelativePath, const char* gamedir ) {
idHashIndex hashIndex( 4096, 4096 );
idStrList extensionList;
idFileList *fileList = new idFileList;
fileList->basePath = relativePath;
GetExtensionList( extension, extensionList );
GetFileList( relativePath, extensionList, fileList->list, hashIndex, fullRelativePath, gamedir );
if ( sort ) {
idStrListSortPaths( fileList->list );
}
return fileList;
}
/*
===============
idFileSystemLocal::GetFileListTree
===============
*/
int idFileSystemLocal::GetFileListTree( const char *relativePath, const idStrList &extensions, idStrList &list, idHashIndex &hashIndex, const char* gamedir ) {
int i;
idStrList slash, folders( 128 );
idHashIndex folderHashIndex( 1024, 128 );
// recurse through the subdirectories
slash.Append( "/" );
GetFileList( relativePath, slash, folders, folderHashIndex, true, gamedir );
for ( i = 0; i < folders.Num(); i++ ) {
if ( folders[i][0] == '.' ) {
continue;
}
if ( folders[i].Icmp( relativePath ) == 0 ){
continue;
}
GetFileListTree( folders[i], extensions, list, hashIndex, gamedir );
}
// list files in the current directory
GetFileList( relativePath, extensions, list, hashIndex, true, gamedir );
return list.Num();
}
/*
===============
idFileSystemLocal::ListFilesTree
===============
*/
idFileList *idFileSystemLocal::ListFilesTree( const char *relativePath, const char *extension, bool sort, const char* gamedir ) {
idHashIndex hashIndex( 4096, 4096 );
idStrList extensionList;
idFileList *fileList = new idFileList();
fileList->basePath = relativePath;
fileList->list.SetGranularity( 4096 );
GetExtensionList( extension, extensionList );
GetFileListTree( relativePath, extensionList, fileList->list, hashIndex, gamedir );
if ( sort ) {
idStrListSortPaths( fileList->list );
}
return fileList;
}
/*
===============
idFileSystemLocal::FreeFileList
===============
*/
void idFileSystemLocal::FreeFileList( idFileList *fileList ) {
delete fileList;
}
/*
===============
idFileSystemLocal::ListMods
===============
*/
idModList *idFileSystemLocal::ListMods( void ) {
int i;
const int MAX_DESCRIPTION = 256;
char desc[ MAX_DESCRIPTION ];
idStrList dirs;
idStrList pk4s;
idModList *list = new idModList;
const char *search[ 4 ];
int isearch;
search[0] = fs_savepath.GetString();
search[1] = fs_devpath.GetString();
search[2] = fs_basepath.GetString();
search[3] = fs_cdpath.GetString();
for ( isearch = 0; isearch < 4; isearch++ ) {
dirs.Clear();
pk4s.Clear();
// scan for directories
ListOSFiles( search[ isearch ], "/", dirs );
dirs.Remove( "." );
dirs.Remove( ".." );
dirs.Remove( "base" );
dirs.Remove( "pb" );
// see if there are any pk4 files in each directory
for( i = 0; i < dirs.Num(); i++ )
{
idStr gamepath = BuildOSPath( search[ isearch ], dirs[ i ], "" );
ListOSFiles( gamepath, ".pk4", pk4s );
if ( pk4s.Num() )
{
if ( !list->mods.Find( dirs[ i ] ) )
{
// D3 1.3 #31, only list d3xp if the pak is present
if ( dirs[ i ].Icmp( "d3xp" ) || HasD3XP() )
{
list->mods.Append( dirs[ i ] );
}
}
}
}
}
list->mods.Sort();
// read the descriptions for each mod - search all paths
for ( i = 0; i < list->mods.Num(); i++ ) {
for ( isearch = 0; isearch < 4; isearch++ ) {
idStr descfile = BuildOSPath( search[ isearch ], list->mods[ i ], "description.txt" );
FILE *f = OpenOSFile( descfile, "r" );
if ( f ) {
if ( fgets( desc, MAX_DESCRIPTION, f ) ) {
list->descriptions.Append( desc );
fclose( f );
break;
} else {
common->DWarning( "Error reading %s", descfile.c_str() );
fclose( f );
continue;
}
}
}
if ( isearch == 4 ) {
list->descriptions.Append( list->mods[ i ] );
}
}
list->mods.Insert( "" );
list->descriptions.Insert( "Quadrilateral Cowboy" );
assert( list->mods.Num() == list->descriptions.Num() );
return list;
}
/*
===============
idFileSystemLocal::FreeModList
===============
*/
void idFileSystemLocal::FreeModList( idModList *modList ) {
delete modList;
}
/*
===============
idDEntry::Matches
===============
*/
bool idDEntry::Matches(const char *directory, const char *extension) const {
if ( !idDEntry::directory.Icmp( directory ) && !idDEntry::extension.Icmp( extension ) ) {
return true;
}
return false;
}
/*
===============
idDEntry::Init
===============
*/
void idDEntry::Init( const char *directory, const char *extension, const idStrList &list ) {
idDEntry::directory = directory;
idDEntry::extension = extension;
idStrList::operator=(list);
}
/*
===============
idDEntry::Clear
===============
*/
void idDEntry::Clear( void ) {
directory.Clear();
extension.Clear();
idStrList::Clear();
}
/*
===============
idFileSystemLocal::ListOSFiles
call to the OS for a listing of files in an OS directory
optionally, perform some caching of the entries
===============
*/
int idFileSystemLocal::ListOSFiles( const char *directory, const char *extension, idStrList &list ) {
int i, j, ret;
if ( !extension ) {
extension = "";
}
if ( !fs_caseSensitiveOS.GetBool() ) {
return Sys_ListFiles( directory, extension, list );
}
// try in cache
i = dir_cache_index - 1;
while( i >= dir_cache_index - dir_cache_count ) {
j = (i+MAX_CACHED_DIRS) % MAX_CACHED_DIRS;
if ( dir_cache[j].Matches( directory, extension ) ) {
if ( fs_debug.GetInteger() ) {
//common->Printf( "idFileSystemLocal::ListOSFiles: cache hit: %s\n", directory );
}
list = dir_cache[j];
return list.Num();
}
i--;
}
if ( fs_debug.GetInteger() ) {
//common->Printf( "idFileSystemLocal::ListOSFiles: cache miss: %s\n", directory );
}
ret = Sys_ListFiles( directory, extension, list );
if ( ret == -1 ) {
return -1;
}
// push a new entry
dir_cache[dir_cache_index].Init( directory, extension, list );
dir_cache_index = (++dir_cache_index) % MAX_CACHED_DIRS;
if ( dir_cache_count < MAX_CACHED_DIRS ) {
dir_cache_count++;
}
return ret;
}
/*
================
idFileSystemLocal::Dir_f
================
*/
void idFileSystemLocal::Dir_f( const idCmdArgs &args ) {
idStr relativePath;
idStr extension;
idFileList *fileList;
int i;
if ( args.Argc() < 2 || args.Argc() > 3 ) {
common->Printf( "usage: dir <directory> [extension]\n" );
return;
}
if ( args.Argc() == 2 ) {
relativePath = args.Argv( 1 );
extension = "";
}
else {
relativePath = args.Argv( 1 );
extension = args.Argv( 2 );
if ( extension[0] != '.' ) {
common->Warning( "extension should have a leading dot" );
}
}
relativePath.BackSlashesToSlashes();
relativePath.StripTrailing( '/' );
common->Printf( "Listing of %s/*%s\n", relativePath.c_str(), extension.c_str() );
common->Printf( "---------------\n" );
fileList = fileSystemLocal.ListFiles( relativePath, extension );
for ( i = 0; i < fileList->GetNumFiles(); i++ ) {
common->Printf( "%s\n", fileList->GetFile( i ) );
}
common->Printf( "%d files\n", fileList->list.Num() );
fileSystemLocal.FreeFileList( fileList );
}
/*
================
idFileSystemLocal::DirTree_f
================
*/
void idFileSystemLocal::DirTree_f( const idCmdArgs &args ) {
idStr relativePath;
idStr extension;
idFileList *fileList;
int i;
if ( args.Argc() < 2 || args.Argc() > 3 ) {
common->Printf( "usage: dirtree <directory> [extension]\n" );
return;
}
if ( args.Argc() == 2 ) {
relativePath = args.Argv( 1 );
extension = "";
}
else {
relativePath = args.Argv( 1 );
extension = args.Argv( 2 );
if ( extension[0] != '.' ) {
common->Warning( "extension should have a leading dot" );
}
}
relativePath.BackSlashesToSlashes();
relativePath.StripTrailing( '/' );
common->Printf( "Listing of %s/*%s /s\n", relativePath.c_str(), extension.c_str() );
common->Printf( "---------------\n" );
fileList = fileSystemLocal.ListFilesTree( relativePath, extension );
for ( i = 0; i < fileList->GetNumFiles(); i++ ) {
common->Printf( "%s\n", fileList->GetFile( i ) );
}
common->Printf( "%d files\n", fileList->list.Num() );
fileSystemLocal.FreeFileList( fileList );
}
/*
============
idFileSystemLocal::Path_f
============
*/
void idFileSystemLocal::Path_f( const idCmdArgs &args ) {
searchpath_t *sp;
int i;
idStr status;
common->Printf( "Current search path:\n" );
for ( sp = fileSystemLocal.searchPaths; sp; sp = sp->next ) {
if ( sp->pack ) {
if ( com_developer.GetBool() ) {
sprintf( status, "%s (%i files - 0x%x %s", sp->pack->pakFilename.c_str(), sp->pack->numfiles, sp->pack->checksum, sp->pack->referenced ? "referenced" : "not referenced" );
if ( sp->pack->addon ) {
status += " - addon)\n";
} else {
status += ")\n";
}
common->Printf( status.c_str() );
}
else
{
common->Printf( "%s (%i files)\n", sp->pack->pakFilename.c_str(), sp->pack->numfiles );
}
if ( fileSystemLocal.serverPaks.Num() ) {
if ( fileSystemLocal.serverPaks.Find( sp->pack ) ) {
common->Printf( " on the pure list\n" );
} else {
common->Printf( " not on the pure list\n" );
}
}
} else {
common->Printf( "%s/%s\n", sp->dir->path.c_str(), sp->dir->gamedir.c_str() );
}
}
common->Printf( "game DLL: 0x%x in pak: 0x%x\n", fileSystemLocal.gameDLLChecksum, fileSystemLocal.gamePakChecksum );
#if ID_FAKE_PURE
common->Printf( "Note: ID_FAKE_PURE is enabled\n" );
#endif
for( i = 0; i < MAX_GAME_OS; i++ ) {
if ( fileSystemLocal.gamePakForOS[ i ] ) {
common->Printf( "OS %d - pak 0x%x\n", i, fileSystemLocal.gamePakForOS[ i ] );
}
}
// show addon packs that are *not* in the search lists
common->Printf( "Addon pk4s:\n" );
for ( sp = fileSystemLocal.addonPaks; sp; sp = sp->next ) {
if ( com_developer.GetBool() )
{
common->Printf( "%s (%i files - 0x%x)\n", sp->pack->pakFilename.c_str(), sp->pack->numfiles, sp->pack->checksum );
}
else
{
common->Printf( "%s (%i files)\n", sp->pack->pakFilename.c_str(), sp->pack->numfiles );
}
}
}
/*
============
idFileSystemLocal::GetOSMask
============
*/
int idFileSystemLocal::GetOSMask( void ) {
int i, ret = 0;
for( i = 0; i < MAX_GAME_OS; i++ ) {
if ( fileSystemLocal.gamePakForOS[ i ] ) {
ret |= ( 1 << i );
}
}
if ( !ret ) {
return -1;
}
return ret;
}
/*
============
idFileSystemLocal::TouchFile_f
The only purpose of this function is to allow game script files to copy
arbitrary files furing an "fs_copyfiles 1" run.
============
*/
void idFileSystemLocal::TouchFile_f( const idCmdArgs &args ) {
idFile *f;
if ( args.Argc() != 2 ) {
common->Printf( "Usage: touchFile <file>\n" );
return;
}
f = fileSystemLocal.OpenFileRead( args.Argv( 1 ) );
if ( f ) {
fileSystemLocal.CloseFile( f );
}
}
/*
============
idFileSystemLocal::TouchFileList_f
Takes a text file and touches every file in it, use one file per line.
============
*/
void idFileSystemLocal::TouchFileList_f( const idCmdArgs &args ) {
if ( args.Argc() != 2 ) {
common->Printf( "Usage: touchFileList <filename>\n" );
return;
}
const char *buffer = NULL;
idParser src( LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWMULTICHARLITERALS | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );
if ( fileSystem->ReadFile( args.Argv( 1 ), ( void** )&buffer, NULL ) && buffer ) {
src.LoadMemory( buffer, strlen( buffer ), args.Argv( 1 ) );
if ( src.IsLoaded() ) {
idToken token;
while( src.ReadToken( &token ) ) {
common->Printf( "%s\n", token.c_str() );
session->UpdateScreen();
idFile *f = fileSystemLocal.OpenFileRead( token );
if ( f ) {
fileSystemLocal.CloseFile( f );
}
}
}
}
}
/*
================
idFileSystemLocal::AddGameDirectory
Sets gameFolder, adds the directory to the head of the search paths, then loads any pk4 files.
================
*/
void idFileSystemLocal::AddGameDirectory( const char *path, const char *dir ) {
int i;
searchpath_t * search;
pack_t * pak;
idStr pakfile;
idStrList pakfiles;
// check if the search path already exists
for ( search = searchPaths; search; search = search->next ) {
// if this element is a pak file
if ( !search->dir ) {
continue;
}
if ( search->dir->path.Cmp( path ) == 0 && search->dir->gamedir.Cmp( dir ) == 0 ) {
return;
}
}
gameFolder = dir;
//
// add the directory to the search path
//
search = new searchpath_t;
search->dir = new directory_t;
search->pack = NULL;
search->dir->path = path;
search->dir->gamedir = dir;
search->next = searchPaths;
searchPaths = search;
// find all pak files in this directory
pakfile = BuildOSPath( path, dir, "" );
pakfile[ pakfile.Length() - 1 ] = 0; // strip the trailing slash
ListOSFiles( pakfile, ".pk4", pakfiles );
// sort them so that later alphabetic matches override
// earlier ones. This makes pak1.pk4 override pak0.pk4
pakfiles.Sort();
for ( i = 0; i < pakfiles.Num(); i++ ) {
pakfile = BuildOSPath( path, dir, pakfiles[i] );
pak = LoadZipFile( pakfile );
if ( !pak ) {
continue;
}
// insert the pak after the directory it comes from
search = new searchpath_t;
search->dir = NULL;
search->pack = pak;
search->next = searchPaths->next;
searchPaths->next = search;
common->Printf( "Loaded pk4 %s with checksum 0x%x\n", pakfile.c_str(), pak->checksum );
}
}
/*
================
idFileSystemLocal::SetupGameDirectories
Takes care of the correct search order.
================
*/
void idFileSystemLocal::SetupGameDirectories( const char *gameName ) {
// accept abs path
if (gameName && strlen(gameName) > 2
&& (gameName[0] == '/' || gameName[0] == '\\' || gameName[1] == ':') ) {
AddGameDirectory( gameName, "." );
}
else {
// setup cdpath
if ( fs_cdpath.GetString()[0] ) {
AddGameDirectory( fs_cdpath.GetString(), gameName );
}
// setup basepath
if ( fs_basepath.GetString()[0] ) {
AddGameDirectory( fs_basepath.GetString(), gameName );
}
// setup devpath
if ( fs_devpath.GetString()[0] ) {
AddGameDirectory( fs_devpath.GetString(), gameName );
}
// setup savepath
if ( fs_savepath.GetString()[0] ) {
AddGameDirectory( fs_savepath.GetString(), gameName );
}
}
}
/*
===============
idFileSystemLocal::FollowDependencies
===============
*/
void idFileSystemLocal::FollowAddonDependencies( pack_t *pak ) {
assert( pak );
if ( !pak->addon_info || !pak->addon_info->depends.Num() ) {
return;
}
int i, num = pak->addon_info->depends.Num();
for ( i = 0; i < num; i++ ) {
pack_t *deppak = GetPackForChecksum( pak->addon_info->depends[ i ], true );
if ( deppak ) {
// make sure it hasn't been marked for search already
if ( !deppak->addon_search ) {
// must clean addonChecksums as we go
int addon_index = addonChecksums.FindIndex( deppak->checksum );
if ( addon_index >= 0 ) {
addonChecksums.RemoveIndex( addon_index );
}
deppak->addon_search = true;
common->Printf( "Addon pk4 %s 0x%x depends on pak %s 0x%x, will be searched\n",
pak->pakFilename.c_str(), pak->checksum,
deppak->pakFilename.c_str(), deppak->checksum );
FollowAddonDependencies( deppak );
}
} else {
common->Printf( "Addon pk4 %s 0x%x depends on unknown pak 0x%x\n",
pak->pakFilename.c_str(), pak->checksum, pak->addon_info->depends[ i ] );
}
}
}
/*
================
idFileSystemLocal::Startup
================
*/
void idFileSystemLocal::Startup( void ) {
searchpath_t **search;
int i;
pack_t *pak;
int addon_index;
common->Printf( "------ Initializing File System ------\n" );
if ( restartChecksums.Num() ) {
common->Printf( "restarting in pure mode with %d pak files\n", restartChecksums.Num() );
}
if ( addonChecksums.Num() ) {
common->Printf( "restarting filesystem with %d addon pak file(s) to include\n", addonChecksums.Num() );
}
SetupGameDirectories( BASE_GAMEDIR );
// fs_game_base override
if ( fs_game_base.GetString()[0] &&
idStr::Icmp( fs_game_base.GetString(), BASE_GAMEDIR ) ) {
SetupGameDirectories( fs_game_base.GetString() );
}
// fs_game override
if ( fs_game.GetString()[0] &&
idStr::Icmp( fs_game.GetString(), BASE_GAMEDIR ) &&
idStr::Icmp( fs_game.GetString(), fs_game_base.GetString() ) ) {
SetupGameDirectories( fs_game.GetString() );
}
// currently all addons are in the search list - deal with filtering out and dependencies now
// scan through and deal with dependencies
search = &searchPaths;
while ( *search ) {
if ( !( *search )->pack || !( *search )->pack->addon ) {
search = &( ( *search )->next );
continue;
}
pak = ( *search )->pack;
if ( fs_searchAddons.GetBool() ) {
// when we have fs_searchAddons on we should never have addonChecksums
assert( !addonChecksums.Num() );
pak->addon_search = true;
search = &( ( *search )->next );
continue;
}
addon_index = addonChecksums.FindIndex( pak->checksum );
if ( addon_index >= 0 ) {
assert( !pak->addon_search ); // any pak getting flagged as addon_search should also have been removed from addonChecksums already
pak->addon_search = true;
addonChecksums.RemoveIndex( addon_index );
FollowAddonDependencies( pak );
}
search = &( ( *search )->next );
}
// now scan to filter out addons not marked addon_search
search = &searchPaths;
while ( *search ) {
if ( !( *search )->pack || !( *search )->pack->addon ) {
search = &( ( *search )->next );
continue;
}
assert( !( *search )->dir );
pak = ( *search )->pack;
if ( pak->addon_search ) {
common->Printf( "Addon pk4 %s with checksum 0x%x is on the search list\n",
pak->pakFilename.c_str(), pak->checksum );
search = &( ( *search )->next );
} else {
// remove from search list, put in addons list
searchpath_t *paksearch = *search;
*search = ( *search )->next;
paksearch->next = addonPaks;
addonPaks = paksearch;
common->Printf( "Addon pk4 %s with checksum 0x%x is on addon list\n",
pak->pakFilename.c_str(), pak->checksum );
}
}
// all addon paks found and accounted for
assert( !addonChecksums.Num() );
addonChecksums.Clear(); // just in case
if ( restartChecksums.Num() ) {
search = &searchPaths;
while ( *search ) {
if ( !( *search )->pack ) {
search = &( ( *search )->next );
continue;
}
if ( ( i = restartChecksums.FindIndex( ( *search )->pack->checksum ) ) != -1 ) {
if ( i == 0 ) {
// this pak is the next one in the pure search order
serverPaks.Append( ( *search )->pack );
restartChecksums.RemoveIndex( 0 );
if ( !restartChecksums.Num() ) {
break; // early out, we're done
}
search = &( ( *search )->next );
continue;
} else {
// this pak will be on the pure list, but order is not right yet
searchpath_t *aux;
aux = ( *search )->next;
if ( !aux ) {
// last of the list can't be swapped back
if ( fs_debug.GetBool() ) {
common->Printf( "found pure checksum %x at index %d, but the end of search path is reached\n", ( *search )->pack->checksum, i );
idStr checks;
checks.Clear();
for ( i = 0; i < serverPaks.Num(); i++ ) {
checks += va( "%p ", serverPaks[ i ] );
}
common->Printf( "%d pure paks - %s \n", serverPaks.Num(), checks.c_str() );
checks.Clear();
for ( i = 0; i < restartChecksums.Num(); i++ ) {
checks += va( "%x ", restartChecksums[ i ] );
}
common->Printf( "%d paks left - %s\n", restartChecksums.Num(), checks.c_str() );
}
common->FatalError( "Failed to restart with pure mode restrictions for server connect" );
}
// put this search path at the end of the list
searchpath_t *search_end;
search_end = ( *search )->next;
while ( search_end->next ) {
search_end = search_end->next;
}
search_end->next = *search;
*search = ( *search )->next;
search_end->next->next = NULL;
continue;
}
}
// this pak is not on the pure list
search = &( ( *search )->next );
}
// the list must be empty
if ( restartChecksums.Num() ) {
if ( fs_debug.GetBool() ) {
idStr checks;
checks.Clear();
for ( i = 0; i < serverPaks.Num(); i++ ) {
checks += va( "%p ", serverPaks[ i ] );
}
common->Printf( "%d pure paks - %s \n", serverPaks.Num(), checks.c_str() );
checks.Clear();
for ( i = 0; i < restartChecksums.Num(); i++ ) {
checks += va( "%x ", restartChecksums[ i ] );
}
common->Printf( "%d paks left - %s\n", restartChecksums.Num(), checks.c_str() );
}
common->FatalError( "Failed to restart with pure mode restrictions for server connect" );
}
// also the game pak checksum
// we could check if the game pak is actually present, but we would not be restarting if there wasn't one @ first pure check
gamePakChecksum = restartGamePakChecksum;
}
// add our commands
cmdSystem->AddCommand( "dir", Dir_f, CMD_FL_SYSTEM, "lists a folder", idCmdSystem::ArgCompletion_FileName );
cmdSystem->AddCommand( "dirtree", DirTree_f, CMD_FL_SYSTEM, "lists a folder with subfolders" );
cmdSystem->AddCommand( "path", Path_f, CMD_FL_SYSTEM, "lists search paths" );
cmdSystem->AddCommand( "touchFile", TouchFile_f, CMD_FL_SYSTEM, "touches a file" );
cmdSystem->AddCommand( "touchFileList", TouchFileList_f, CMD_FL_SYSTEM, "touches a list of files" );
// print the current search paths
Path_f( idCmdArgs() );
common->Printf( "file system initialized.\n" );
common->Printf( "--------------------------------------\n" );
}
/*
===================
idFileSystemLocal::SetRestrictions
Looks for product keys and restricts media add on ability
if the full version is not found
===================
*/
void idFileSystemLocal::SetRestrictions( void ) {
#ifdef ID_DEMO_BUILD
common->Printf( "\nRunning in restricted demo mode.\n\n" );
// make sure that the pak file has the header checksum we expect
searchpath_t *search;
for ( search = searchPaths; search; search = search->next ) {
if ( search->pack ) {
// a tiny attempt to keep the checksum from being scannable from the exe
if ( ( search->pack->checksum ^ 0x84268436u ) != ( DEMO_PAK_CHECKSUM ^ 0x84268436u ) ) {
common->FatalError( "Corrupted %s: 0x%x", search->pack->pakFilename.c_str(), search->pack->checksum );
}
}
}
cvarSystem->SetCVarBool( "fs_restrict", true );
#endif
}
/*
=====================
idFileSystemLocal::UpdatePureServerChecksums
=====================
*/
void idFileSystemLocal::UpdatePureServerChecksums( void ) {
searchpath_t *search;
int i;
pureStatus_t status;
serverPaks.Clear();
for ( search = searchPaths; search; search = search->next ) {
// is the element a referenced pak file?
if ( !search->pack ) {
continue;
}
status = GetPackStatus( search->pack );
if ( status == PURE_NEVER ) {
continue;
}
if ( status == PURE_NEUTRAL && !search->pack->referenced ) {
continue;
}
serverPaks.Append( search->pack );
if ( serverPaks.Num() >= MAX_PURE_PAKS ) {
common->FatalError( "MAX_PURE_PAKS ( %d ) exceeded\n", MAX_PURE_PAKS );
}
}
if ( fs_debug.GetBool() ) {
idStr checks;
for ( i = 0; i < serverPaks.Num(); i++ ) {
checks += va( "%x ", serverPaks[ i ]->checksum );
}
common->Printf( "set pure list - %d paks ( %s)\n", serverPaks.Num(), checks.c_str() );
}
}
/*
=====================
idFileSystemLocal::UpdateGamePakChecksums
=====================
*/
bool idFileSystemLocal::UpdateGamePakChecksums( void ) {
searchpath_t *search;
fileInPack_t *pakFile;
int confHash;
idFile *confFile;
char *buf;
idLexer *lexConf;
idToken token;
int id;
confHash = HashFileName( BINARY_CONFIG );
memset( gamePakForOS, 0, sizeof( gamePakForOS ) );
for ( search = searchPaths; search; search = search->next ) {
if ( !search->pack ) {
continue;
}
search->pack->binary = BINARY_NO;
for ( pakFile = search->pack->hashTable[confHash]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, BINARY_CONFIG ) ) {
search->pack->binary = BINARY_YES;
confFile = ReadFileFromZip( search->pack, pakFile, BINARY_CONFIG );
buf = new char[ confFile->Length() + 1 ];
confFile->Read( (void *)buf, confFile->Length() );
buf[ confFile->Length() ] = '\0';
lexConf = new idLexer( buf, confFile->Length(), confFile->GetFullPath() );
while ( lexConf->ReadToken( &token ) ) {
if ( token.IsNumeric() ) {
id = atoi( token );
if ( id < MAX_GAME_OS && !gamePakForOS[ id ] ) {
if ( fs_debug.GetBool() ) {
common->Printf( "Adding game pak checksum for OS %d: %s 0x%x\n", id, confFile->GetFullPath(), search->pack->checksum );
}
gamePakForOS[ id ] = search->pack->checksum;
}
}
}
CloseFile( confFile );
delete lexConf;
delete[] buf;
}
}
}
// some sanity checks on the game code references
// make sure that at least the local OS got a pure reference
if ( !gamePakForOS[ BUILD_OS_ID ] ) {
common->Warning( "No game code pak reference found for the local OS" );
return false;
}
if ( !cvarSystem->GetCVarBool( "net_serverAllowServerMod" ) &&
gamePakChecksum != gamePakForOS[ BUILD_OS_ID ] ) {
common->Warning( "The current game code doesn't match pak files (net_serverAllowServerMod is off)" );
return false;
}
return true;
}
/*
=====================
idFileSystemLocal::GetPackForChecksum
=====================
*/
pack_t* idFileSystemLocal::GetPackForChecksum( int checksum, bool searchAddons ) {
searchpath_t *search;
for ( search = searchPaths; search; search = search->next ) {
if ( !search->pack ) {
continue;
}
if ( search->pack->checksum == checksum ) {
return search->pack;
}
}
if ( searchAddons ) {
for ( search = addonPaks; search; search = search->next ) {
assert( search->pack && search->pack->addon );
if ( search->pack->checksum == checksum ) {
return search->pack;
}
}
}
return NULL;
}
/*
===============
idFileSystemLocal::ValidateDownloadPakForChecksum
===============
*/
int idFileSystemLocal::ValidateDownloadPakForChecksum( int checksum, char path[ MAX_STRING_CHARS ], bool isBinary ) {
int i;
idStrList testList;
idStr name;
idStr relativePath;
bool pakBinary;
pack_t *pak = GetPackForChecksum( checksum );
if ( !pak ) {
return 0;
}
// validate this pak for a potential download
// ignore pak*.pk4 for download. those are reserved to distribution and cannot be downloaded
name = pak->pakFilename;
name.StripPath();
if ( strstr( name.c_str(), "pak" ) == name.c_str() ) {
common->DPrintf( "%s is not a donwloadable pak\n", pak->pakFilename.c_str() );
return 0;
}
// check the binary
// a pure server sets the binary flag when starting the game
assert( pak->binary != BINARY_UNKNOWN );
pakBinary = ( pak->binary == BINARY_YES ) ? true : false;
if ( isBinary != pakBinary ) {
common->DPrintf( "%s binary flag mismatch\n", pak->pakFilename.c_str() );
return 0;
}
// extract a path that includes the fs_game: != OSPathToRelativePath
testList.Append( fs_savepath.GetString() );
testList.Append( fs_devpath.GetString() );
testList.Append( fs_basepath.GetString() );
testList.Append( fs_cdpath.GetString() );
for ( i = 0; i < testList.Num(); i ++ ) {
if ( testList[ i ].Length() && !testList[ i ].Icmpn( pak->pakFilename, testList[ i ].Length() ) ) {
relativePath = pak->pakFilename.c_str() + testList[ i ].Length() + 1;
break;
}
}
if ( i == testList.Num() ) {
common->Warning( "idFileSystem::ValidateDownloadPak: failed to extract relative path for %s", pak->pakFilename.c_str() );
return 0;
}
idStr::Copynz( path, relativePath, MAX_STRING_CHARS );
return pak->length;
}
/*
=====================
idFileSystemLocal::ClearPureChecksums
=====================
*/
void idFileSystemLocal::ClearPureChecksums( void ) {
common->DPrintf( "Cleared pure server lock\n" );
serverPaks.Clear();
}
/*
=====================
idFileSystemLocal::SetPureServerChecksums
set the pure paks according to what the server asks
if that's not possible, identify why and build an answer
can be:
loadedFileFromDir - some files were loaded from directories instead of paks (a restart in pure pak-only is required)
missing/wrong checksums - some pak files would need to be installed/updated (downloaded for instance)
some pak files currently referenced are not referenced by the server
wrong order - if the pak order doesn't match, means some stuff could have been loaded from somewhere else
server referenced files are prepended to the list if possible ( that doesn't break pureness )
DLL:
the checksum of the pak containing the DLL is maintained seperately, the server can send different replies by OS
=====================
*/
fsPureReply_t idFileSystemLocal::SetPureServerChecksums( const int pureChecksums[ MAX_PURE_PAKS ], int _gamePakChecksum, int missingChecksums[ MAX_PURE_PAKS ], int *missingGamePakChecksum ) {
pack_t *pack;
int i, j, imissing;
bool success = true;
bool canPrepend = true;
char dllName[MAX_OSPATH];
int dllHash;
fileInPack_t * pakFile;
sys->DLL_GetFileName( "game", dllName, MAX_OSPATH );
dllHash = HashFileName( dllName );
imissing = 0;
missingChecksums[ 0 ] = 0;
assert( missingGamePakChecksum );
*missingGamePakChecksum = 0;
if ( pureChecksums[ 0 ] == 0 ) {
ClearPureChecksums();
return PURE_OK;
}
if ( !serverPaks.Num() ) {
// there was no pure lockdown yet - lock to what we already have
UpdatePureServerChecksums();
}
i = 0; j = 0;
while ( pureChecksums[ i ] ) {
if ( j < serverPaks.Num() && serverPaks[ j ]->checksum == pureChecksums[ i ] ) {
canPrepend = false; // once you start matching into the list there is no prepending anymore
i++; j++; // the pak is matched, is in the right order, continue..
} else {
pack = GetPackForChecksum( pureChecksums[ i ], true );
if ( pack && pack->addon && !pack->addon_search ) {
// this is an addon pack, and it's not on our current search list
// setting success to false meaning that a restart including this addon is required
if ( fs_debug.GetBool() ) {
common->Printf( "pak %s checksumed 0x%x is on addon list. Restart required.\n", pack->pakFilename.c_str(), pack->checksum );
}
success = false;
}
if ( pack && pack->isNew ) {
// that's a downloaded pack, we will need to restart
if ( fs_debug.GetBool() ) {
common->Printf( "pak %s checksumed 0x%x is a newly downloaded file. Restart required.\n", pack->pakFilename.c_str(), pack->checksum );
}
success = false;
}
if ( pack ) {
if ( canPrepend ) {
// we still have a chance
if ( fs_debug.GetBool() ) {
common->Printf( "prepend pak %s checksumed 0x%x at index %d\n", pack->pakFilename.c_str(), pack->checksum, j );
}
// NOTE: there is a light possibility this adds at the end of the list if UpdatePureServerChecksums didn't set anything
serverPaks.Insert( pack, j );
i++; j++; // continue..
} else {
success = false;
if ( fs_debug.GetBool() ) {
// verbose the situation
if ( serverPaks.Find( pack ) ) {
common->Printf( "pak %s checksumed 0x%x is in the pure list at wrong index. Current index is %d, found at %d\n", pack->pakFilename.c_str(), pack->checksum, j, serverPaks.FindIndex( pack ) );
} else {
common->Printf( "pak %s checksumed 0x%x can't be added to pure list because of search order\n", pack->pakFilename.c_str(), pack->checksum );
}
}
i++; // advance server checksums only
}
} else {
// didn't find a matching checksum
success = false;
missingChecksums[ imissing++ ] = pureChecksums[ i ];
missingChecksums[ imissing ] = 0;
if ( fs_debug.GetBool() ) {
common->Printf( "checksum not found - 0x%x\n", pureChecksums[ i ] );
}
i++; // advance the server checksums only
}
}
}
while ( j < serverPaks.Num() ) {
success = false; // just in case some extra pak files are referenced at the end of our local list
if ( fs_debug.GetBool() ) {
common->Printf( "pak %s checksumed 0x%x is an extra reference at the end of local pure list\n", serverPaks[ j ]->pakFilename.c_str(), serverPaks[ j ]->checksum );
}
j++;
}
// DLL checksuming
if ( !_gamePakChecksum ) {
// server doesn't have knowledge of code we can use ( OS issue )
return PURE_NODLL;
}
assert( gameDLLChecksum );
#if ID_FAKE_PURE
gamePakChecksum = _gamePakChecksum;
#endif
if ( _gamePakChecksum != gamePakChecksum ) {
// current DLL is wrong, search for a pak with the approriate checksum
// ( search all paks, the pure list is not relevant here )
pack = GetPackForChecksum( _gamePakChecksum );
if ( !pack ) {
if ( fs_debug.GetBool() ) {
common->Printf( "missing the game code pak ( 0x%x )\n", _gamePakChecksum );
}
// if there are other paks missing they have also been marked above
*missingGamePakChecksum = _gamePakChecksum;
return PURE_MISSING;
}
// if assets paks are missing, don't try any of the DLL restart / NODLL
if ( imissing ) {
return PURE_MISSING;
}
// we have a matching pak
if ( fs_debug.GetBool() ) {
common->Printf( "server's game code pak candidate is '%s' ( 0x%x )\n", pack->pakFilename.c_str(), pack->checksum );
}
// make sure there is a valid DLL for us
if ( pack->hashTable[ dllHash ] ) {
for ( pakFile = pack->hashTable[ dllHash ]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, dllName ) ) {
gamePakChecksum = _gamePakChecksum; // this will be used to extract the DLL in pure mode FindDLL
return PURE_RESTART;
}
}
}
common->Warning( "media is misconfigured. server claims pak '%s' ( 0x%x ) has media for us, but '%s' is not found\n", pack->pakFilename.c_str(), pack->checksum, dllName );
return PURE_NODLL;
}
// we reply to missing after DLL check so it can be part of the list
if ( imissing ) {
return PURE_MISSING;
}
// one last check
if ( loadedFileFromDir ) {
success = false;
if ( fs_debug.GetBool() ) {
common->Printf( "SetPureServerChecksums: there are files loaded from dir\n" );
}
}
return ( success ? PURE_OK : PURE_RESTART );
}
/*
=====================
idFileSystemLocal::GetPureServerChecksums
=====================
*/
void idFileSystemLocal::GetPureServerChecksums( int checksums[ MAX_PURE_PAKS ], int OS, int *_gamePakChecksum ) {
int i;
for ( i = 0; i < serverPaks.Num(); i++ ) {
checksums[ i ] = serverPaks[ i ]->checksum;
}
checksums[ i ] = 0;
if ( _gamePakChecksum ) {
if ( OS >= 0 ) {
*_gamePakChecksum = gamePakForOS[ OS ];
} else {
*_gamePakChecksum = gamePakChecksum;
}
}
}
/*
=====================
idFileSystemLocal::SetRestartChecksums
=====================
*/
void idFileSystemLocal::SetRestartChecksums( const int pureChecksums[ MAX_PURE_PAKS ], int gamePakChecksum ) {
int i;
pack_t *pack;
restartChecksums.Clear();
i = 0;
while ( pureChecksums[ i ] ) {
pack = GetPackForChecksum( pureChecksums[ i ], true );
if ( !pack ) {
common->FatalError( "SetRestartChecksums failed: no pak for checksum 0x%x\n", pureChecksums[i] );
}
if ( pack->addon && addonChecksums.FindIndex( pack->checksum ) < 0 ) {
// can't mark it pure if we're not even gonna search it :-)
addonChecksums.Append( pack->checksum );
}
restartChecksums.Append( pureChecksums[ i ] );
i++;
}
restartGamePakChecksum = gamePakChecksum;
}
/*
================
idFileSystemLocal::Init
Called only at inital startup, not when the filesystem
is resetting due to a game change
================
*/
void idFileSystemLocal::Init( void ) {
// allow command line parms to override our defaults
// we have to specially handle this, because normal command
// line variable sets don't happen until after the filesystem
// has already been initialized
common->StartupVariable( "fs_basepath", false );
common->StartupVariable( "fs_savepath", false );
common->StartupVariable( "fs_cdpath", false );
common->StartupVariable( "fs_devpath", false );
common->StartupVariable( "fs_game", false );
common->StartupVariable( "fs_game_base", false );
common->StartupVariable( "fs_copyfiles", false );
common->StartupVariable( "fs_restrict", false );
common->StartupVariable( "fs_searchAddons", false );
#if !ID_ALLOW_D3XP
if ( fs_game.GetString()[0] && !idStr::Icmp( fs_game.GetString(), "d3xp" ) ) {
fs_game.SetString( NULL );
}
if ( fs_game_base.GetString()[0] && !idStr::Icmp( fs_game_base.GetString(), "d3xp" ) ) {
fs_game_base.SetString( NULL );
}
#endif
if ( fs_basepath.GetString()[0] == '\0' ) {
fs_basepath.SetString( Sys_DefaultBasePath() );
}
if ( fs_savepath.GetString()[0] == '\0' ) {
fs_savepath.SetString( Sys_DefaultSavePath() );
}
if ( fs_cdpath.GetString()[0] == '\0' ) {
fs_cdpath.SetString( Sys_DefaultCDPath() );
}
if ( fs_devpath.GetString()[0] == '\0' ) {
fs_devpath.SetString( fs_cdpath.GetString()[0] ? fs_cdpath.GetString() : fs_basepath.GetString() );
}
// try to start up normally
Startup( );
// see if we are going to allow add-ons
SetRestrictions();
// spawn a thread to handle background file reads
StartBackgroundDownloadThread();
// if we can't find default.cfg, assume that the paths are
// busted and error out now, rather than getting an unreadable
// graphics screen when the font fails to load
// Dedicated servers can run with no outside files at all
if ( ReadFile( "default.cfg", NULL, NULL ) <= 0 ) {
common->FatalError( "Couldn't load default.cfg" );
}
}
/*
================
idFileSystemLocal::Restart
================
*/
void idFileSystemLocal::Restart( void ) {
// free anything we currently have loaded
Shutdown( true );
Startup( );
// see if we are going to allow add-ons
SetRestrictions();
// if we can't find default.cfg, assume that the paths are
// busted and error out now, rather than getting an unreadable
// graphics screen when the font fails to load
if ( ReadFile( "default.cfg", NULL, NULL ) <= 0 ) {
common->FatalError( "Couldn't load default.cfg" );
}
}
/*
================
idFileSystemLocal::Shutdown
Frees all resources and closes all files
================
*/
void idFileSystemLocal::Shutdown( bool reloading ) {
searchpath_t *sp, *next, *loop;
gameFolder.Clear();
serverPaks.Clear();
if ( !reloading ) {
restartChecksums.Clear();
addonChecksums.Clear();
}
loadedFileFromDir = false;
gameDLLChecksum = 0;
gamePakChecksum = 0;
ClearDirCache();
// free everything - loop through searchPaths and addonPaks
for ( loop = searchPaths; loop; loop == searchPaths ? loop = addonPaks : loop = NULL ) {
for ( sp = loop; sp; sp = next ) {
next = sp->next;
if ( sp->pack ) {
unzClose( sp->pack->handle );
delete [] sp->pack->buildBuffer;
if ( sp->pack->addon_info ) {
sp->pack->addon_info->mapDecls.DeleteContents( true );
delete sp->pack->addon_info;
}
delete sp->pack;
}
if ( sp->dir ) {
delete sp->dir;
}
delete sp;
}
}
// any FS_ calls will now be an error until reinitialized
searchPaths = NULL;
addonPaks = NULL;
cmdSystem->RemoveCommand( "path" );
cmdSystem->RemoveCommand( "dir" );
cmdSystem->RemoveCommand( "dirtree" );
cmdSystem->RemoveCommand( "touchFile" );
mapDict.Clear();
}
/*
================
idFileSystemLocal::IsInitialized
================
*/
bool idFileSystemLocal::IsInitialized( void ) const {
return ( searchPaths != NULL );
}
/*
=================================================================================
Opening files
=================================================================================
*/
/*
===========
idFileSystemLocal::FileAllowedFromDir
===========
*/
bool idFileSystemLocal::FileAllowedFromDir( const char *path ) {
unsigned int l;
l = strlen( path );
if ( !strcmp( path + l - 4, ".cfg" ) // for config files
|| !strcmp( path + l - 4, ".dat" ) // for journal files
|| !strcmp( path + l - 4, ".dll" ) // dynamic modules are handled a different way for pure
|| !strcmp( path + l - 3, ".so" )
|| ( l > 6 && !strcmp( path + l - 6, ".dylib" ) )
|| ( l > 10 && !strcmp( path + l - 10, ".scriptcfg" ) ) // configuration script, such as map cycle
#if ID_PURE_ALLOWDDS
|| !strcmp( path + l - 4, ".dds" )
#endif
) {
// note: cd and xp keys, as well as config.spec are opened through an explicit OS path and don't hit this
return true;
}
// savegames
if ( strstr( path, "savegames" ) == path &&
( !strcmp( path + l - 4, ".tga" ) || !strcmp( path + l -4, ".txt" ) || !strcmp( path + l - 5, ".save" ) ) ) {
return true;
}
// screen shots
if ( strstr( path, "screenshots" ) == path && !strcmp( path + l - 4, ".tga" ) ) {
return true;
}
// objective tgas
if ( strstr( path, "maps/game" ) == path &&
!strcmp( path + l - 4, ".tga" ) ) {
return true;
}
// splash screens extracted from addons
if ( strstr( path, "guis/assets/splash/addon" ) == path &&
!strcmp( path + l -4, ".tga" ) ) {
return true;
}
return false;
}
/*
===========
idFileSystemLocal::GetPackStatus
===========
*/
pureStatus_t idFileSystemLocal::GetPackStatus( pack_t *pak ) {
int i, l, hashindex;
fileInPack_t *file;
bool abrt;
idStr name;
if ( pak->pureStatus != PURE_UNKNOWN ) {
return pak->pureStatus;
}
// check content for PURE_NEVER
i = 0;
file = pak->buildBuffer;
for ( hashindex = 0; hashindex < FILE_HASH_SIZE; hashindex++ ) {
abrt = false;
file = pak->hashTable[ hashindex ];
while ( file ) {
abrt = true;
l = file->name.Length();
for ( int j = 0; pureExclusions[j].func != NULL; j++ ) {
if ( pureExclusions[j].func( pureExclusions[j], l, file->name ) ) {
abrt = false;
break;
}
}
if ( abrt ) {
common->DPrintf( "pak '%s' candidate for pure: '%s'\n", pak->pakFilename.c_str(), file->name.c_str() );
break;
}
file = file->next;
i++;
}
if ( abrt ) {
break;
}
}
if ( i == pak->numfiles ) {
pak->pureStatus = PURE_NEVER;
return PURE_NEVER;
}
// check pak name for PURE_ALWAYS
pak->pakFilename.ExtractFileName( name );
if ( !name.IcmpPrefixPath( "pak" ) ) {
pak->pureStatus = PURE_ALWAYS;
return PURE_ALWAYS;
}
pak->pureStatus = PURE_NEUTRAL;
return PURE_NEUTRAL;
}
/*
===========
idFileSystemLocal::ReadFileFromZip
===========
*/
idFile_InZip * idFileSystemLocal::ReadFileFromZip( pack_t *pak, fileInPack_t *pakFile, const char *relativePath ) {
unz_s * zfi;
FILE * fp;
idFile_InZip *file = new idFile_InZip();
// open a new file on the pakfile
file->z = unzReOpen( pak->pakFilename, pak->handle );
if ( file->z == NULL ) {
common->FatalError( "Couldn't reopen %s", pak->pakFilename.c_str() );
}
file->name = relativePath;
file->fullPath = pak->pakFilename + "/" + relativePath;
zfi = (unz_s *)file->z;
// in case the file was new
fp = zfi->file;
// set the file position in the zip file (also sets the current file info)
unzSetCurrentFileInfoPosition( pak->handle, pakFile->pos );
// copy the file info into the unzip structure
memcpy( zfi, pak->handle, sizeof(unz_s) );
// we copy this back into the structure
zfi->file = fp;
// open the file in the zip
unzOpenCurrentFile( file->z );
file->zipFilePos = pakFile->pos;
file->fileSize = zfi->cur_file_info.uncompressed_size;
return file;
}
/*
===========
idFileSystemLocal::OpenFileReadFlags
Finds the file in the search path, following search flag recommendations
Returns filesize and an open FILE pointer.
Used for streaming data out of either a
separate file or a ZIP file.
===========
*/
idFile *idFileSystemLocal::OpenFileReadFlags( const char *relativePath, int searchFlags, pack_t **foundInPak, bool allowCopyFiles, const char* gamedir ) {
searchpath_t * search;
idStr netpath;
pack_t * pak;
fileInPack_t * pakFile;
directory_t * dir;
long hash;
FILE * fp;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( !relativePath ) {
common->FatalError( "idFileSystemLocal::OpenFileRead: NULL 'relativePath' parameter passed\n" );
}
if ( foundInPak ) {
*foundInPak = NULL;
}
// qpaths are not supposed to have a leading slash
if ( relativePath[0] == '/' || relativePath[0] == '\\' ) {
relativePath++;
}
// make absolutely sure that it can't back up the path.
// The searchpaths do guarantee that something will always
// be prepended, so we don't need to worry about "c:" or "//limbo"
if ( strstr( relativePath, ".." ) || strstr( relativePath, "::" ) ) {
return NULL;
}
// edge case
if ( relativePath[0] == '\0' ) {
return NULL;
}
// make sure the doomkey file is only readable by game at initialization
// any other time the key should only be accessed in memory using the provided functions
if( common->IsInitialized() && ( idStr::Icmp( relativePath, CDKEY_FILE ) == 0 || idStr::Icmp( relativePath, XPKEY_FILE ) == 0 ) ) {
return NULL;
}
//
// search through the path, one element at a time
//
hash = HashFileName( relativePath );
for ( search = searchPaths; search; search = search->next ) {
if ( search->dir && ( searchFlags & FSFLAG_SEARCH_DIRS ) ) {
// check a file in the directory tree
// if we are running restricted, the only files we
// will allow to come from the directory are .cfg files
if ( fs_restrict.GetBool() || serverPaks.Num() ) {
if ( !FileAllowedFromDir( relativePath ) ) {
continue;
}
}
dir = search->dir;
if(gamedir && strlen(gamedir)) {
if(dir->gamedir != gamedir) {
continue;
}
}
netpath = BuildOSPath( dir->path, dir->gamedir, relativePath );
fp = OpenOSFileCorrectName( netpath, "rb" );
if ( !fp ) {
continue;
}
idFile_Permanent *file = new idFile_Permanent();
file->o = fp;
file->name = relativePath;
file->fullPath = netpath;
file->mode = ( 1 << FS_READ );
file->fileSize = DirectFileLength( file->o );
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystem::OpenFileRead: %s (found in '%s/%s')\n", relativePath, dir->path.c_str(), dir->gamedir.c_str() );
}
if ( !loadedFileFromDir && !FileAllowedFromDir( relativePath ) ) {
if ( restartChecksums.Num() ) {
common->FatalError( "'%s' loaded from directory: Failed to restart with pure mode restrictions for server connect", relativePath );
}
common->DPrintf( "filesystem: switching to pure mode will require a restart. '%s' loaded from directory.\n", relativePath );
loadedFileFromDir = true;
}
// if fs_copyfiles is set
if ( allowCopyFiles && fs_copyfiles.GetInteger() ) {
idStr copypath;
idStr name;
copypath = BuildOSPath( fs_savepath.GetString(), dir->gamedir, relativePath );
netpath.ExtractFileName( name );
copypath.StripFilename( );
copypath += PATHSEPERATOR_STR;
copypath += name;
bool isFromCDPath = !dir->path.Cmp( fs_cdpath.GetString() );
bool isFromSavePath = !dir->path.Cmp( fs_savepath.GetString() );
bool isFromBasePath = !dir->path.Cmp( fs_basepath.GetString() );
switch ( fs_copyfiles.GetInteger() ) {
case 1:
// copy from cd path only
if ( isFromCDPath ) {
CopyFile( netpath, copypath );
}
break;
case 2:
// from cd path + timestamps
if ( isFromCDPath ) {
CopyFile( netpath, copypath );
} else if ( isFromSavePath || isFromBasePath ) {
idStr sourcepath;
sourcepath = BuildOSPath( fs_cdpath.GetString(), dir->gamedir, relativePath );
FILE *f1 = OpenOSFile( sourcepath, "r" );
if ( f1 ) {
ID_TIME_T t1 = Sys_FileTimeStamp( f1 );
fclose( f1 );
FILE *f2 = OpenOSFile( copypath, "r" );
if ( f2 ) {
ID_TIME_T t2 = Sys_FileTimeStamp( f2 );
fclose( f2 );
if ( t1 > t2 ) {
CopyFile( sourcepath, copypath );
}
}
}
}
break;
case 3:
if ( isFromCDPath || isFromBasePath ) {
CopyFile( netpath, copypath );
}
break;
case 4:
if ( isFromCDPath && !isFromBasePath ) {
CopyFile( netpath, copypath );
}
break;
}
}
return file;
} else if ( search->pack && ( searchFlags & FSFLAG_SEARCH_PAKS ) ) {
if ( !search->pack->hashTable[hash] ) {
continue;
}
// disregard if it doesn't match one of the allowed pure pak files
if ( serverPaks.Num() ) {
GetPackStatus( search->pack );
if ( search->pack->pureStatus != PURE_NEVER && !serverPaks.Find( search->pack ) ) {
continue; // not on the pure server pak list
}
}
// look through all the pak file elements
pak = search->pack;
if ( searchFlags & FSFLAG_BINARY_ONLY ) {
// make sure this pak is tagged as a binary file
if ( pak->binary == BINARY_UNKNOWN ) {
int confHash;
fileInPack_t *pakFile;
confHash = HashFileName( BINARY_CONFIG );
pak->binary = BINARY_NO;
for ( pakFile = search->pack->hashTable[confHash]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, BINARY_CONFIG ) ) {
pak->binary = BINARY_YES;
break;
}
}
}
if ( pak->binary == BINARY_NO ) {
continue; // not a binary pak, skip
}
}
for ( pakFile = pak->hashTable[hash]; pakFile; pakFile = pakFile->next ) {
// case and separator insensitive comparisons
if ( !FilenameCompare( pakFile->name, relativePath ) ) {
idFile_InZip *file = ReadFileFromZip( pak, pakFile, relativePath );
if ( foundInPak ) {
*foundInPak = pak;
}
if ( !pak->referenced && !( searchFlags & FSFLAG_PURE_NOREF ) ) {
// mark this pak referenced
if ( fs_debug.GetInteger( ) ) {
common->Printf( "idFileSystem::OpenFileRead: %s -> adding %s to referenced paks\n", relativePath, pak->pakFilename.c_str() );
}
pak->referenced = true;
}
if ( fs_debug.GetInteger( ) ) {
common->Printf( "idFileSystem::OpenFileRead: %s (found in '%s')\n", relativePath, pak->pakFilename.c_str() );
}
return file;
}
}
}
}
if ( searchFlags & FSFLAG_SEARCH_ADDONS ) {
for ( search = addonPaks; search; search = search->next ) {
assert( search->pack );
fileInPack_t *pakFile;
pak = search->pack;
for ( pakFile = pak->hashTable[hash]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, relativePath ) ) {
idFile_InZip *file = ReadFileFromZip( pak, pakFile, relativePath );
if ( foundInPak ) {
*foundInPak = pak;
}
// we don't toggle pure on paks found in addons - they can't be used without a reloadEngine anyway
if ( fs_debug.GetInteger( ) ) {
common->Printf( "idFileSystem::OpenFileRead: %s (found in addon pk4 '%s')\n", relativePath, search->pack->pakFilename.c_str() );
}
return file;
}
}
}
}
if ( fs_debug.GetInteger( ) ) {
common->Printf( "Can't find %s\n", relativePath );
}
return NULL;
}
/*
===========
idFileSystemLocal::OpenFileRead
===========
*/
idFile *idFileSystemLocal::OpenFileRead( const char *relativePath, bool allowCopyFiles, const char* gamedir ) {
return OpenFileReadFlags( relativePath, FSFLAG_SEARCH_DIRS | FSFLAG_SEARCH_PAKS, NULL, allowCopyFiles, gamedir );
}
/*
===========
idFileSystemLocal::OpenFileWrite
===========
*/
idFile *idFileSystemLocal::OpenFileWrite( const char *relativePath, const char *basePath ) {
const char *path;
idStr OSpath;
idFile_Permanent *f;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
path = cvarSystem->GetCVarString( basePath );
if ( !path[0] ) {
path = fs_savepath.GetString();
}
OSpath = BuildOSPath( path, gameFolder, relativePath );
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystem::OpenFileWrite: %s\n", OSpath.c_str() );
}
// if the dir we are writing to is in our current list, it will be outdated
// so just flush everything
ClearDirCache();
common->DPrintf( "writing to: %s\n", OSpath.c_str() );
CreateOSPath( OSpath );
f = new idFile_Permanent();
f->o = OpenOSFile( OSpath, "wb" );
if ( !f->o ) {
delete f;
return NULL;
}
f->name = relativePath;
f->fullPath = OSpath;
f->mode = ( 1 << FS_WRITE );
f->handleSync = false;
f->fileSize = 0;
return f;
}
/*
===========
idFileSystemLocal::OpenExplicitFileRead
===========
*/
idFile *idFileSystemLocal::OpenExplicitFileRead( const char *OSPath ) {
idFile_Permanent *f;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystem::OpenExplicitFileRead: %s\n", OSPath );
}
common->DPrintf( "idFileSystem::OpenExplicitFileRead - reading from: %s\n", OSPath );
f = new idFile_Permanent();
f->o = OpenOSFile( OSPath, "rb" );
if ( !f->o ) {
delete f;
return NULL;
}
f->name = OSPath;
f->fullPath = OSPath;
f->mode = ( 1 << FS_READ );
f->handleSync = false;
f->fileSize = DirectFileLength( f->o );
return f;
}
/*
===========
idFileSystemLocal::OpenExplicitFileWrite
===========
*/
idFile *idFileSystemLocal::OpenExplicitFileWrite( const char *OSPath ) {
idFile_Permanent *f;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystem::OpenExplicitFileWrite: %s\n", OSPath );
}
common->DPrintf( "writing to: %s\n", OSPath );
CreateOSPath( OSPath );
f = new idFile_Permanent();
f->o = OpenOSFile( OSPath, "wb" );
if ( !f->o ) {
delete f;
return NULL;
}
f->name = OSPath;
f->fullPath = OSPath;
f->mode = ( 1 << FS_WRITE );
f->handleSync = false;
f->fileSize = 0;
return f;
}
/*
===========
idFileSystemLocal::OpenFileAppend
===========
*/
idFile *idFileSystemLocal::OpenFileAppend( const char *relativePath, bool sync, const char *basePath ) {
const char *path;
idStr OSpath;
idFile_Permanent *f;
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
path = cvarSystem->GetCVarString( basePath );
if ( !path[0] ) {
path = fs_savepath.GetString();
}
OSpath = BuildOSPath( path, gameFolder, relativePath );
CreateOSPath( OSpath );
if ( fs_debug.GetInteger() ) {
common->Printf( "idFileSystem::OpenFileAppend: %s\n", OSpath.c_str() );
}
f = new idFile_Permanent();
f->o = OpenOSFile( OSpath, "ab" );
if ( !f->o ) {
delete f;
return NULL;
}
f->name = relativePath;
f->fullPath = OSpath;
f->mode = ( 1 << FS_WRITE ) + ( 1 << FS_APPEND );
f->handleSync = sync;
f->fileSize = DirectFileLength( f->o );
return f;
}
/*
================
idFileSystemLocal::OpenFileByMode
================
*/
idFile *idFileSystemLocal::OpenFileByMode( const char *relativePath, fsMode_t mode ) {
if ( mode == FS_READ ) {
return OpenFileRead( relativePath );
}
if ( mode == FS_WRITE ) {
return OpenFileWrite( relativePath );
}
if ( mode == FS_APPEND ) {
return OpenFileAppend( relativePath, true );
}
common->FatalError( "idFileSystemLocal::OpenFileByMode: bad mode" );
return NULL;
}
/*
==============
idFileSystemLocal::CloseFile
==============
*/
void idFileSystemLocal::CloseFile( idFile *f ) {
if ( !searchPaths ) {
common->FatalError( "Filesystem call made without initialization\n" );
}
delete f;
}
/*
=================================================================================
back ground loading
=================================================================================
*/
/*
=================
idFileSystemLocal::CurlWriteFunction
=================
*/
size_t idFileSystemLocal::CurlWriteFunction( void *ptr, size_t size, size_t nmemb, void *stream ) {
backgroundDownload_t *bgl = (backgroundDownload_t *)stream;
if ( !bgl->f ) {
return size * nmemb;
}
#ifdef _WIN32
return _write( _fileno(static_cast<idFile_Permanent*>(bgl->f)->GetFilePtr()), ptr, size * nmemb );
#else
return fwrite( ptr, size, nmemb, static_cast<idFile_Permanent*>(bgl->f)->GetFilePtr() );
#endif
}
/*
=================
idFileSystemLocal::CurlProgressFunction
=================
*/
int idFileSystemLocal::CurlProgressFunction( void *clientp, double dltotal, double dlnow, double ultotal, double ulnow ) {
backgroundDownload_t *bgl = (backgroundDownload_t *)clientp;
if ( bgl->url.status == DL_ABORTING ) {
return 1;
}
bgl->url.dltotal = dltotal;
bgl->url.dlnow = dlnow;
return 0;
}
/*
===================
BackgroundDownload
Reads part of a file from a background thread.
===================
*/
dword BackgroundDownloadThread( void *parms ) {
#if ENABLE_FP_EXCEPTIONS
FPExceptionEnabler enabled(_EM_UNDERFLOW | _EM_OVERFLOW | _EM_ZERODIVIDE | _EM_INVALID);
#endif
while( 1 ) {
Sys_EnterCriticalSection();
backgroundDownload_t *bgl = fileSystemLocal.backgroundDownloads;
if ( !bgl ) {
Sys_LeaveCriticalSection();
Sys_WaitForEvent();
continue;
}
// remove this from the list
fileSystemLocal.backgroundDownloads = bgl->next;
Sys_LeaveCriticalSection();
bgl->next = NULL;
if ( bgl->opcode == DLTYPE_FILE ) {
// use the low level read function, because fread may allocate memory
#if defined(WIN32)
_read( _fileno(static_cast<idFile_Permanent*>(bgl->f)->GetFilePtr()), bgl->file.buffer, bgl->file.length );
#else
fread( bgl->file.buffer, bgl->file.length, 1, static_cast<idFile_Permanent*>(bgl->f)->GetFilePtr() );
#endif
bgl->completed = true;
} else {
#if ID_ENABLE_CURL
// DLTYPE_URL
// use a local buffer for curl error since the size define is local
char error_buf[ CURL_ERROR_SIZE ];
bgl->url.dlerror[ 0 ] = '\0';
CURL *session = curl_easy_init();
CURLcode ret;
if ( !session ) {
bgl->url.dlstatus = CURLE_FAILED_INIT;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_ERRORBUFFER, error_buf );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_URL, bgl->url.url.c_str() );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_FAILONERROR, 1 );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_WRITEFUNCTION, idFileSystemLocal::CurlWriteFunction );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_WRITEDATA, bgl );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_NOPROGRESS, 0 );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_PROGRESSFUNCTION, idFileSystemLocal::CurlProgressFunction );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
ret = curl_easy_setopt( session, CURLOPT_PROGRESSDATA, bgl );
if ( ret ) {
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
bgl->url.dlnow = 0;
bgl->url.dltotal = 0;
bgl->url.status = DL_INPROGRESS;
ret = curl_easy_perform( session );
if ( ret ) {
Sys_Printf( "curl_easy_perform failed: %s\n", error_buf );
idStr::Copynz( bgl->url.dlerror, error_buf, MAX_STRING_CHARS );
bgl->url.dlstatus = ret;
bgl->url.status = DL_FAILED;
bgl->completed = true;
continue;
}
bgl->url.status = DL_DONE;
bgl->completed = true;
#else
bgl->url.status = DL_FAILED;
bgl->completed = true;
#endif
}
}
return 0;
}
/*
=================
idFileSystemLocal::StartBackgroundReadThread
=================
*/
void idFileSystemLocal::StartBackgroundDownloadThread() {
if ( !backgroundThread.threadHandle ) {
Sys_CreateThread( (xthread_t)BackgroundDownloadThread, NULL, THREAD_NORMAL, backgroundThread, "backgroundDownload", g_threads, &g_thread_count );
if ( !backgroundThread.threadHandle ) {
common->Warning( "idFileSystemLocal::StartBackgroundDownloadThread: failed" );
}
} else {
common->Printf( "background thread already running\n" );
}
}
/*
=================
idFileSystemLocal::BackgroundDownload
=================
*/
void idFileSystemLocal::BackgroundDownload( backgroundDownload_t *bgl ) {
if ( bgl->opcode == DLTYPE_FILE ) {
if ( dynamic_cast<idFile_Permanent *>(bgl->f) ) {
// add the bgl to the background download list
Sys_EnterCriticalSection();
bgl->next = backgroundDownloads;
backgroundDownloads = bgl;
Sys_TriggerEvent();
Sys_LeaveCriticalSection();
} else {
// read zipped file directly
bgl->f->Seek( bgl->file.position, FS_SEEK_SET );
bgl->f->Read( bgl->file.buffer, bgl->file.length );
bgl->completed = true;
}
} else {
Sys_EnterCriticalSection();
bgl->next = backgroundDownloads;
backgroundDownloads = bgl;
Sys_TriggerEvent();
Sys_LeaveCriticalSection();
}
}
/*
=================
idFileSystemLocal::PerformingCopyFiles
=================
*/
bool idFileSystemLocal::PerformingCopyFiles( void ) const {
return fs_copyfiles.GetInteger() > 0;
}
/*
=================
idFileSystemLocal::FindPakForFileChecksum
=================
*/
pack_t *idFileSystemLocal::FindPakForFileChecksum( const char *relativePath, int findChecksum, bool bReference ) {
searchpath_t *search;
pack_t *pak;
fileInPack_t *pakFile;
int hash;
assert( !serverPaks.Num() );
hash = HashFileName( relativePath );
for ( search = searchPaths; search; search = search->next ) {
if ( search->pack && search->pack->hashTable[ hash ] ) {
pak = search->pack;
for ( pakFile = pak->hashTable[ hash ]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, relativePath ) ) {
idFile_InZip *file = ReadFileFromZip( pak, pakFile, relativePath );
if ( findChecksum == GetFileChecksum( file ) ) {
if ( fs_debug.GetBool() ) {
common->Printf( "found '%s' with checksum 0x%x in pak '%s'\n", relativePath, findChecksum, pak->pakFilename.c_str() );
}
if ( bReference ) {
pak->referenced = true;
// FIXME: use dependencies for pak references
}
CloseFile( file );
return pak;
} else if ( fs_debug.GetBool() ) {
common->Printf( "'%s' in pak '%s' has != checksum %x\n", relativePath, pak->pakFilename.c_str(), GetFileChecksum( file ) );
}
CloseFile( file );
}
}
}
}
if ( fs_debug.GetBool() ) {
common->Printf( "no pak file found for '%s' checksumed %x\n", relativePath, findChecksum );
}
return NULL;
}
/*
=================
idFileSystemLocal::GetFileChecksum
=================
*/
int idFileSystemLocal::GetFileChecksum( idFile *file ) {
int len, ret;
byte *buf;
file->Seek( 0, FS_SEEK_END );
len = file->Tell();
file->Seek( 0, FS_SEEK_SET );
buf = (byte *)Mem_Alloc( len );
if ( file->Read( buf, len ) != len ) {
common->FatalError( "Short read in idFileSystemLocal::GetFileChecksum()\n" );
}
ret = MD4_BlockChecksum( buf, len );
Mem_Free( buf );
return ret;
}
/*
=================
idFileSystemLocal::FindDLL
=================
*/
void idFileSystemLocal::FindDLL( const char *name, char _dllPath[ MAX_OSPATH ], bool updateChecksum ) {
idFile *dllFile = NULL;
char dllName[MAX_OSPATH];
idStr dllPath;
int dllHash;
pack_t *inPak;
pack_t *pak;
fileInPack_t *pakFile;
sys->DLL_GetFileName( name, dllName, MAX_OSPATH );
dllHash = HashFileName( dllName );
#if ID_FAKE_PURE
if ( 1 ) {
#else
if ( !serverPaks.Num() ) {
#endif
// from executable directory first - this is handy for developement
dllPath = Sys_EXEPath( );
dllPath.StripFilename( );
dllPath.AppendPath( dllName );
dllFile = OpenExplicitFileRead( dllPath );
}
if ( !dllFile ) {
if ( !serverPaks.Num() ) {
// not running in pure mode, try to extract from a pak file first
dllFile = OpenFileReadFlags( dllName, FSFLAG_SEARCH_PAKS | FSFLAG_PURE_NOREF | FSFLAG_BINARY_ONLY, &inPak );
if ( dllFile ) {
common->Printf( "found DLL in pak file: %s\n", dllFile->GetFullPath() );
dllPath = RelativePathToOSPath( dllName, "fs_savepath" );
CopyFile( dllFile, dllPath );
CloseFile( dllFile );
dllFile = OpenFileReadFlags( dllName, FSFLAG_SEARCH_DIRS );
if ( !dllFile ) {
common->Error( "DLL extraction to fs_savepath failed\n" );
} else if ( updateChecksum ) {
gameDLLChecksum = GetFileChecksum( dllFile );
gamePakChecksum = inPak->checksum;
updateChecksum = false; // don't try again below
}
} else {
// didn't find a source in a pak file, try in the directory
dllFile = OpenFileReadFlags( dllName, FSFLAG_SEARCH_DIRS );
if ( dllFile ) {
if ( updateChecksum ) {
gameDLLChecksum = GetFileChecksum( dllFile );
// see if we can mark a pak file
pak = FindPakForFileChecksum( dllName, gameDLLChecksum, false );
pak ? gamePakChecksum = pak->checksum : gamePakChecksum = 0;
updateChecksum = false;
}
}
}
} else {
// we are in pure mode. this path to be reached only for game DLL situations
// with a code pak checksum given by server
assert( gamePakChecksum );
assert( updateChecksum );
pak = GetPackForChecksum( gamePakChecksum );
if ( !pak ) {
// not supposed to happen, bug in pure code?
common->Warning( "FindDLL in pure mode: game pak not found ( 0x%x )\n", gamePakChecksum );
} else {
// extract and copy
for ( pakFile = pak->hashTable[dllHash]; pakFile; pakFile = pakFile->next ) {
if ( !FilenameCompare( pakFile->name, dllName ) ) {
dllFile = ReadFileFromZip( pak, pakFile, dllName );
common->Printf( "found DLL in game pak file: %s\n", pak->pakFilename.c_str() );
dllPath = RelativePathToOSPath( dllName, "fs_savepath" );
CopyFile( dllFile, dllPath );
CloseFile( dllFile );
dllFile = OpenFileReadFlags( dllName, FSFLAG_SEARCH_DIRS );
if ( !dllFile ) {
common->Error( "DLL extraction to fs_savepath failed\n" );
} else {
gameDLLChecksum = GetFileChecksum( dllFile );
updateChecksum = false; // don't try again below
}
}
}
}
}
}
if ( updateChecksum ) {
if ( dllFile ) {
gameDLLChecksum = GetFileChecksum( dllFile );
} else {
gameDLLChecksum = 0;
}
gamePakChecksum = 0;
}
if ( dllFile ) {
dllPath = dllFile->GetFullPath( );
CloseFile( dllFile );
dllFile = NULL;
} else {
dllPath = "";
}
idStr::snPrintf( _dllPath, MAX_OSPATH, dllPath.c_str() );
}
/*
================
idFileSystemLocal::ClearDirCache
================
*/
void idFileSystemLocal::ClearDirCache( void ) {
int i;
dir_cache_index = 0;
dir_cache_count = 0;
for( i = 0; i < MAX_CACHED_DIRS; i++ ) {
dir_cache[ i ].Clear();
}
}
/*
===============
idFileSystemLocal::HasD3XP
===============
*/
bool idFileSystemLocal::HasD3XP( void ) {
int i;
idStrList dirs, pk4s;
idStr gamepath;
if ( d3xp == -1 ) {
return false;
} else if ( d3xp == 1 ) {
return true;
}
#if 0
// check for a d3xp directory with a pk4 file
// copied over from ListMods - only looks in basepath
ListOSFiles( fs_basepath.GetString(), "/", dirs );
for ( i = 0; i < dirs.Num(); i++ ) {
if ( dirs[i].Icmp( "d3xp" ) == 0 ) {
gamepath = BuildOSPath( fs_basepath.GetString(), dirs[ i ], "" );
ListOSFiles( gamepath, ".pk4", pk4s );
if ( pk4s.Num() ) {
d3xp = 1;
return true;
}
}
}
#elif ID_ALLOW_D3XP
// check for d3xp's d3xp/pak000.pk4 in any search path
// checking wether the pak is loaded by checksum wouldn't be enough:
// we may have a different fs_game right now but still need to reply that it's installed
const char *search[4];
idFile *pakfile;
search[0] = fs_savepath.GetString();
search[1] = fs_devpath.GetString();
search[2] = fs_basepath.GetString();
search[3] = fs_cdpath.GetString();
for ( i = 0; i < 4; i++ ) {
pakfile = OpenExplicitFileRead( BuildOSPath( search[ i ], "d3xp", "pak000.pk4" ) );
if ( pakfile ) {
CloseFile( pakfile );
d3xp = 1;
return true;
}
}
#endif
#if ID_ALLOW_D3XP
// if we didn't find a pk4 file then the user might have unpacked so look for default.cfg file
// that's the old way mostly used during developement. don't think it hurts to leave it there
ListOSFiles( fs_basepath.GetString(), "/", dirs );
for ( i = 0; i < dirs.Num(); i++ ) {
if ( dirs[i].Icmp( "d3xp" ) == 0 ) {
gamepath = BuildOSPath( fs_savepath.GetString(), dirs[ i ], "default.cfg" );
idFile* cfg = OpenExplicitFileRead(gamepath);
if(cfg) {
CloseFile(cfg);
d3xp = 1;
return true;
}
}
}
#endif
d3xp = -1;
return false;
}
/*
===============
idFileSystemLocal::RunningD3XP
===============
*/
bool idFileSystemLocal::RunningD3XP( void ) {
// TODO: mark the checksum of the gold XP and check for it being referenced ( for double mod support )
// a simple fs_game check should be enough for now..
if ( !idStr::Icmp( fs_game.GetString(), "d3xp" ) ||
!idStr::Icmp( fs_game_base.GetString(), "d3xp" ) ) {
return true;
}
return false;
}
/*
===============
idFileSystemLocal::MakeTemporaryFile
===============
*/
idFile * idFileSystemLocal::MakeTemporaryFile( void ) {
FILE *f = tmpfile();
if ( !f ) {
common->Warning( "idFileSystem::MakeTemporaryFile failed: %s", strerror( errno ) );
return NULL;
}
idFile_Permanent *file = new idFile_Permanent();
file->o = f;
file->name = "<tempfile>";
file->fullPath = "<tempfile>";
file->mode = ( 1 << FS_READ ) + ( 1 << FS_WRITE );
file->fileSize = 0;
return file;
}
/*
===============
idFileSystemLocal::FindFile
===============
*/
findFile_t idFileSystemLocal::FindFile( const char *path, bool scheduleAddons ) {
pack_t *pak;
idFile *f = OpenFileReadFlags( path, FSFLAG_SEARCH_DIRS | FSFLAG_SEARCH_PAKS | FSFLAG_SEARCH_ADDONS, &pak );
if ( !f ) {
return FIND_NO;
}
if ( !pak ) {
// found in FS, not even in paks
return FIND_YES;
}
// marking addons for inclusion on reload - may need to do that even when already in the search path
if ( scheduleAddons && pak->addon && addonChecksums.FindIndex( pak->checksum ) < 0 ) {
addonChecksums.Append( pak->checksum );
}
// an addon that's not on search list yet? that will require a restart
if ( pak->addon && !pak->addon_search ) {
delete f;
return FIND_ADDON;
}
delete f;
return FIND_YES;
}
/*
===============
idFileSystemLocal::GetNumMaps
account for actual decls and for addon maps
===============
*/
int idFileSystemLocal::GetNumMaps() {
int i;
searchpath_t *search = NULL;
int ret = declManager->GetNumDecls( DECL_MAPDEF );
// add to this all addon decls - coming from all addon packs ( searched or not )
for ( i = 0; i < 2; i++ ) {
if ( i == 0 ) {
search = searchPaths;
} else if ( i == 1 ) {
search = addonPaks;
}
for ( ; search ; search = search->next ) {
if ( !search->pack || !search->pack->addon || !search->pack->addon_info ) {
continue;
}
ret += search->pack->addon_info->mapDecls.Num();
}
}
return ret;
}
/*
===============
idFileSystemLocal::GetMapDecl
retrieve the decl dictionary, add a 'path' value
===============
*/
const idDict * idFileSystemLocal::GetMapDecl( int idecl ) {
int i;
const idDecl *mapDecl;
const idDeclEntityDef *mapDef;
int numdecls = declManager->GetNumDecls( DECL_MAPDEF );
searchpath_t *search = NULL;
if ( idecl < numdecls ) {
mapDecl = declManager->DeclByIndex( DECL_MAPDEF, idecl );
mapDef = static_cast<const idDeclEntityDef *>( mapDecl );
if ( !mapDef ) {
common->Error( "idFileSystemLocal::GetMapDecl %d: not found\n", idecl );
}
mapDict = mapDef->dict;
mapDict.Set( "path", mapDef->GetName() );
return &mapDict;
}
idecl -= numdecls;
for ( i = 0; i < 2; i++ ) {
if ( i == 0 ) {
search = searchPaths;
} else if ( i == 1 ) {
search = addonPaks;
}
for ( ; search ; search = search->next ) {
if ( !search->pack || !search->pack->addon || !search->pack->addon_info ) {
continue;
}
// each addon may have a bunch of map decls
if ( idecl < search->pack->addon_info->mapDecls.Num() ) {
mapDict = *search->pack->addon_info->mapDecls[ idecl ];
return &mapDict;
}
idecl -= search->pack->addon_info->mapDecls.Num();
assert( idecl >= 0 );
}
}
return NULL;
}
/*
===============
idFileSystemLocal::FindMapScreenshot
===============
*/
void idFileSystemLocal::FindMapScreenshot( const char *path, char *buf, int len ) {
idFile *file;
idStr mapname = path;
mapname.StripPath();
mapname.StripFileExtension();
idStr::snPrintf( buf, len, "guis/assets/splash/%s.tga", mapname.c_str() );
if ( ReadFile( buf, NULL, NULL ) == -1 ) {
// try to extract from an addon
file = OpenFileReadFlags( buf, FSFLAG_SEARCH_ADDONS );
if ( file ) {
// save it out to an addon splash directory
int dlen = file->Length();
char *data = new char[ dlen ];
file->Read( data, dlen );
CloseFile( file );
idStr::snPrintf( buf, len, "guis/assets/splash/addon/%s.tga", mapname.c_str() );
WriteFile( buf, data, dlen );
delete[] data;
} else {
idStr::Copynz( buf, "guis/assets/splash/pdtempa", len );
}
}
}
idStr idFileSystemLocal::GetModDescription(idStr descPath)
{
const int MAX_DESCRIPTION = 256;
char desc[ MAX_DESCRIPTION ];
FILE *f = OpenOSFile( descPath, "r" );
if ( f )
{
if ( fgets( desc, MAX_DESCRIPTION, f ) )
{
//common->Printf("FOUND MOD %s\n", desc);
fclose( f );
}
else
{
common->DWarning( "STEAM: error reading %s", descPath.c_str() );
fclose( f );
}
}
return desc;
}
Reference in a new issue View git blame Copy permalink