d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
377 Commits
25 Branches
6 Tags
221 MiB
Tree: 53bd92f7a8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '53bd92f7a8'
${ noResults }
source-engine/filesystem/basefilesystem.cpp

5832 lines
160 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#ifdef POSIX
#define _snwprintf swprintf
#endif
#include "basefilesystem.h"
#include "tier0/vprof.h"
#include "tier1/characterset.h"
#include "tier1/utlbuffer.h"
#include "tier1/convar.h"
#include "tier1/KeyValues.h"
#include "tier0/icommandline.h"
#include "generichash.h"
#include "tier1/utllinkedlist.h"
#include "filesystem/IQueuedLoader.h"
#include "tier2/tier2.h"
#include "zip_utils.h"
#include "packfile.h"
#ifdef _X360
#include "xbox/xbox_launch.h"
#endif
#ifndef DEDICATED
#include "keyvaluescompiler.h"
#endif
#include "ifilelist.h"
#ifdef IS_WINDOWS_PC
// Needed for getting file type string
#define WIN32_LEAN_AND_MEAN
#include <shellapi.h>
#endif
#if defined( _X360 )
#include "xbox\xbox_win32stubs.h"
#undef GetCurrentDirectory
#endif
fix windows build scripts, add windows opus support
2 years ago
#include <time.h>
1
5 years ago
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#pragma warning( disable : 4355 ) // warning C4355: 'this' : used in base member initializer list
ConVar fs_report_sync_opens( "fs_report_sync_opens", "0", 0, "0:Off, 1:Blocking only, 2:All" );
ConVar fs_warning_mode( "fs_warning_mode", "0", 0, "0:Off, 1:Warn main thread, 2:Warn other threads" );
#define BSPOUTPUT 0 // bsp output flag -- determines type of fs_log output to generate
static void AddSeperatorAndFixPath( char *str );
// Case-insensitive symbol table for path IDs.
CUtlSymbolTableMT g_PathIDTable( 0, 32, true );
int g_iNextSearchPathID = 1;
// This can be used to easily fix a filename on the stack.
#ifdef DBGFLAG_ASSERT
// Look for cases like materials\\blah.vmt.
static bool V_CheckDoubleSlashes( const char *pStr )
{
int len = V_strlen( pStr );
for ( int i=1; i < len-1; i++ )
{
if ( (pStr[i] == '/' || pStr[i] == '\\') && (pStr[i+1] == '/' || pStr[i+1] == '\\') )
{
Msg( "Double slashes found in path '%s'\n", pStr );
return true;
}
}
return false;
}
#define CHECK_DOUBLE_SLASHES( x ) V_CheckDoubleSlashes(x)
#else
#define CHECK_DOUBLE_SLASHES( x )
#endif
static void LogFileOpen( const char *vpk, const char *pFilename, const char *pAbsPath )
{
static const char *mode = NULL;
// Figure out if we should be doing this at all, the first time we are acalled
if ( mode == NULL )
{
if ( CommandLine()->FindParm( "-log_opened_files" ) )
mode = "wt";
else
mode = "";
}
if ( *mode == '\0' )
return;
// Open file for write or append
FILE *f = fopen( "opened_files.txt", mode );
Assert( f );
if ( f )
{
fprintf( f, "%s, %s, %s\n", vpk, pFilename, pAbsPath );
//fprintf( f, "%s\n", pFilename );
fclose(f);
// If this was the first time, switch from write to append for further writes
mode = "at";
}
}
static CBaseFileSystem *g_pBaseFileSystem;
CBaseFileSystem *BaseFileSystem()
{
return g_pBaseFileSystem;
}
ConVar filesystem_buffer_size( "filesystem_buffer_size", "0", 0, "Size of per file buffers. 0 for none" );
#if defined( TRACK_BLOCKING_IO )
// If we hit more than 100 items in a frame, we're probably doing a level load...
#define MAX_ITEMS 100
class CBlockingFileItemList : public IBlockingFileItemList
{
public:
CBlockingFileItemList( CBaseFileSystem *fs )
:
m_pFS( fs ),
m_bLocked( false )
{
}
// You can't call any of the below calls without calling these methods!!!!
virtual void LockMutex()
{
Assert( !m_bLocked );
if ( m_bLocked )
return;
m_bLocked = true;
m_pFS->BlockingFileAccess_EnterCriticalSection();
}
virtual void UnlockMutex()
{
Assert( m_bLocked );
if ( !m_bLocked )
return;
m_pFS->BlockingFileAccess_LeaveCriticalSection();
m_bLocked = false;
}
virtual int First() const
{
if ( !m_bLocked )
{
Error( "CBlockingFileItemList::First() w/o calling EnterCriticalSectionFirst!" );
}
return m_Items.Head();
}
virtual int Next( int i ) const
{
if ( !m_bLocked )
{
Error( "CBlockingFileItemList::Next() w/o calling EnterCriticalSectionFirst!" );
}
return m_Items.Next( i );
}
virtual int InvalidIndex() const
{
return m_Items.InvalidIndex();
}
virtual const FileBlockingItem& Get( int index ) const
{
if ( !m_bLocked )
{
Error( "CBlockingFileItemList::Get( %d ) w/o calling EnterCriticalSectionFirst!", index );
}
return m_Items[ index ];
}
virtual void Reset()
{
if ( !m_bLocked )
{
Error( "CBlockingFileItemList::Reset() w/o calling EnterCriticalSectionFirst!" );
}
m_Items.RemoveAll();
}
void Add( const FileBlockingItem& item )
{
// Ack, should use a linked list probably...
while ( m_Items.Count() > MAX_ITEMS )
{
m_Items.Remove( m_Items.Head() );
}
m_Items.AddToTail( item );
}
private:
CUtlLinkedList< FileBlockingItem, unsigned short > m_Items;
CBaseFileSystem *m_pFS;
bool m_bLocked;
};
#endif
CUtlSymbol CBaseFileSystem::m_GamePathID;
CUtlSymbol CBaseFileSystem::m_BSPPathID;
DVDMode_t CBaseFileSystem::m_DVDMode;
CUtlVector< FileNameHandle_t > CBaseFileSystem::m_ExcludePaths;
class CStoreIDEntry
{
public:
Replace empty constructors with default constructors #88
2 years ago
CStoreIDEntry() = default;
1
5 years ago
CStoreIDEntry( const char *pPathIDStr, int storeID )
{
m_PathIDString = pPathIDStr;
m_StoreID = storeID;
}
public:
CUtlSymbol m_PathIDString;
int m_StoreID;
};
#if 0
static CStoreIDEntry* FindPrevFileByStoreID( CUtlDict< CUtlVector<CStoreIDEntry>* ,int> &filesByStoreID, const char *pFilename, const char *pPathIDStr, int foundStoreID )
{
int iEntry = filesByStoreID.Find( pFilename );
if ( iEntry == filesByStoreID.InvalidIndex() )
{
CUtlVector<CStoreIDEntry> *pList = new CUtlVector<CStoreIDEntry>;
pList->AddToTail( CStoreIDEntry(pPathIDStr, foundStoreID) );
filesByStoreID.Insert( pFilename, pList );
return NULL;
}
else
{
// Now is there a previous entry with a different path ID string and the same store ID?
CUtlVector<CStoreIDEntry> *pList = filesByStoreID[iEntry];
for ( int i=0; i < pList->Count(); i++ )
{
CStoreIDEntry &entry = pList->Element( i );
if ( entry.m_StoreID == foundStoreID && V_stricmp( entry.m_PathIDString.String(), pPathIDStr ) != 0 )
return &entry;
}
return NULL;
}
}
#endif
//-----------------------------------------------------------------------------
class CBaseFileSystem::CFileCacheObject
{
public:
CFileCacheObject( CBaseFileSystem* pFS );
~CFileCacheObject();
void AddFiles( const char **ppFileNames, int nFileNames );
bool IsReady() const { return m_nPending == 0; }
static void IOCallback( const FileAsyncRequest_t &request, int nBytesRead, FSAsyncStatus_t err );
struct Info_t
{
const char* pFileName;
FSAsyncControl_t hIOAsync;
CMemoryFileBacking* pBacking;
CFileCacheObject* pOwner;
};
CBaseFileSystem* m_pFS;
CInterlockedInt m_nPending;
CThreadFastMutex m_InfosMutex;
CUtlVector< Info_t* > m_Infos;
private:
void ProcessNewEntries( int start );
CFileCacheObject( const CFileCacheObject& ); // not implemented
CFileCacheObject & operator=(const CFileCacheObject& ); // not implemented
};
//-----------------------------------------------------------------------------
// constructor
//-----------------------------------------------------------------------------
CBaseFileSystem::CBaseFileSystem()
: m_FileTracker2( this )
{
g_pBaseFileSystem = this;
g_pFullFileSystem = this;
m_WhitelistFileTrackingEnabled = -1;
// If this changes then FileNameHandleInternal_t/FileNameHandle_t needs to be fixed!!!
Assert( sizeof( CUtlSymbol ) == sizeof( short ) );
// Clear out statistics
memset( &m_Stats, 0, sizeof(m_Stats) );
m_fwLevel = FILESYSTEM_WARNING_REPORTUNCLOSED;
m_pfnWarning = NULL;
m_pLogFile = NULL;
m_bOutputDebugString = false;
m_WhitelistSpewFlags = 0;
m_DirtyDiskReportFunc = NULL;
m_pPureServerWhitelist = NULL;
m_pThreadPool = NULL;
#if defined( TRACK_BLOCKING_IO )
m_pBlockingItems = new CBlockingFileItemList( this );
m_bBlockingFileAccessReportingEnabled = false;
m_bAllowSynchronousLogging = true;
#endif
m_iMapLoad = 0;
Q_memset( m_PreloadData, 0, sizeof( m_PreloadData ) );
// allows very specifc constrained behavior
m_DVDMode = DVDMODE_OFF;
if ( IsX360() )
{
if ( CommandLine()->FindParm( "-dvd" ) )
{
m_DVDMode = DVDMODE_STRICT;
}
else if ( CommandLine()->FindParm( "-dvddev" ) )
{
m_DVDMode = DVDMODE_DEV;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::~CBaseFileSystem()
{
m_PathIDInfos.PurgeAndDeleteElements();
#if defined( TRACK_BLOCKING_IO )
delete m_pBlockingItems;
#endif
// Free the whitelist.
RegisterFileWhitelist( NULL, NULL );
}
//-----------------------------------------------------------------------------
// Methods of IAppSystem
//-----------------------------------------------------------------------------
void *CBaseFileSystem::QueryInterface( const char *pInterfaceName )
{
// We also implement the IMatSystemSurface interface
if (!Q_strncmp( pInterfaceName, BASEFILESYSTEM_INTERFACE_VERSION, Q_strlen(BASEFILESYSTEM_INTERFACE_VERSION) + 1))
return (IBaseFileSystem*)this;
return NULL;
}
InitReturnVal_t CBaseFileSystem::Init()
{
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
// This is a special tag to allow iterating just the BSP file, it doesn't show up in the list per se, but gets converted to "GAME" in the filter function
m_BSPPathID = g_PathIDTable.AddString( "BSP" );
m_GamePathID = g_PathIDTable.AddString( "GAME" );
if ( getenv( "fs_debug" ) )
{
m_bOutputDebugString = true;
}
const char *logFileName = CommandLine()->ParmValue( "-fs_log" );
if( logFileName )
{
m_pLogFile = fopen( logFileName, "w" ); // STEAM OK
if ( !m_pLogFile )
return INIT_FAILED;
fprintf( m_pLogFile, "@echo off\n" );
fprintf( m_pLogFile, "setlocal\n" );
const char *fs_target = CommandLine()->ParmValue( "-fs_target" );
if( fs_target )
{
fprintf( m_pLogFile, "set fs_target=\"%s\"\n", fs_target );
}
fprintf( m_pLogFile, "if \"%%fs_target%%\" == \"\" goto error\n" );
fprintf( m_pLogFile, "@echo on\n" );
}
InitAsync();
if ( IsX360() && m_DVDMode == DVDMODE_DEV )
{
// exclude paths are valid ony in dvddev mode
char szExcludeFile[MAX_PATH];
const char *pRemotePath = CommandLine()->ParmValue( "-remote" );
const char *pBasePath = CommandLine()->ParmValue( "-basedir" );
if ( pRemotePath && pBasePath )
{
// the optional exclude path file only exists at the remote path
V_ComposeFileName( pRemotePath, "xbox_exclude_paths.txt", szExcludeFile, sizeof( szExcludeFile ) );
// populate the exclusion list
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( ReadFile( szExcludeFile, NULL, buf, 0, 0 ) )
{
characterset_t breakSet;
CharacterSetBuild( &breakSet, "" );
char szPath[MAX_PATH];
char szToken[MAX_PATH];
for ( ;; )
{
int nTokenSize = buf.ParseToken( &breakSet, szToken, sizeof( szToken ) );
if ( nTokenSize <= 0 )
{
break;
}
char *pToken = szToken;
if ( pToken[0] == '\\' )
{
// skip past possible initial seperator
pToken++;
}
V_ComposeFileName( pBasePath, pToken, szPath, sizeof( szPath ) );
V_AppendSlash( szPath, sizeof( szPath ) );
FileNameHandle_t hFileName = FindOrAddFileName( szPath );
if ( m_ExcludePaths.Find( hFileName ) == -1 )
{
m_ExcludePaths.AddToTail( hFileName );
}
}
}
}
}
return INIT_OK;
}
void CBaseFileSystem::Shutdown()
{
ShutdownAsync();
m_FileTracker2.ShutdownAsync();
#ifndef _X360
if( m_pLogFile )
{
if( CommandLine()->FindParm( "-fs_logbins" ) >= 0 )
{
char cwd[MAX_FILEPATH];
getcwd( cwd, MAX_FILEPATH-1 );
fprintf( m_pLogFile, "set binsrc=\"%s\"\n", cwd );
fprintf( m_pLogFile, "mkdir \"%%fs_target%%\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\hl2.exe\" \"%%fs_target%%\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\hl2.dat\" \"%%fs_target%%\"\n" );
fprintf( m_pLogFile, "mkdir \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\*.asi\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\materialsystem.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\shaderapidx9.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\filesystem_stdio.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\soundemittersystem.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\stdshader*.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\shader_nv*.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\launcher.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\engine.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\mss32.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\tier0.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\vgui2.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\vguimatsurface.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\voice_miles.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\vphysics.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\vstdlib.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\studiorender.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\bin\\vaudio_miles.dll\" \"%%fs_target%%\\bin\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\hl2\\resource\\*.ttf\" \"%%fs_target%%\\hl2\\resource\"\n" );
fprintf( m_pLogFile, "copy \"%%binsrc%%\\hl2\\bin\\gameui.dll\" \"%%fs_target%%\\hl2\\bin\"\n" );
}
fprintf( m_pLogFile, "goto done\n" );
fprintf( m_pLogFile, ":error\n" );
fprintf( m_pLogFile, "echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\"\n" );
fprintf( m_pLogFile, "echo ERROR: must set fs_target=targetpath (ie. \"set fs_target=u:\\destdir\")!\n" );
fprintf( m_pLogFile, "echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\"\n" );
fprintf( m_pLogFile, ":done\n" );
fclose( m_pLogFile ); // STEAM OK
}
#endif
UnloadCompiledKeyValues();
RemoveAllSearchPaths();
Trace_DumpUnclosedFiles();
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Computes a full write path
//-----------------------------------------------------------------------------
inline void CBaseFileSystem::ComputeFullWritePath( char* pDest, int maxlen, const char *pRelativePath, const char *pWritePathID )
{
Q_strncpy( pDest, GetWritePath( pRelativePath, pWritePathID ), maxlen );
Q_strncat( pDest, pRelativePath, maxlen, COPY_ALL_CHARACTERS );
Q_FixSlashes( pDest );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : src1 -
// src2 -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::OpenedFileLessFunc( COpenedFile const& src1, COpenedFile const& src2 )
{
return src1.m_pFile < src2.m_pFile;
}
void CBaseFileSystem::InstallDirtyDiskReportFunc( FSDirtyDiskReportFunc_t func )
{
m_DirtyDiskReportFunc = func;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *fullpath -
//-----------------------------------------------------------------------------
void CBaseFileSystem::LogAccessToFile( char const *accesstype, char const *fullpath, char const *options )
{
LOCAL_THREAD_LOCK();
if ( m_fwLevel >= FILESYSTEM_WARNING_REPORTALLACCESSES && !V_stristr( fullpath, "console.log" ) )
{
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES, "---FS%s: %s %s (%.3f)\n", ThreadInMainThread() ? "" : "[a]", accesstype, fullpath, Plat_FloatTime() );
}
int c = m_LogFuncs.Count();
if ( !c )
return;
for ( int i = 0; i < c; ++i )
{
( m_LogFuncs[ i ] )( fullpath, options );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
// *options -
// Output : FILE
//-----------------------------------------------------------------------------
FILE *CBaseFileSystem::Trace_FOpen( const char *filenameT, const char *options, unsigned flags, int64 *size )
{
AUTOBLOCKREPORTER_FN( Trace_FOpen, this, true, filenameT, FILESYSTEM_BLOCKING_SYNCHRONOUS, FileBlockingItem::FB_ACCESS_OPEN );
char filename[MAX_PATH];
FixUpPath ( filenameT, filename, sizeof( filename ) );
FILE *fp = FS_fopen( filename, options, flags, size );
if ( fp )
{
if ( options[0] == 'r' )
{
FS_setbufsize(fp, filesystem_buffer_size.GetInt() );
}
else
{
FS_setbufsize(fp, 32*1024 );
}
AUTO_LOCK( m_OpenedFilesMutex );
COpenedFile file;
file.SetName( filename );
file.m_pFile = fp;
m_OpenedFiles.AddToTail( file );
LogAccessToFile( "open", filename, options );
}
return fp;
}
void CBaseFileSystem::GetFileNameForHandle( FileHandle_t handle, char *buf, size_t buflen )
{
V_strncpy( buf, "Unknown", buflen );
/*
CFileHandle *fh = ( CFileHandle *)handle;
if ( !fh )
{
buf[ 0 ] = 0;
return;
}
#if !defined( _RETAIL )
// Pack file filehandles store the underlying name for convenience
if ( fh->IsPack() )
{
Q_strncpy( buf, fh->Name(), buflen );
return;
}
#endif
AUTO_LOCK( m_OpenedFilesMutex );
COpenedFile file;
file.m_pFile = fh->GetFileHandle();
int result = m_OpenedFiles.Find( file );
if ( result != -1 )
{
COpenedFile found = m_OpenedFiles[ result ];
Q_strncpy( buf, found.GetName(), buflen );
}
else
{
buf[ 0 ] = 0;
}
*/
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *fp -
//-----------------------------------------------------------------------------
void CBaseFileSystem::Trace_FClose( FILE *fp )
{
if ( fp )
{
m_OpenedFilesMutex.Lock();
COpenedFile file;
file.m_pFile = fp;
int result = m_OpenedFiles.Find( file );
if ( result != -1 /*m_OpenedFiles.InvalidIdx()*/ )
{
COpenedFile found = m_OpenedFiles[ result ];
if ( m_fwLevel >= FILESYSTEM_WARNING_REPORTALLACCESSES && !V_stristr( found.GetName(), "console.log" ) )
{
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES, "---FS%s: close %s %p %i (%.3f)\n", ThreadInMainThread() ? "" : "[a]", found.GetName(), fp, m_OpenedFiles.Count(), Plat_FloatTime() );
}
m_OpenedFiles.Remove( result );
}
else
{
Assert( 0 );
if ( m_fwLevel >= FILESYSTEM_WARNING_REPORTALLACCESSES )
{
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES, "Tried to close unknown file pointer %p\n", fp );
}
}
m_OpenedFilesMutex.Unlock();
FS_fclose( fp );
}
}
void CBaseFileSystem::Trace_FRead( int size, FILE* fp )
{
if ( !fp || m_fwLevel < FILESYSTEM_WARNING_REPORTALLACCESSES_READ )
return;
AUTO_LOCK( m_OpenedFilesMutex );
COpenedFile file;
file.m_pFile = fp;
int result = m_OpenedFiles.Find( file );
if( result != -1 )
{
COpenedFile found = m_OpenedFiles[ result ];
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES_READ, "---FS%s: read %s %i %p (%.3f)\n", ThreadInMainThread() ? "" : "[a]", found.GetName(), size, fp, Plat_FloatTime() );
}
else
{
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES_READ, "Tried to read %i bytes from unknown file pointer %p\n", size, fp );
}
}
void CBaseFileSystem::Trace_FWrite( int size, FILE* fp )
{
if ( !fp || m_fwLevel < FILESYSTEM_WARNING_REPORTALLACCESSES_READWRITE )
return;
COpenedFile file;
file.m_pFile = fp;
AUTO_LOCK( m_OpenedFilesMutex );
int result = m_OpenedFiles.Find( file );
if( result != -1 )
{
COpenedFile found = m_OpenedFiles[ result ];
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES_READWRITE, "---FS%s: write %s %i %p\n", ThreadInMainThread() ? "" : "[a]", found.GetName(), size, fp );
}
else
{
Warning( FILESYSTEM_WARNING_REPORTALLACCESSES_READWRITE, "Tried to write %i bytes from unknown file pointer %p\n", size, fp );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::Trace_DumpUnclosedFiles( void )
{
/*
AUTO_LOCK( m_OpenedFilesMutex );
for ( int i = 0 ; i < m_OpenedFiles.Count(); i++ )
{
COpenedFile *found = &m_OpenedFiles[ i ];
if ( m_fwLevel >= FILESYSTEM_WARNING_REPORTUNCLOSED )
{
// This warning can legitimately trigger because the log file is, by design, not
// closed. It is not closed at shutdown in order to avoid race conditions. It is
// not closed at each call to log information because the performance costs,
// especially if Microsoft Security Essentials is running, are extreme.
// In addition, when this warning triggers it can, due to the state of the process,
// actually cause a crash.
Warning( FILESYSTEM_WARNING_REPORTUNCLOSED, "File %s was never closed\n", found->GetName() );
}
}
*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::PrintOpenedFiles( void )
{
FileWarningLevel_t saveLevel = m_fwLevel;
m_fwLevel = FILESYSTEM_WARNING_REPORTUNCLOSED;
Trace_DumpUnclosedFiles();
m_fwLevel = saveLevel;
}
#if defined( SUPPORT_PACKED_STORE )
CPackedStoreRefCount::CPackedStoreRefCount( char const *pFileBasename, char *pszFName, IBaseFileSystem *pFS )
: CPackedStore( pFileBasename, pszFName, pFS, false )
{
// If the VPK is signed, check the signature
//
// !FIXME! This code is simple a linchpin that a hacker could detour to bypass sv_pure
#ifdef VPK_ENABLE_SIGNING
CPackedStore::ESignatureCheckResult eSigResult = CPackedStore::CheckSignature( 0, NULL );
m_bSignatureValid = ( eSigResult == CPackedStore::eSignatureCheckResult_ValidSignature );
#else
m_bSignatureValid = false;
#endif
}
#endif
void CBaseFileSystem::AddVPKFile( char const *pPath, const char *pPathID, SearchPathAdd_t addType )
{
#if defined( SUPPORT_PACKED_STORE )
char nameBuf[MAX_PATH];
Q_MakeAbsolutePath( nameBuf, sizeof( nameBuf ), pPath );
Q_FixSlashes( nameBuf );
CUtlSymbol pathIDSym = g_PathIDTable.AddString( pPathID );
// See if we already have this vpk file as a search path
CPackedStoreRefCount *pVPK = NULL;
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackedStoreRefCount *p = m_SearchPaths[i].GetPackedStore();
if ( p && V_stricmp( p->FullPathName(), nameBuf ) == 0 )
{
// Already present
if ( m_SearchPaths[i].GetPath() == pathIDSym )
return;
// Present, but for a different path
pVPK = p;
}
}
// Create a new VPK if we didn't don't already have it opened
if ( pVPK == NULL )
{
char pszFName[MAX_PATH];
pVPK = new CPackedStoreRefCount( nameBuf, pszFName, this );
if ( pVPK->IsEmpty() )
{
delete pVPK;
return;
}
pVPK->RegisterFileTracker( (IThreadedFileMD5Processor *)&m_FileTracker2 );
pVPK->m_PackFileID = m_FileTracker2.NotePackFileOpened( pVPK->FullPathName(), pPathID, 0 );
}
else
{
pVPK->AddRef();
}
// Crete a search path for this
CSearchPath *sp = &m_SearchPaths[ ( addType == PATH_ADD_TO_TAIL ) ? m_SearchPaths.AddToTail() : m_SearchPaths.AddToHead() ];
sp->SetPackedStore( pVPK );
sp->m_storeId = g_iNextSearchPathID++;
sp->SetPath( pathIDSym );
sp->m_pPathIDInfo = FindOrAddPathIDInfo( g_PathIDTable.AddString( pPathID ), -1 );
// Check if we're trusted or not
SetSearchPathIsTrustedSource( sp );
#endif // SUPPORT_PACKED_STORE
}
bool CBaseFileSystem::RemoveVPKFile( const char *pPath, const char *pPathID )
{
#if defined( SUPPORT_PACKED_STORE )
char nameBuf[MAX_PATH];
Q_MakeAbsolutePath( nameBuf, sizeof( nameBuf ), pPath );
Q_FixSlashes( nameBuf );
CUtlSymbol pathIDSym = g_PathIDTable.AddString( pPathID );
// See if we already have this vpk file as a search path
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackedStoreRefCount *p = m_SearchPaths[i].GetPackedStore();
if ( p && V_stricmp( p->FullPathName(), nameBuf ) == 0 )
{
// remove if we find one
if ( m_SearchPaths[i].GetPath() == pathIDSym )
{
m_SearchPaths.Remove( i );
return true;
}
}
}
#endif // SUPPORT_PACKED_STORE
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Adds the specified pack file to the list
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::AddPackFile( const char *pFileName, const char *pathID )
{
CHECK_DOUBLE_SLASHES( pFileName );
AsyncFinishAll();
return AddPackFileFromPath( "", pFileName, true, pathID );
}
//-----------------------------------------------------------------------------
// Purpose: Adds a pack file from the specified path
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::AddPackFileFromPath( const char *pPath, const char *pakfile, bool bCheckForAppendedPack, const char *pathID )
{
char fullpath[ MAX_PATH ];
_snprintf( fullpath, sizeof(fullpath), "%s%s", pPath, pakfile );
Q_FixSlashes( fullpath );
struct _stat buf;
if ( FS_stat( fullpath, &buf ) == -1 )
return false;
CPackFile *pf = new CZipPackFile( this );
pf->m_hPackFileHandleFS = Trace_FOpen( fullpath, "rb", 0, NULL );
if ( !pf->m_hPackFileHandleFS )
{
delete pf;
return false;
}
// NOTE: Opening .bsp fiels inside of VPK files is not supported
// Get the length of the pack file:
FS_fseek( ( FILE * )pf->m_hPackFileHandleFS, 0, FILESYSTEM_SEEK_TAIL );
int64 len = FS_ftell( ( FILE * )pf->m_hPackFileHandleFS );
FS_fseek( ( FILE * )pf->m_hPackFileHandleFS, 0, FILESYSTEM_SEEK_HEAD );
if ( !pf->Prepare( len ) )
{
// Failed for some reason, ignore it
Trace_FClose( pf->m_hPackFileHandleFS );
pf->m_hPackFileHandleFS = NULL;
delete pf;
return false;
}
// Add this pack file to the search path:
CSearchPath *sp = &m_SearchPaths[ m_SearchPaths.AddToTail() ];
pf->SetPath( sp->GetPath() );
pf->m_lPackFileTime = GetFileTime( pakfile );
sp->SetPath( pPath );
sp->m_pPathIDInfo->SetPathID( pathID );
sp->SetPackFile( pf );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Search pPath for pak?.pak files and add to search path if found
// Input : *pPath -
//-----------------------------------------------------------------------------
#if !defined( _X360 )
#define PACK_NAME_FORMAT "zip%i.zip"
#else
#define PACK_NAME_FORMAT "zip%i.360.zip"
#define PACK_LOCALIZED_NAME_FORMAT "zip%i_%s.360.zip"
#endif
void CBaseFileSystem::AddPackFiles( const char *pPath, const CUtlSymbol &pathID, SearchPathAdd_t addType )
{
Assert( ThreadInMainThread() );
DISK_INTENSIVE();
CUtlVector< CUtlString > pakNames;
CUtlVector< int64 > pakSizes;
// determine pak files, [zip0..zipN]
for ( int i = 0; ; i++ )
{
char pakfile[MAX_PATH];
char fullpath[MAX_PATH];
V_snprintf( pakfile, sizeof( pakfile ), PACK_NAME_FORMAT, i );
V_ComposeFileName( pPath, pakfile, fullpath, sizeof( fullpath ) );
struct _stat buf;
if ( FS_stat( fullpath, &buf ) == -1 )
break;
MEM_ALLOC_CREDIT();
pakNames.AddToTail( pakfile );
pakSizes.AddToTail( (int64)((unsigned int)buf.st_size) );
}
#if defined( _X360 )
// localized zips are added last to ensure they appear first in the search path construction
// localized zips can only appear in the game or mod directories
bool bUseEnglishAudio = XboxLaunch()->GetForceEnglish();
if ( XBX_IsLocalized() && ( bUseEnglishAudio == false ) &&
( V_stricmp( g_PathIDTable.String( pathID ), "game" ) == 0 || V_stricmp( g_PathIDTable.String( pathID ), "mod" ) == 0 ) )
{
// determine localized pak files, [zip0_language..zipN_language]
for ( int i = 0; ; i++ )
{
char pakfile[MAX_PATH];
char fullpath[MAX_PATH];
V_snprintf( pakfile, sizeof( pakfile ), PACK_LOCALIZED_NAME_FORMAT, i, XBX_GetLanguageString() );
V_ComposeFileName( pPath, pakfile, fullpath, sizeof( fullpath ) );
struct _stat buf;
if ( FS_stat( fullpath, &buf ) == -1 )
break;
pakNames.AddToTail( pakfile );
pakSizes.AddToTail( (int64)((unsigned int)buf.st_size) );
}
}
#endif
// Add any zip files in the format zip1.zip ... zip0.zip
// Add them backwards so zip(N) is higher priority than zip(N-1), etc.
int pakcount = pakSizes.Count();
int nCount = 0;
for ( int i = pakcount-1; i >= 0; i-- )
{
char fullpath[MAX_PATH];
V_ComposeFileName( pPath, pakNames[i].Get(), fullpath, sizeof( fullpath ) );
int nIndex;
if ( addType == PATH_ADD_TO_TAIL )
{
nIndex = m_SearchPaths.AddToTail();
}
else
{
nIndex = m_SearchPaths.InsertBefore( nCount );
++nCount;
}
CSearchPath *sp = &m_SearchPaths[ nIndex ];
sp->m_pPathIDInfo = FindOrAddPathIDInfo( pathID, -1 );
sp->m_storeId = g_iNextSearchPathID++;
sp->SetPath( g_PathIDTable.AddString( pPath ) );
CPackFile *pf = NULL;
for ( int iPackFile = 0; iPackFile < m_ZipFiles.Count(); iPackFile++ )
{
if ( !Q_stricmp( m_ZipFiles[iPackFile]->m_ZipName.Get(), fullpath ) )
{
pf = m_ZipFiles[iPackFile];
sp->SetPackFile( pf );
pf->AddRef();
}
}
if ( !pf )
{
MEM_ALLOC_CREDIT();
pf = new CZipPackFile( this );
pf->SetPath( sp->GetPath() );
pf->m_ZipName = fullpath;
m_ZipFiles.AddToTail( pf );
sp->SetPackFile( pf );
pf->m_lPackFileTime = GetFileTime( fullpath );
pf->m_hPackFileHandleFS = Trace_FOpen( fullpath, "rb", 0, NULL );
if ( pf->m_hPackFileHandleFS )
{
FS_setbufsize( pf->m_hPackFileHandleFS, 32*1024 ); // 32k buffer.
if ( pf->Prepare( pakSizes[i] ) )
{
FS_setbufsize( pf->m_hPackFileHandleFS, filesystem_buffer_size.GetInt() );
}
else
{
// Failed for some reason, ignore it
if ( pf->m_hPackFileHandleFS )
{
Trace_FClose( pf->m_hPackFileHandleFS );
pf->m_hPackFileHandleFS = NULL;
}
m_SearchPaths.Remove( nIndex );
}
}
else
{
// !NOTE! Pack files inside of VPK not supported
//pf->m_hPackFileHandleVPK = FindFileInVPKs( fullpath );
//if ( !pf->m_hPackFileHandleVPK || !pf->Prepare( pakSizes[i] ) )
{
m_SearchPaths.Remove( nIndex );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Wipe all map (.bsp) pak file search paths
//-----------------------------------------------------------------------------
void CBaseFileSystem::RemoveAllMapSearchPaths( void )
{
AsyncFinishAll();
int c = m_SearchPaths.Count();
for ( int i = c - 1; i >= 0; i-- )
{
if ( !( m_SearchPaths[i].GetPackFile() && m_SearchPaths[i].GetPackFile()->m_bIsMapPath ) )
{
continue;
}
m_SearchPaths.Remove( i );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::AddMapPackFile( const char *pPath, const char *pPathID, SearchPathAdd_t addType )
{
char tempPathID[MAX_PATH];
ParsePathID( pPath, pPathID, tempPathID );
// Security nightmares already, should not let things explicitly loading from e.g. "MOD" get surprise untrusted
// files unless you really really know what you're doing.
AssertMsg( V_strcasecmp( pPathID, "GAME" ) == 0,
"Mounting map files anywhere besides GAME is asking for pain" );
char newPath[ MAX_FILEPATH ];
// +2 for '\0' and potential slash added at end.
V_strncpy( newPath, pPath, sizeof( newPath ) );
#ifdef _WIN32 // don't do this on linux!
V_strlower( newPath );
#endif
V_FixSlashes( newPath );
// Open the .bsp and find the map lump
char fullpath[ MAX_FILEPATH ];
if ( V_IsAbsolutePath( newPath ) ) // If it's an absolute path, just use that.
{
V_strncpy( fullpath, newPath, sizeof(fullpath) );
}
else
{
if ( !GetLocalPath( newPath, fullpath, sizeof(fullpath) ) )
{
// Couldn't find that .bsp file!!!
return;
}
}
int c = m_SearchPaths.Count();
for ( int i = c - 1; i >= 0; i-- )
{
if ( !( m_SearchPaths[i].GetPackFile() && m_SearchPaths[i].GetPackFile()->m_bIsMapPath ) )
continue;
if ( V_stricmp( m_SearchPaths[i].GetPackFile()->m_ZipName.Get(), fullpath ) == 0 )
{
// Already set as map path
return;
}
}
RemoveAllMapSearchPaths();
CUtlSymbol pathSymbol = g_PathIDTable.AddString( newPath );
int iStoreId = CRC32_ProcessSingleBuffer( fullpath, V_strlen(fullpath) ) | 0x80000000; // set store ID based on .bsp filename, so if we remount the same map file, it will have the same storeid
// Look through already-open packfiles in case we intentionally
// preserved this ZIP across a map reload via refcount holding
FOR_EACH_VEC( m_ZipFiles, i )
{
CPackFile* pf = m_ZipFiles[i];
if ( pf && pf->m_bIsMapPath && pf->GetPath() == pathSymbol && V_stricmp( pf->m_ZipName.Get(), fullpath ) == 0 )
{
CSearchPath *sp = &m_SearchPaths[ ( addType == PATH_ADD_TO_TAIL ) ? m_SearchPaths.AddToTail() : m_SearchPaths.AddToHead() ];
pf->AddRef();
sp->SetPackFile( pf );
sp->m_storeId = iStoreId;
sp->SetPath( pathSymbol );
sp->m_pPathIDInfo = FindOrAddPathIDInfo( g_PathIDTable.AddString( pPathID ), -1 );
if ( IsX360() && !V_strnicmp( newPath, "net:", 4 ) )
{
sp->m_bIsRemotePath = true;
}
SetSearchPathIsTrustedSource( sp );
return;
}
}
{
FILE *fp = Trace_FOpen( fullpath, "rb", 0, NULL );
if ( !fp )
{
// Couldn't open it
Warning( FILESYSTEM_WARNING, "Couldn't open .bsp %s for embedded pack file check\n", fullpath );
return;
}
// Get the .bsp file header
dheader_t header;
memset( &header, 0, sizeof(dheader_t) );
m_Stats.nBytesRead += FS_fread( &header, sizeof( header ), fp );
m_Stats.nReads++;
if ( header.ident != IDBSPHEADER || header.version < MINBSPVERSION || header.version > BSPVERSION )
{
Trace_FClose( fp );
return;
}
// Find the LUMP_PAKFILE offset
lump_t *packfile = &header.lumps[ LUMP_PAKFILE ];
if ( packfile->filelen <= sizeof( lump_t ) )
{
// It's empty or only contains a file header ( so there are no entries ), so don't add to search paths
Trace_FClose( fp );
return;
}
// Seek to correct position
FS_fseek( fp, packfile->fileofs, FILESYSTEM_SEEK_HEAD );
CPackFile *pf = new CZipPackFile( this );
pf->m_bIsMapPath = true;
pf->m_hPackFileHandleFS = fp;
MEM_ALLOC_CREDIT();
pf->m_ZipName = fullpath;
if ( pf->Prepare( packfile->filelen, packfile->fileofs ) )
{
int nIndex;
if ( addType == PATH_ADD_TO_TAIL )
{
nIndex = m_SearchPaths.AddToTail();
}
else
{
nIndex = m_SearchPaths.AddToHead();
}
CSearchPath *sp = &m_SearchPaths[ nIndex ];
sp->SetPackFile( pf );
sp->m_storeId = iStoreId;
sp->SetPath( pathSymbol );
sp->m_pPathIDInfo = FindOrAddPathIDInfo( g_PathIDTable.AddString( pPathID ), -1 );
if ( IsX360() && !V_strnicmp( newPath, "net:", 4 ) )
{
sp->m_bIsRemotePath = true;
}
pf->SetPath( pathSymbol );
pf->m_lPackFileTime = GetFileTime( newPath );
Trace_FClose( pf->m_hPackFileHandleFS );
pf->m_hPackFileHandleFS = NULL;
m_ZipFiles.AddToTail( pf );
SetSearchPathIsTrustedSource( sp );
}
else
{
delete pf;
}
}
}
void CBaseFileSystem::BeginMapAccess()
{
if ( m_iMapLoad++ == 0 )
{
int c = m_SearchPaths.Count();
for( int i = 0; i < c; i++ )
{
CSearchPath *pSearchPath = &m_SearchPaths[i];
CPackFile *pPackFile = pSearchPath->GetPackFile();
if ( pPackFile && pPackFile->m_bIsMapPath )
{
pPackFile->AddRef();
pPackFile->m_mutex.Lock();
#if defined( SUPPORT_PACKED_STORE )
if ( pPackFile->m_nOpenFiles == 0 && pPackFile->m_hPackFileHandleFS == NULL && !pPackFile->m_hPackFileHandleVPK )
#else
if ( pPackFile->m_nOpenFiles == 0 && pPackFile->m_hPackFileHandleFS == NULL )
#endif
{
// Try opening the file as a regular file
pPackFile->m_hPackFileHandleFS = Trace_FOpen( pPackFile->m_ZipName, "rb", 0, NULL );
// !NOTE! Pack files inside of VPK not supported
//#if defined( SUPPORT_PACKED_STORE )
// if ( !pPackFile->m_hPackFileHandleFS )
// {
// pPackFile->m_hPackFileHandleVPK = FindFileInVPKs( pPackFile->m_ZipName );
// }
//#endif
}
pPackFile->m_nOpenFiles++;
pPackFile->m_mutex.Unlock();
}
}
}
}
void CBaseFileSystem::EndMapAccess()
{
if ( m_iMapLoad-- == 1 )
{
int c = m_SearchPaths.Count();
for( int i = 0; i < c; i++ )
{
CSearchPath *pSearchPath = &m_SearchPaths[i];
CPackFile *pPackFile = pSearchPath->GetPackFile();
if ( pPackFile && pPackFile->m_bIsMapPath )
{
pPackFile->m_mutex.Lock();
pPackFile->m_nOpenFiles--;
if ( pPackFile->m_nOpenFiles == 0 )
{
if ( pPackFile->m_hPackFileHandleFS )
{
Trace_FClose( pPackFile->m_hPackFileHandleFS );
pPackFile->m_hPackFileHandleFS = NULL;
}
}
pPackFile->m_mutex.Unlock();
pPackFile->Release();
}
}
}
}
void CBaseFileSystem::PrintSearchPaths( void )
{
Msg( "---------------\n" );
Msg( "Paths:\n" );
int c = m_SearchPaths.Count();
for( int i = 0; i < c; i++ )
{
CSearchPath *pSearchPath = &m_SearchPaths[i];
const char *pszPack = "";
const char *pszType = "";
if ( pSearchPath->GetPackFile() && pSearchPath->GetPackFile()->m_bIsMapPath )
{
pszType = "(map)";
}
else if ( pSearchPath->GetPackFile() )
{
pszType = "(pack) ";
pszPack = pSearchPath->GetPackFile()->m_ZipName;
}
#ifdef SUPPORT_PACKED_STORE
else if ( pSearchPath->GetPackedStore() )
{
pszType = "(VPK)";
pszPack = pSearchPath->GetPackedStore()->FullPathName();
}
#endif
Msg( "\"%s\" \"%s\" %s%s\n", pSearchPath->GetPathString(), (const char *)pSearchPath->GetPathIDString(), pszType, pszPack );
}
if ( IsX360() && m_ExcludePaths.Count() )
{
// dump current list
Msg( "\nExclude:\n" );
char szPath[MAX_PATH];
for ( int i = 0; i < m_ExcludePaths.Count(); i++ )
{
if ( String( m_ExcludePaths[i], szPath, sizeof( szPath ) ) )
{
Msg( "\"%s\"\n", szPath );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: This is where search paths are created. map files are created at head of list (they occur after
// file system paths have already been set ) so they get highest priority. Otherwise, we add the disk (non-packfile)
// path and then the paks if they exist for the path
// Input : *pPath -
//-----------------------------------------------------------------------------
void CBaseFileSystem::AddSearchPathInternal( const char *pPath, const char *pathID, SearchPathAdd_t addType, bool bAddPackFiles )
{
AsyncFinishAll();
Assert( ThreadInMainThread() );
// Map pak files have their own handler
if ( V_stristr( pPath, ".bsp" ) )
{
AddMapPackFile( pPath, pathID, addType );
return;
}
// So do VPK files
if ( V_stristr( pPath, ".vpk" ) )
{
AddVPKFile( pPath, pathID, addType );
return;
}
// Clean up the name
char newPath[ MAX_FILEPATH ];
if ( pPath[0] == 0 )
{
newPath[0] = newPath[1] = 0;
}
else
{
if ( IsX360() || Q_IsAbsolutePath( pPath ) )
{
Q_strncpy( newPath, pPath, sizeof( newPath ) );
}
else
{
Q_MakeAbsolutePath( newPath, sizeof(newPath), pPath );
}
#ifdef _WIN32
Q_strlower( newPath );
#endif
AddSeperatorAndFixPath( newPath );
}
// Make sure that it doesn't already exist
CUtlSymbol pathSym, pathIDSym;
pathSym = g_PathIDTable.AddString( newPath );
pathIDSym = g_PathIDTable.AddString( pathID );
int i;
int c = m_SearchPaths.Count();
int id = 0;
for ( i = 0; i < c; i++ )
{
CSearchPath *pSearchPath = &m_SearchPaths[i];
if ( pSearchPath->GetPath() == pathSym && pSearchPath->GetPathID() == pathIDSym )
{
if ( ( addType == PATH_ADD_TO_HEAD && i == 0 ) || ( addType == PATH_ADD_TO_TAIL ) )
{
return; // this entry is already at the head
}
else
{
m_SearchPaths.Remove(i); // remove it from its current position so we can add it back to the head
i--;
c--;
}
}
if ( !id && pSearchPath->GetPath() == pathSym )
{
// get first found - all reference the same store
id = pSearchPath->m_storeId;
}
}
if (!id)
{
id = g_iNextSearchPathID++;
}
if ( IsX360() && bAddPackFiles && ( !Q_stricmp( pathID, "DEFAULT_WRITE_PATH" ) || !Q_stricmp( pathID, "LOGDIR" ) ) )
{
// xbox can be assured that no zips would ever be loaded on its write path
// otherwise xbox reloads zips because of mirrored drive mappings
bAddPackFiles = false;
}
// Add to list
bool bAdded = false;
int nIndex = m_SearchPaths.Count();
if ( bAddPackFiles )
{
// Add pack files for this path next
AddPackFiles( newPath, pathIDSym, addType );
bAdded = m_SearchPaths.Count() != nIndex;
}
if ( addType == PATH_ADD_TO_HEAD )
{
nIndex = m_SearchPaths.Count() - nIndex;
Assert( nIndex >= 0 );
}
if ( IsPC() || !bAddPackFiles || !bAdded )
{
// Grab last entry and set the path
m_SearchPaths.InsertBefore( nIndex );
}
else if ( IsX360() && bAddPackFiles && bAdded )
{
// 360 needs to find files (for the preload hit) in the zip first for fast loading
// 360 always adds the non-pack search path *after* the pack file but respects the overall list ordering
if ( addType == PATH_ADD_TO_HEAD )
{
m_SearchPaths.InsertBefore( nIndex );
}
else
{
nIndex = m_SearchPaths.Count() - 1;
m_SearchPaths.InsertAfter( nIndex );
nIndex++;
}
}
CSearchPath *sp = &m_SearchPaths[ nIndex ];
sp->SetPath( pathSym );
sp->m_pPathIDInfo = FindOrAddPathIDInfo( pathIDSym, -1 );
// all matching paths have a reference to the same store
sp->m_storeId = id;
if ( IsX360() && !V_strnicmp( newPath, "net:", 4 ) )
{
sp->m_bIsRemotePath = true;
}
}
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath *CBaseFileSystem::FindSearchPathByStoreId( int storeId )
{
FOR_EACH_VEC( m_SearchPaths, i )
{
if ( m_SearchPaths[i].m_storeId == storeId )
return &m_SearchPaths[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Create the search path.
//-----------------------------------------------------------------------------
void CBaseFileSystem::AddSearchPath( const char *pPath, const char *pathID, SearchPathAdd_t addType )
{
int currCount = m_SearchPaths.Count();
AddSearchPathInternal( pPath, pathID, addType, true );
if ( IsX360() && m_DVDMode == DVDMODE_DEV )
{
// dvd development mode clones a search path based on the remote path for fall through
const char *pRemotePath = CommandLine()->ParmValue( "-remote" );
const char *pBasePath = CommandLine()->ParmValue( "-basedir" );
if ( pRemotePath && pBasePath && !V_stristr( pPath, ".bsp" ) )
{
// isolate the search path from the base path
if ( !V_strnicmp( pPath, pBasePath, strlen( pBasePath ) ) )
{
// substitue the remote path
char szRemotePath[MAX_PATH];
V_strncpy( szRemotePath, pRemotePath, sizeof( szRemotePath ) );
V_strncat( szRemotePath, pPath + strlen( pBasePath ), sizeof( szRemotePath ) );
// no pack files are allowed on the fall through remote path
AddSearchPathInternal( szRemotePath, pathID, addType, false );
}
}
}
if ( currCount != m_SearchPaths.Count() )
{
#if !defined( DEDICATED )
if ( IsDebug() )
{
// spew updated search paths
// PrintSearchPaths();
}
#endif
}
}
//-----------------------------------------------------------------------------
// Returns the search path, each path is separated by ;s. Returns the length of the string returned
// Pack search paths include the pack name, so that callers can still form absolute paths
// and that absolute path can be sent to the filesystem, and mounted as a file inside a pack.
//-----------------------------------------------------------------------------
int CBaseFileSystem::GetSearchPath( const char *pathID, bool bGetPackFiles, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars )
{
AUTO_LOCK( m_SearchPathsMutex );
if ( maxLenInChars )
{
pDest[0] = 0;
}
// Build up result into string object
CUtlString sResult;
CSearchPathsIterator iter( this, pathID, bGetPackFiles ? FILTER_NONE : FILTER_CULLPACK );
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
if ( !sResult.IsEmpty() )
sResult += ";";
CUtlString sName;
if ( pSearchPath->GetPackFile() )
{
sResult += pSearchPath->GetPackFile()->m_ZipName.String();
sResult += CORRECT_PATH_SEPARATOR_S;
}
#ifdef SUPPORT_PACKED_STORE
else if ( pSearchPath->GetPackedStore() )
{
sResult += pSearchPath->GetPackedStore()->FullPathName();
}
#endif
else
{
sResult += pSearchPath->GetPathString();
}
}
// Copy into user's buffer, possibly truncating
if ( maxLenInChars )
{
V_strncpy( pDest, sResult.String(), maxLenInChars );
}
// Return 1 extra for the NULL terminator
return sResult.Length()+1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPath -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::RemoveSearchPath( const char *pPath, const char *pathID )
{
AsyncFinishAll();
char newPath[ MAX_FILEPATH ];
newPath[ 0 ] = 0;
if ( pPath )
{
// +2 for '\0' and potential slash added at end.
Q_strncpy( newPath, pPath, sizeof( newPath ) );
#ifdef _WIN32 // don't do this on linux!
Q_strlower( newPath );
#endif
if ( V_stristr( newPath, ".bsp" ) )
{
Q_FixSlashes( newPath );
}
else if ( V_stristr( newPath, ".vpk" ) )
{
return RemoveVPKFile( newPath, pathID );
}
else
{
AddSeperatorAndFixPath( newPath );
}
}
CUtlSymbol lookup = g_PathIDTable.AddString( newPath );
CUtlSymbol id = g_PathIDTable.AddString( pathID );
bool bret = false;
// Count backward since we're possibly deleting one or more pack files, too
int i;
int c = m_SearchPaths.Count();
for( i = c - 1; i >= 0; i-- )
{
if ( newPath[0] && m_SearchPaths[i].GetPath() != lookup )
continue;
if ( FilterByPathID( &m_SearchPaths[i], id ) )
continue;
m_SearchPaths.Remove( i );
bret = true;
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose: Removes all search paths for a given pathID, such as all "GAME" paths.
// Input : pathID -
//-----------------------------------------------------------------------------
void CBaseFileSystem::RemoveSearchPaths( const char *pathID )
{
AsyncFinishAll();
int nCount = m_SearchPaths.Count();
for (int i = nCount - 1; i >= 0; i--)
{
if (!Q_stricmp(m_SearchPaths.Element(i).GetPathIDString(), pathID))
{
m_SearchPaths.FastRemove(i);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath *CBaseFileSystem::FindWritePath( const char *pFilename, const char *pathID )
{
CUtlSymbol lookup = g_PathIDTable.AddString( pathID );
AUTO_LOCK( m_SearchPathsMutex );
// a pathID has been specified, find the first match in the path list
int c = m_SearchPaths.Count();
for ( int i = 0; i < c; i++ )
{
// pak files are not allowed to be written to...
CSearchPath *pSearchPath = &m_SearchPaths[i];
if ( pSearchPath->GetPackFile() || pSearchPath->GetPackedStore() )
{
continue;
}
if ( IsX360() && ( m_DVDMode == DVDMODE_DEV ) && pFilename && !pSearchPath->m_bIsRemotePath )
{
bool bIgnorePath = false;
char szExcludePath[MAX_PATH];
char szFilename[MAX_PATH];
V_ComposeFileName( pSearchPath->GetPathString(), pFilename, szFilename, sizeof( szFilename ) );
for ( int j = 0; j < m_ExcludePaths.Count(); j++ )
{
if ( g_pFullFileSystem->String( m_ExcludePaths[j], szExcludePath, sizeof( szExcludePath ) ) )
{
if ( !V_strnicmp( szFilename, szExcludePath, strlen( szExcludePath ) ) )
{
bIgnorePath = true;
break;
}
}
}
if ( bIgnorePath )
{
// filename matches exclusion path, skip it
// favoring the next path which should be the path fall through hit
continue;
}
}
if ( !pathID || ( pSearchPath->GetPathID() == lookup ) )
{
return pSearchPath;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Finds a search path that should be used for writing to, given a pathID.
//-----------------------------------------------------------------------------
const char *CBaseFileSystem::GetWritePath( const char *pFilename, const char *pathID )
{
CSearchPath *pSearchPath = NULL;
if ( pathID && pathID[ 0 ] != '\0' )
{
// Check for "game_write" and "mod_write"
if ( V_stricmp( pathID, "game" ) == 0 )
pSearchPath = FindWritePath( pFilename, "game_write" );
else if ( V_stricmp( pathID, "mod" ) == 0 )
pSearchPath = FindWritePath( pFilename, "mod_write" );
if ( pSearchPath == NULL )
pSearchPath = FindWritePath( pFilename, pathID );
if ( pSearchPath )
{
return pSearchPath->GetPathString();
}
Warning( FILESYSTEM_WARNING, "Requested non-existent write path %s!\n", pathID );
}
pSearchPath = FindWritePath( pFilename, "DEFAULT_WRITE_PATH" );
if ( pSearchPath )
{
return pSearchPath->GetPathString();
}
pSearchPath = FindWritePath( pFilename, NULL ); // okay, just return the first search path added!
if ( pSearchPath )
{
return pSearchPath->GetPathString();
}
// Hope this is reasonable!!
return ".\\";
}
//-----------------------------------------------------------------------------
// Reads/writes files to utlbuffers. Attempts alignment fixups for optimal read
//-----------------------------------------------------------------------------
amd64: fix multithread, fix vgui, fix physmodels
2 years ago
CTHREADLOCAL(char *) g_pszReadFilename;
1
5 years ago
bool CBaseFileSystem::ReadToBuffer( FileHandle_t fp, CUtlBuffer &buf, int nMaxBytes, FSAllocFunc_t pfnAlloc )
{
SetBufferSize( fp, 0 ); // TODO: what if it's a pack file? restore buffer size?
int nBytesToRead = Size( fp );
if ( nBytesToRead == 0 )
{
// no data in file
return true;
}
if ( nMaxBytes > 0 )
{
// can't read more than file has
nBytesToRead = min( nMaxBytes, nBytesToRead );
}
int nBytesRead = 0;
int nBytesOffset = 0;
int iStartPos = Tell( fp );
if ( nBytesToRead != 0 )
{
int nBytesDestBuffer = nBytesToRead;
unsigned nSizeAlign = 0, nBufferAlign = 0, nOffsetAlign = 0;
bool bBinary = !( buf.IsText() && !buf.ContainsCRLF() );
if ( bBinary && !IsLinux() && !buf.IsExternallyAllocated() && !pfnAlloc &&
( buf.TellPut() == 0 ) && ( buf.TellGet() == 0 ) && ( iStartPos % 4 == 0 ) &&
GetOptimalIOConstraints( fp, &nOffsetAlign, &nSizeAlign, &nBufferAlign ) )
{
// correct conditions to allow an optimal read
if ( iStartPos % nOffsetAlign != 0 )
{
// move starting position back to nearest alignment
nBytesOffset = ( iStartPos % nOffsetAlign );
Assert ( ( iStartPos - nBytesOffset ) % nOffsetAlign == 0 );
Seek( fp, -nBytesOffset, FILESYSTEM_SEEK_CURRENT );
// going to read from aligned start, increase target buffer size by offset alignment
nBytesDestBuffer += nBytesOffset;
}
// snap target buffer size to its size alignment
// add additional alignment slop for target pointer adjustment
nBytesDestBuffer = AlignValue( nBytesDestBuffer, nSizeAlign ) + nBufferAlign;
}
if ( !pfnAlloc )
{
buf.EnsureCapacity( nBytesDestBuffer + buf.TellPut() );
}
else
{
// caller provided allocator
void *pMemory = (*pfnAlloc)( g_pszReadFilename.Get(), nBytesDestBuffer );
buf.SetExternalBuffer( pMemory, nBytesDestBuffer, 0, buf.GetFlags() & ~CUtlBuffer::EXTERNAL_GROWABLE );
}
int seekGet = -1;
if ( nBytesDestBuffer != nBytesToRead )
{
// doing optimal read, align target pointer
int nAlignedBase = AlignValue( (byte *)buf.Base(), nBufferAlign ) - (byte *)buf.Base();
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nAlignedBase );
// the buffer read position is slid forward to ignore the addtional
// starting offset alignment
seekGet = nAlignedBase + nBytesOffset;
}
nBytesRead = ReadEx( buf.PeekPut(), buf.Size() - buf.TellPut(), nBytesToRead + nBytesOffset, fp );
buf.SeekPut( CUtlBuffer::SEEK_CURRENT, nBytesRead );
if ( seekGet != -1 )
{
// can only seek the get after data has been put, otherwise buffer sets overflow error
buf.SeekGet( CUtlBuffer::SEEK_HEAD, seekGet );
}
Seek( fp, iStartPos + ( nBytesRead - nBytesOffset ), FILESYSTEM_SEEK_HEAD );
}
return (nBytesRead != 0);
}
//-----------------------------------------------------------------------------
// Reads/writes files to utlbuffers
// NOTE NOTE!!
// If you change this implementation, copy it into CBaseVMPIFileSystem::ReadFile
// in vmpi_filesystem.cpp
//-----------------------------------------------------------------------------
bool CBaseFileSystem::ReadFile( const char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes, int nStartingByte, FSAllocFunc_t pfnAlloc )
{
CHECK_DOUBLE_SLASHES( pFileName );
bool bBinary = !( buf.IsText() && !buf.ContainsCRLF() );
FileHandle_t fp = Open( pFileName, ( bBinary ) ? "rb" : "rt", pPath );
if ( !fp )
return false;
if ( nStartingByte != 0 )
{
Seek( fp, nStartingByte, FILESYSTEM_SEEK_HEAD );
}
if ( pfnAlloc )
{
g_pszReadFilename.Set( (char *)pFileName );
}
bool bSuccess = ReadToBuffer( fp, buf, nMaxBytes, pfnAlloc );
Close( fp );
return bSuccess;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CBaseFileSystem::ReadFileEx( const char *pFileName, const char *pPath, void **ppBuf, bool bNullTerminate, bool bOptimalAlloc, int nMaxBytes, int nStartingByte, FSAllocFunc_t pfnAlloc )
{
FileHandle_t fp = Open( pFileName, "rb", pPath );
if ( !fp )
{
return 0;
}
if ( IsX360() )
{
// callers are sloppy, always want optimal
bOptimalAlloc = true;
}
SetBufferSize( fp, 0 ); // TODO: what if it's a pack file? restore buffer size?
int nBytesToRead = Size( fp );
int nBytesRead = 0;
if ( nMaxBytes > 0 )
{
nBytesToRead = min( nMaxBytes, nBytesToRead );
if ( bNullTerminate )
{
nBytesToRead--;
}
}
if ( nBytesToRead != 0 )
{
int nBytesBuf;
if ( !*ppBuf )
{
nBytesBuf = nBytesToRead + ( ( bNullTerminate ) ? 1 : 0 );
if ( !pfnAlloc && !bOptimalAlloc )
{
// AllocOptimalReadBuffer does malloc...
*ppBuf = malloc( nBytesBuf );
}
else if ( !pfnAlloc )
{
*ppBuf = AllocOptimalReadBuffer( fp, nBytesBuf, 0 );
nBytesBuf = GetOptimalReadSize( fp, nBytesBuf );
}
else
{
*ppBuf = (*pfnAlloc)( pFileName, nBytesBuf );
}
}
else
{
nBytesBuf = nMaxBytes;
}
if ( nStartingByte != 0 )
{
Seek( fp, nStartingByte, FILESYSTEM_SEEK_HEAD );
}
nBytesRead = ReadEx( *ppBuf, nBytesBuf, nBytesToRead, fp );
if ( bNullTerminate )
{
((byte *)(*ppBuf))[nBytesToRead] = 0;
}
}
Close( fp );
return nBytesRead;
}
//-----------------------------------------------------------------------------
// NOTE NOTE!!
// If you change this implementation, copy it into CBaseVMPIFileSystem::WriteFile
// in vmpi_filesystem.cpp
//-----------------------------------------------------------------------------
bool CBaseFileSystem::WriteFile( const char *pFileName, const char *pPath, CUtlBuffer &buf )
{
CHECK_DOUBLE_SLASHES( pFileName );
const char *pWriteFlags = "wb";
if ( buf.IsText() && !buf.ContainsCRLF() )
{
pWriteFlags = "wt";
}
FileHandle_t fp = Open( pFileName, pWriteFlags, pPath );
if ( !fp )
return false;
int nBytesWritten = Write( buf.Base(), buf.TellPut(), fp );
Close( fp );
return (nBytesWritten == buf.TellPut());
}
bool CBaseFileSystem::UnzipFile( const char *pFileName, const char *pPath, const char *pDestination )
{
IZip *pZip = IZip::CreateZip( NULL, true );
HANDLE hZipFile = pZip->ParseFromDisk( pFileName );
if ( !hZipFile )
{
Msg( "Bad or missing zip file, failed to open '%s'\n", pFileName );
return false;
}
int iZipIndex = -1;
int iFileSize;
char szFileName[MAX_PATH];
// Create Directories
CreateDirHierarchy( pDestination, pPath );
while ( 1 )
{
// Get the next file in the zip
szFileName[0] = '\0';
iFileSize = 0;
iZipIndex = pZip->GetNextFilename( iZipIndex, szFileName, sizeof( szFileName ), iFileSize );
// If there aren't any more files then break out of this while
if ( iZipIndex == -1 )
break;
int iFileNameLength = Q_strlen( szFileName );
if ( szFileName[ iFileNameLength - 1 ] == '/' )
{
// Its a directory, so create it
szFileName[ iFileNameLength - 1 ] = '\0';
char szFinalName[ MAX_PATH ];
Q_snprintf( szFinalName, sizeof( szFinalName ), "%s%c%s", pDestination, CORRECT_PATH_SEPARATOR, szFileName );
CreateDirHierarchy( szFinalName, pPath );
}
}
// Write Files
while ( 1 )
{
szFileName[0] = '\0';
iFileSize = 0;
iZipIndex = pZip->GetNextFilename( iZipIndex, szFileName, sizeof( szFileName ), iFileSize );
// If there aren't any more files then break out of this while
if ( iZipIndex == -1 )
break;
int iFileNameLength = Q_strlen( szFileName );
if ( szFileName[ iFileNameLength - 1 ] != '/' )
{
// It's not a directory, so write the file
CUtlBuffer fileBuffer;
fileBuffer.Purge();
if ( pZip->ReadFileFromZip( hZipFile, szFileName, false, fileBuffer ) )
{
char szFinalName[ MAX_PATH ];
Q_snprintf( szFinalName, sizeof( szFinalName ), "%s%c%s", pDestination, CORRECT_PATH_SEPARATOR, szFileName );
// Make sure the directory actually exists in case the ZIP doesn't list it (our zip utils create zips like this)
char szFilePath[ MAX_PATH ];
Q_strncpy( szFilePath, szFinalName, sizeof(szFilePath) );
Q_StripFilename( szFilePath );
CreateDirHierarchy( szFilePath, pPath );
WriteFile( szFinalName, pPath, fileBuffer );
}
}
}
#ifdef WIN32
::CloseHandle( hZipFile );
#else
fclose( (FILE *)hZipFile );
#endif
IZip::ReleaseZip( pZip );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::RemoveAllSearchPaths( void )
{
AUTO_LOCK( m_SearchPathsMutex );
m_SearchPaths.Purge();
//m_PackFileHandles.Purge();
}
void CBaseFileSystem::LogFileAccess( const char *pFullFileName )
{
if( !m_pLogFile )
{
return;
}
char buf[1024];
#if BSPOUTPUT
Q_snprintf( buf, sizeof( buf ), "%s\n%s\n", pShortFileName, pFullFileName);
fprintf( m_pLogFile, "%s", buf ); // STEAM OK
#else
char cwd[MAX_FILEPATH];
getcwd( cwd, MAX_FILEPATH-1 );
Q_strcat( cwd, "\\", sizeof( cwd ) );
if( Q_strnicmp( cwd, pFullFileName, strlen( cwd ) ) == 0 )
{
const char *pFileNameWithoutExeDir = pFullFileName + strlen( cwd );
char targetPath[ MAX_FILEPATH ];
strcpy( targetPath, "%fs_target%\\" );
strcat( targetPath, pFileNameWithoutExeDir );
Q_snprintf( buf, sizeof( buf ), "copy \"%s\" \"%s\"\n", pFullFileName, targetPath );
char tmp[ MAX_FILEPATH ];
Q_strncpy( tmp, targetPath, sizeof( tmp ) );
Q_StripFilename( tmp );
fprintf( m_pLogFile, "mkdir \"%s\"\n", tmp ); // STEAM OK
fprintf( m_pLogFile, "%s", buf ); // STEAM OK
}
else
{
Assert( 0 );
}
#endif
}
class CPackedStore;
class CFileOpenInfo
{
public:
CFileOpenInfo( CBaseFileSystem *pFileSystem, const char *pFileName, const CBaseFileSystem::CSearchPath *path, const char *pOptions, int flags, char **ppszResolvedFilename ) :
m_pFileSystem( pFileSystem ), m_pFileName( pFileName ), m_pSearchPath( path ), m_pOptions( pOptions ), m_Flags( flags ), m_ppszResolvedFilename( ppszResolvedFilename )
{
m_pFileHandle = NULL;
m_ePureFileClass = ePureServerFileClass_Any;
if ( m_pFileSystem->m_pPureServerWhitelist )
{
m_ePureFileClass = m_pFileSystem->m_pPureServerWhitelist->GetFileClass( pFileName );
}
if ( m_ppszResolvedFilename )
*m_ppszResolvedFilename = NULL;
m_pPackFile = NULL;
m_pVPKFile = NULL;
m_AbsolutePath[0] = '\0';
}
~CFileOpenInfo()
{
if ( IsX360() )
{
return;
}
}
void SetAbsolutePath( const char *pFormat, ... )
{
va_list marker;
va_start( marker, pFormat );
V_vsnprintf( m_AbsolutePath, sizeof( m_AbsolutePath ), pFormat, marker );
va_end( marker );
V_FixSlashes( m_AbsolutePath );
}
void SetResolvedFilename( const char *pStr )
{
if ( m_ppszResolvedFilename )
{
Assert( !( *m_ppszResolvedFilename ) );
*m_ppszResolvedFilename = strdup( pStr );
}
}
// Handles telling CFileTracker about the file we just opened so it can remember
// where the file came from, and possibly calculate a CRC if necessary.
void HandleFileCRCTracking( const char *pRelativeFileName )
{
if ( IsX360() )
{
return;
}
if ( m_pFileSystem->m_WhitelistFileTrackingEnabled == 0 )
return;
if ( m_pFileHandle && m_pSearchPath )
{
FILE *fp = m_pFileHandle->m_pFile;
int64 nLength = m_pFileHandle->m_nLength;
#ifdef SUPPORT_PACKED_STORE
if ( m_pVPKFile )
{
m_pFileSystem->m_FileTracker2.NotePackFileAccess( pRelativeFileName, m_pSearchPath->GetPathIDString(), m_pSearchPath->m_storeId, m_pFileHandle->m_VPKHandle );
return;
}
#endif
// we always record hashes of everything we load. we may filter later.
m_pFileSystem->m_FileTracker2.NoteFileLoadedFromDisk( pRelativeFileName, m_pSearchPath->GetPathIDString(), m_pSearchPath->m_storeId, fp, nLength );
}
}
#ifdef SUPPORT_PACKED_STORE
void SetFromPackedStoredFileHandle( const CPackedStoreFileHandle &fHandle, CBaseFileSystem *pFileSystem )
{
Assert( fHandle );
Assert( m_pFileHandle == NULL );
m_pFileHandle = new CFileHandle(pFileSystem);
m_pFileHandle->m_VPKHandle = fHandle;
m_pFileHandle->m_type = FT_NORMAL;
m_pFileHandle->m_nLength = fHandle.m_nFileSize;
}
#endif
public:
CBaseFileSystem *m_pFileSystem;
// These are output parameters.
CFileHandle *m_pFileHandle;
char **m_ppszResolvedFilename;
CPackFile *m_pPackFile;
CPackedStore *m_pVPKFile;
const char *m_pFileName;
const CBaseFileSystem::CSearchPath *m_pSearchPath;
const char *m_pOptions;
int m_Flags;
EPureServerFileClass m_ePureFileClass;
char m_AbsolutePath[MAX_FILEPATH]; // This is set
};
void CBaseFileSystem::HandleOpenRegularFile( CFileOpenInfo &openInfo, bool bIsAbsolutePath )
{
openInfo.m_pFileHandle = NULL;
int64 size;
FILE *fp = Trace_FOpen( openInfo.m_AbsolutePath, openInfo.m_pOptions, openInfo.m_Flags, &size );
if ( fp )
{
if ( m_pLogFile )
{
LogFileAccess( openInfo.m_AbsolutePath );
}
if ( m_bOutputDebugString )
{
#ifdef _WIN32
Plat_DebugString( "fs_debug: " );
Plat_DebugString( openInfo.m_AbsolutePath );
Plat_DebugString( "\n" );
#elif POSIX
fprintf(stderr, "fs_debug: %s\n", openInfo.m_AbsolutePath );
#endif
}
openInfo.m_pFileHandle = new CFileHandle(this);
openInfo.m_pFileHandle->m_pFile = fp;
openInfo.m_pFileHandle->m_type = FT_NORMAL;
openInfo.m_pFileHandle->m_nLength = size;
openInfo.SetResolvedFilename( openInfo.m_AbsolutePath );
LogFileOpen( "Loose", openInfo.m_pFileName, openInfo.m_AbsolutePath );
}
}
//-----------------------------------------------------------------------------
// Purpose: The base file search goes through here
// Input : *path -
// *pFileName -
// *pOptions -
// packfile -
// *filetime -
// Output : FileHandle_t
//-----------------------------------------------------------------------------
FileHandle_t CBaseFileSystem::FindFileInSearchPath( CFileOpenInfo &openInfo )
{
VPROF( "CBaseFileSystem::FindFile" );
Assert( openInfo.m_pSearchPath );
openInfo.m_pFileHandle = NULL;
// Loading from pack file?
CPackFile *pPackFile = openInfo.m_pSearchPath->GetPackFile();
if ( pPackFile )
{
openInfo.m_pFileHandle = pPackFile->OpenFile( openInfo.m_pFileName, openInfo.m_pOptions );
openInfo.m_pPackFile = pPackFile;
if ( openInfo.m_pFileHandle )
{
char tempStr[MAX_PATH*2+2];
V_snprintf( tempStr, sizeof( tempStr ), "%s%c%s", pPackFile->m_ZipName.String(), CORRECT_PATH_SEPARATOR, openInfo.m_pFileName );
openInfo.SetResolvedFilename( tempStr );
}
// If it's a BSP file, then the BSP file got CRC'd elsewhere so no need to verify stuff in there.
return (FileHandle_t)openInfo.m_pFileHandle;
}
// Loading from VPK?
#ifdef SUPPORT_PACKED_STORE
CPackedStore *pVPK = openInfo.m_pSearchPath->GetPackedStore();
if ( pVPK )
{
CPackedStoreFileHandle fHandle = pVPK->OpenFile( openInfo.m_pFileName );
if ( fHandle )
{
openInfo.SetFromPackedStoredFileHandle( fHandle, this );
openInfo.SetResolvedFilename( openInfo.m_pFileName );
openInfo.m_pVPKFile = pVPK;
LogFileOpen( "VPK", openInfo.m_pFileName, pVPK->BaseName() );
openInfo.HandleFileCRCTracking( openInfo.m_pFileName );
return ( FileHandle_t ) openInfo.m_pFileHandle;
}
return NULL;
}
#endif
// Load loose file specified as relative filename
// Convert filename to lowercase. All files in the
// game logical filesystem must be accessed by lowercase name
char szLowercaseFilename[ MAX_PATH ];
V_strcpy_safe( szLowercaseFilename, openInfo.m_pFileName );
V_strlower( szLowercaseFilename );
openInfo.SetAbsolutePath( "%s%s", openInfo.m_pSearchPath->GetPathString(), szLowercaseFilename );
// now have an absolute name
HandleOpenRegularFile( openInfo, false );
return (FileHandle_t)openInfo.m_pFileHandle;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
FileHandle_t CBaseFileSystem::OpenForRead( const char *pFileNameT, const char *pOptions, unsigned flags, const char *pathID, char **ppszResolvedFilename )
{
VPROF( "CBaseFileSystem::OpenForRead" );
char pFileNameBuff[MAX_PATH];
const char *pFileName = pFileNameBuff;
FixUpPath ( pFileNameT, pFileNameBuff, sizeof( pFileNameBuff ) );
// Try the memory cache for un-restricted searches or "GAME" items.
if ( !pathID || Q_stricmp( pathID, "GAME" ) == 0 )
{
CMemoryFileBacking* pBacking = NULL;
{
AUTO_LOCK( m_MemoryFileMutex );
CUtlHashtable< const char*, CMemoryFileBacking* >& table = m_MemoryFileHash;
UtlHashHandle_t idx = table.Find( pFileName );
if ( idx != table.InvalidHandle() )
{
pBacking = table[idx];
pBacking->AddRef();
}
}
if ( pBacking )
{
if ( pBacking->m_nLength != -1 )
{
CFileHandle* pFile = new CMemoryFileHandle( this, pBacking );
pFile->m_type = strstr( pOptions, "b" ) ? FT_MEMORY_BINARY : FT_MEMORY_TEXT;
return ( FileHandle_t )pFile;
}
else
{
// length -1 == cached failure to read
return ( FileHandle_t )NULL;
}
}
else if ( ThreadInMainThread() && fs_report_sync_opens.GetInt() > 0 )
{
DevWarning("blocking load %s\n", pFileName);
}
}
CFileOpenInfo openInfo( this, pFileName, NULL, pOptions, flags, ppszResolvedFilename );
// Already have an absolute path?
// If so, don't bother iterating search paths.
if ( V_IsAbsolutePath( pFileName ) )
{
openInfo.SetAbsolutePath( "%s", pFileName );
// Check if it's of the form C:/a/b/c/blah.zip/materials/blah.vtf
// an absolute path can encode a zip pack file (i.e. caller wants to open the file from within the pack file)
// format must strictly be ????.zip\????
// assuming a reasonable restriction that the zip must be a pre-existing search path zip
char *pZipExt = V_stristr( openInfo.m_AbsolutePath, ".zip" CORRECT_PATH_SEPARATOR_S );
if ( !pZipExt )
pZipExt = V_stristr( openInfo.m_AbsolutePath, ".bsp" CORRECT_PATH_SEPARATOR_S );
#if defined( SUPPORT_PACKED_STORE )
if ( !pZipExt )
pZipExt = V_stristr( openInfo.m_AbsolutePath, ".vpk" CORRECT_PATH_SEPARATOR_S );
#endif
if ( pZipExt && pZipExt[5] )
{
// Cut string at the slash
char *pSlash = pZipExt + 4;
Assert( *pSlash == CORRECT_PATH_SEPARATOR );
*pSlash = '\0';
// want relative portion only, everything after the slash
char *pRelativeFileName = pSlash + 1;
// Find the zip or VPK in the search paths
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
// In VPK?
#if defined( SUPPORT_PACKED_STORE )
CPackedStore *pVPK = m_SearchPaths[i].GetPackedStore();
if ( pVPK )
{
if ( V_stricmp( pVPK->FullPathName(), openInfo.m_AbsolutePath ) == 0 )
{
CPackedStoreFileHandle fHandle = pVPK->OpenFile( pRelativeFileName );
if ( fHandle )
{
openInfo.m_pSearchPath = &m_SearchPaths[i];
openInfo.SetFromPackedStoredFileHandle( fHandle, this );
}
break;
}
continue;
}
#endif
// In .zip?
CPackFile *pPackFile = m_SearchPaths[i].GetPackFile();
if ( pPackFile )
{
if ( Q_stricmp( pPackFile->m_ZipName.Get(), openInfo.m_AbsolutePath ) == 0 )
{
openInfo.m_pSearchPath = &m_SearchPaths[i];
openInfo.m_pFileHandle = pPackFile->OpenFile( pRelativeFileName, openInfo.m_pOptions );
openInfo.m_pPackFile = pPackFile;
break;
}
}
}
if ( openInfo.m_pFileHandle )
{
openInfo.SetResolvedFilename( openInfo.m_pFileName );
openInfo.HandleFileCRCTracking( pRelativeFileName );
}
return (FileHandle_t)openInfo.m_pFileHandle;
}
// Otherwise, it must be a regular file, specified by absolute filename
HandleOpenRegularFile( openInfo, true );
// !FIXME! We probably need to deal with CRC tracking, right?
return (FileHandle_t)openInfo.m_pFileHandle;
}
// Run through all the search paths.
PathTypeFilter_t pathFilter = FILTER_NONE;
if ( IsX360() )
{
if ( flags & FSOPEN_NEVERINPACK )
{
pathFilter = FILTER_CULLPACK;
}
else if ( m_DVDMode == DVDMODE_STRICT )
{
// most all files on the dvd are expected to be in the pack
// don't allow disk paths to be searched, which is very expensive on the dvd
pathFilter = FILTER_CULLNONPACK;
}
}
CSearchPathsIterator iter( this, &pFileName, pathID, pathFilter );
for ( openInfo.m_pSearchPath = iter.GetFirst(); openInfo.m_pSearchPath != NULL; openInfo.m_pSearchPath = iter.GetNext() )
{
FileHandle_t filehandle = FindFileInSearchPath( openInfo );
if ( filehandle )
{
// Check if search path is excluded due to pure server white list,
// then we should make a note of this fact, and keep searching
if ( !openInfo.m_pSearchPath->m_bIsTrustedForPureServer && openInfo.m_ePureFileClass == ePureServerFileClass_AnyTrusted )
{
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Ignoring %s from %s for pure server operation\n", openInfo.m_pFileName, openInfo.m_pSearchPath->GetDebugString() );
#endif
m_FileTracker2.NoteFileIgnoredForPureServer( openInfo.m_pFileName, pathID, openInfo.m_pSearchPath->m_storeId );
Close( filehandle );
openInfo.m_pFileHandle = NULL;
if ( ppszResolvedFilename && *ppszResolvedFilename )
{
free( *ppszResolvedFilename );
*ppszResolvedFilename = NULL;
}
continue;
}
//
openInfo.HandleFileCRCTracking( openInfo.m_pFileName );
return filehandle;
}
}
LogFileOpen( "[Failed]", pFileName, "" );
return ( FileHandle_t )0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
FileHandle_t CBaseFileSystem::OpenForWrite( const char *pFileName, const char *pOptions, const char *pathID )
{
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pathID, tempPathID );
if ( ThreadInMainThread() && fs_report_sync_opens.GetInt() )
{
DevWarning("blocking write %s\n", pFileName);
}
// Opening for write or append uses the write path
// Unless an absolute path is specified...
const char *pTmpFileName;
char szScratchFileName[MAX_PATH];
if ( Q_IsAbsolutePath( pFileName ) )
{
pTmpFileName = pFileName;
}
else
{
ComputeFullWritePath( szScratchFileName, sizeof( szScratchFileName ), pFileName, pathID );
pTmpFileName = szScratchFileName;
}
int64 size;
FILE *fp = Trace_FOpen( pTmpFileName, pOptions, 0, &size );
if ( !fp )
{
return ( FileHandle_t )0;
}
CFileHandle *fh = new CFileHandle( this );
fh->m_nLength = size;
fh->m_type = FT_NORMAL;
fh->m_pFile = fp;
return ( FileHandle_t )fh;
}
// This looks for UNC-type filename specifiers, which should be used instead of
// passing in path ID. So if it finds //mod/cfg/config.cfg, it translates
// pFilename to "cfg/config.cfg" and pPathID to "mod" (mod is placed in tempPathID).
void CBaseFileSystem::ParsePathID( const char* &pFilename, const char* &pPathID, char tempPathID[MAX_PATH] )
{
tempPathID[0] = 0;
if ( !pFilename || pFilename[0] == 0 )
return;
// FIXME: Pain! Backslashes are used to denote network drives, forward to denote path ids
// HOORAY! We call FixSlashes everywhere. That will definitely not work
// I'm not changing it yet though because I don't know how painful the bugs would be that would be generated
bool bIsForwardSlash = ( pFilename[0] == '/' && pFilename[1] == '/' );
// bool bIsBackwardSlash = ( pFilename[0] == '\\' && pFilename[1] == '\\' );
if ( !bIsForwardSlash ) //&& !bIsBackwardSlash )
return;
// They're specifying two path IDs. Ignore the one passed-in.
if ( pPathID )
{
Warning( FILESYSTEM_WARNING, "FS: Specified two path IDs (%s, %s).\n", pFilename, pPathID );
}
// Parse out the path ID.
const char *pIn = &pFilename[2];
char *pOut = tempPathID;
while ( *pIn && !PATHSEPARATOR( *pIn ) && (pOut - tempPathID) < (MAX_PATH-1) )
{
*pOut++ = *pIn++;
}
*pOut = 0;
if ( tempPathID[0] == '*' )
{
// * means NULL.
pPathID = NULL;
}
else
{
pPathID = tempPathID;
}
// Move pFilename up past the part with the path ID.
if ( *pIn == 0 )
pFilename = pIn;
else
pFilename = pIn + 1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
FileHandle_t CBaseFileSystem::Open( const char *pFileName, const char *pOptions, const char *pathID )
{
return OpenEx( pFileName, pOptions, 0, pathID );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
FileHandle_t CBaseFileSystem::OpenEx( const char *pFileName, const char *pOptions, unsigned flags, const char *pathID, char **ppszResolvedFilename )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s(%s, %s, %u %s )", __FUNCTION__, tmDynamicString( TELEMETRY_LEVEL0, pFileName ), tmDynamicString( TELEMETRY_LEVEL0, pOptions ), flags, tmDynamicString( TELEMETRY_LEVEL0, pathID ) );
VPROF_BUDGET( "CBaseFileSystem::Open", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
if ( !pFileName )
return (FileHandle_t)0;
CHECK_DOUBLE_SLASHES( pFileName );
if ( ThreadInMainThread() && fs_report_sync_opens.GetInt() > 1 )
{
::Warning( "Open( %s )\n", pFileName );
}
// Allow for UNC-type syntax to specify the path ID.
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pathID, tempPathID );
// Try each of the search paths in succession
// FIXME: call createdirhierarchy upon opening for write.
if ( strstr( pOptions, "r" ) && !strstr( pOptions, "+" ) )
{
return OpenForRead( pFileName, pOptions, flags, pathID, ppszResolvedFilename );
}
return OpenForWrite( pFileName, pOptions, pathID );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::Close( FileHandle_t file )
{
VPROF_BUDGET( "CBaseFileSystem::Close", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
if ( !file )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Close NULL file handle!\n" );
return;
}
delete (CFileHandle*)file;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::Seek( FileHandle_t file, int pos, FileSystemSeek_t whence )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s (pos=%d, whence=%d)", __FUNCTION__, pos, whence );
VPROF_BUDGET( "CBaseFileSystem::Seek", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "Tried to Seek NULL file handle!\n" );
return;
}
fh->Seek( pos, whence );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// Output : unsigned int
//-----------------------------------------------------------------------------
unsigned int CBaseFileSystem::Tell( FileHandle_t file )
{
VPROF_BUDGET( "CBaseFileSystem::Tell", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
if ( !file )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Tell NULL file handle!\n" );
return 0;
}
// Pack files are relative
return (( CFileHandle *)file)->Tell();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// Output : unsigned int
//-----------------------------------------------------------------------------
unsigned int CBaseFileSystem::Size( FileHandle_t file )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
VPROF_BUDGET( "CBaseFileSystem::Size", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
if ( !file )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Size NULL file handle!\n" );
return 0;
}
return ((CFileHandle *)file)->Size();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// Output : unsigned int
//-----------------------------------------------------------------------------
unsigned int CBaseFileSystem::Size( const char* pFileName, const char *pPathID )
{
VPROF_BUDGET( "CBaseFileSystem::Size", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CHECK_DOUBLE_SLASHES( pFileName );
// handle the case where no name passed...
if ( !pFileName || !pFileName[0] )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Size NULL filename!\n" );
return 0;
}
// Ok, fall through to the fast path.
unsigned result = 0;
FileHandle_t h = Open( pFileName, "rb", pPathID );
if ( h )
{
result = Size( h );
Close(h);
}
return result;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *path -
// *pFileName -
// Output : long
//-----------------------------------------------------------------------------
fix windows build scripts, add windows opus support
2 years ago
time_t CBaseFileSystem::FastFileTime( const CSearchPath *path, const char *pFileName )
1
5 years ago
{
struct _stat buf;
if ( path->GetPackFile() )
{
// If we found the file:
if ( path->GetPackFile()->ContainsFile( pFileName ) )
{
return (path->GetPackFile()->m_lPackFileTime);
}
}
#ifdef SUPPORT_PACKED_STORE
else if ( path->GetPackedStore() )
{
// Hm, should we support this in some way?
return 0L;
}
#endif
else
{
// Is it an absolute path?
char pTmpFileName[ MAX_FILEPATH ];
if ( Q_IsAbsolutePath( pFileName ) )
{
Q_strncpy( pTmpFileName, pFileName, sizeof( pTmpFileName ) );
}
else
{
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", path->GetPathString(), pFileName );
}
Q_FixSlashes( pTmpFileName );
if( FS_stat( pTmpFileName, &buf ) != -1 )
{
return buf.st_mtime;
}
BSD: Add support (#140) * BSD: Add support * BSD: other fixes There is still a bug when vgui haven't got text, maybe because of resources. Also there is bug where when trying to start new game caption names shows wrong. * BSD: Debugging * BSD: modify preprocessor and fix windows * BSD: Remove debugging and fix labels in gameui * BSD: Remove disabling some DX9 commands * BSD: Remove -g flag
2 years ago
#if defined(LINUX) || defined(BSD)
1
5 years ago
char caseFixedName[ MAX_PATH ];
bool found = findFileInDirCaseInsensitive_safe( pTmpFileName, caseFixedName );
if ( found && FS_stat( caseFixedName, &buf ) != -1 )
{
return buf.st_mtime;
}
#endif
}
return ( 0L );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseFileSystem::EndOfFile( FileHandle_t file )
{
if ( !file )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to EndOfFile NULL file handle!\n" );
return true;
}
return ((CFileHandle *)file)->EndOfFile();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseFileSystem::Read( void *pOutput, int size, FileHandle_t file )
{
return ReadEx( pOutput, size, size, file );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseFileSystem::ReadEx( void *pOutput, int destSize, int size, FileHandle_t file )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s (%d bytes)", __FUNCTION__, size );
VPROF_BUDGET( "CBaseFileSystem::Read", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
if ( !file )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Read NULL file handle!\n" );
return 0;
}
if ( size < 0 )
{
return 0;
}
return ((CFileHandle*)file)->Read(pOutput, destSize, size );
}
//-----------------------------------------------------------------------------
// Purpose: Blow away current readers
// Input : -
//-----------------------------------------------------------------------------
void CBaseFileSystem::UnloadCompiledKeyValues()
{
#ifndef DEDICATED
for ( int i = 0; i < IFileSystem::NUM_PRELOAD_TYPES; ++i )
{
delete m_PreloadData[ i ].m_pReader;
m_PreloadData[ i ].m_pReader = NULL;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Put data file into list of at specific slot, will be loaded when ::SetupPreloadData() gets called
// Input : type -
// *archiveFile -
//-----------------------------------------------------------------------------
void CBaseFileSystem::LoadCompiledKeyValues( KeyValuesPreloadType_t type, char const *archiveFile )
{
// Just add to list for appropriate loader
Assert( type >= 0 && type < IFileSystem::NUM_PRELOAD_TYPES );
CompiledKeyValuesPreloaders_t& loader = m_PreloadData[ type ];
Assert( loader.m_CacheFile == 0 );
loader.m_CacheFile = FindOrAddFileName( archiveFile );
}
//-----------------------------------------------------------------------------
// Purpose: Takes a passed in KeyValues& head and fills in the precompiled keyvalues data into it.
// Input : head -
// type -
// *filename -
// *pPathID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::LoadKeyValues( KeyValues& head, KeyValuesPreloadType_t type, char const *filename, char const *pPathID /*= 0*/ )
{
bool bret = true;
#ifndef DEDICATED
char tempPathID[MAX_PATH];
ParsePathID( filename, pPathID, tempPathID );
// FIXME: THIS STUFF DOESN'T TRACK pPathID AT ALL RIGHT NOW!!!!!
if ( !m_PreloadData[ type ].m_pReader || !m_PreloadData[ type ].m_pReader->InstanceInPlace( head, filename ) )
{
bret = head.LoadFromFile( this, filename, pPathID );
}
return bret;
#else
bret = head.LoadFromFile( this, filename, pPathID );
return bret;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: If the "PreloadedData" hasn't been purged, then this'll try and instance the KeyValues using the fast path of
/// compiled keyvalues loaded during startup.
// Otherwise, it'll just fall through to the regular KeyValues loading routines
// Input : type -
// *filename -
// *pPathID -
// Output : KeyValues
//-----------------------------------------------------------------------------
KeyValues *CBaseFileSystem::LoadKeyValues( KeyValuesPreloadType_t type, char const *filename, char const *pPathID /*= 0*/ )
{
KeyValues *kv = NULL;
if ( !m_PreloadData[ type ].m_pReader )
{
kv = new KeyValues( filename );
if ( kv )
{
kv->LoadFromFile( this, filename, pPathID );
}
}
else
{
#ifndef DEDICATED
// FIXME: THIS STUFF DOESN'T TRACK pPathID AT ALL RIGHT NOW!!!!!
kv = m_PreloadData[ type ].m_pReader->Instance( filename );
if ( !kv )
{
kv = new KeyValues( filename );
if ( kv )
{
kv->LoadFromFile( this, filename, pPathID );
}
}
#endif
}
return kv;
}
//-----------------------------------------------------------------------------
// Purpose: This is the fallback method of reading the name of the first key in the file
// Input : *filename -
// *pPathID -
// *rootName -
// bufsize -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::LookupKeyValuesRootKeyName( char const *filename, char const *pPathID, char *rootName, size_t bufsize )
{
if ( FileExists( filename, pPathID ) )
{
// open file and get shader name
FileHandle_t hFile = Open( filename, "r", pPathID );
if ( hFile == FILESYSTEM_INVALID_HANDLE )
{
return false;
}
char buf[ 128 ];
ReadLine( buf, sizeof( buf ), hFile );
Close( hFile );
// The name will possibly come in as "foo"\n
// So we need to strip the starting " character
char *pStart = buf;
if ( *pStart == '\"' )
{
++pStart;
}
// Then copy the rest of the string
Q_strncpy( rootName, pStart, bufsize );
// And then strip off the \n and the " character at the end, in that order
int len = Q_strlen( pStart );
while ( len > 0 && rootName[ len - 1 ] == '\n' )
{
rootName[ len - 1 ] = 0;
--len;
}
while ( len > 0 && rootName[ len - 1 ] == '\"' )
{
rootName[ len - 1 ] = 0;
--len;
}
}
else
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Tries to look up the name of the first key in the file from the compiled data
// Input : type -
// *outbuf -
// bufsize -
// *filename -
// *pPathID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::ExtractRootKeyName( KeyValuesPreloadType_t type, char *outbuf, size_t bufsize, char const *filename, char const *pPathID /*= 0*/ )
{
char tempPathID[MAX_PATH];
ParsePathID( filename, pPathID, tempPathID );
bool bret = true;
if ( !m_PreloadData[ type ].m_pReader )
{
// Use fallback
bret = LookupKeyValuesRootKeyName( filename, pPathID, outbuf, bufsize );
}
else
{
#ifndef DEDICATED
// Try to use cache
bret = m_PreloadData[ type ].m_pReader->LookupKeyValuesRootKeyName( filename, outbuf, bufsize );
if ( !bret )
{
// Not in cache, use fallback
bret = LookupKeyValuesRootKeyName( filename, pPathID, outbuf, bufsize );
}
#endif
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::SetupPreloadData()
{
int i;
for ( i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackFile* pf = m_SearchPaths[i].GetPackFile();
if ( pf )
{
pf->SetupPreloadData();
}
}
#ifndef DEDICATED
if ( !CommandLine()->FindParm( "-fs_nopreloaddata" ) )
{
// Loads in the precompiled keyvalues data for each type
for ( i = 0; i < NUM_PRELOAD_TYPES; ++i )
{
CompiledKeyValuesPreloaders_t& preloader = m_PreloadData[ i ];
Assert( !preloader.m_pReader );
char fn[MAX_PATH];
if ( preloader.m_CacheFile != 0 &&
String( preloader.m_CacheFile, fn, sizeof( fn ) ) )
{
preloader.m_pReader = new CCompiledKeyValuesReader();
preloader.m_pReader->LoadFile( fn );
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::DiscardPreloadData()
{
int i;
for( i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackFile* pf = m_SearchPaths[i].GetPackFile();
if ( pf )
{
pf->DiscardPreloadData();
}
}
UnloadCompiledKeyValues();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseFileSystem::Write( void const* pInput, int size, FileHandle_t file )
{
VPROF_BUDGET( "CBaseFileSystem::Write", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
AUTOBLOCKREPORTER_FH( Write, this, true, file, FILESYSTEM_BLOCKING_SYNCHRONOUS, FileBlockingItem::FB_ACCESS_WRITE );
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Write NULL file handle!\n" );
return 0;
}
return fh->Write( pInput, size );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseFileSystem::FPrintf( FileHandle_t file, const char *pFormat, ... )
{
va_list args;
va_start( args, pFormat );
VPROF_BUDGET( "CBaseFileSystem::FPrintf", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to FPrintf NULL file handle!\n" );
return 0;
}
/*
if ( !fh->GetFileHandle() )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to FPrintf NULL file pointer inside valid file handle!\n" );
return 0;
}
*/
char buffer[65535];
int len = vsnprintf( buffer, sizeof( buffer), pFormat, args );
len = fh->Write( buffer, len );
//int len = FS_vfprintf( fh->GetFileHandle() , pFormat, args );
va_end( args );
return len;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::SetBufferSize( FileHandle_t file, unsigned nBytes )
{
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to SetBufferSize NULL file handle!\n" );
return;
}
fh->SetBufferSize( nBytes );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseFileSystem::IsOk( FileHandle_t file )
{
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to IsOk NULL file handle!\n" );
return false;
}
return fh->IsOK();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::Flush( FileHandle_t file )
{
VPROF_BUDGET( "CBaseFileSystem::Flush", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to Flush NULL file handle!\n" );
return;
}
fh->Flush();
}
bool CBaseFileSystem::Precache( const char *pFileName, const char *pPathID)
{
CHECK_DOUBLE_SLASHES( pFileName );
// Allow for UNC-type syntax to specify the path ID.
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pPathID, tempPathID );
Assert( pPathID );
// Really simple, just open, the file, read it all in and close it.
// We probably want to use file mapping to do this eventually.
FileHandle_t f = Open( pFileName, "rb", pPathID );
if ( !f )
return false;
// not for consoles, the read discard is a negative benefit, slow and clobbers small drive caches
if ( IsPC() )
{
char buffer[16384];
while( sizeof(buffer) == Read(buffer,sizeof(buffer),f) );
}
Close( f );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
char *CBaseFileSystem::ReadLine( char *pOutput, int maxChars, FileHandle_t file )
{
VPROF_BUDGET( "CBaseFileSystem::ReadLine", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CFileHandle *fh = ( CFileHandle *)file;
if ( !fh )
{
Warning( FILESYSTEM_WARNING, "FS: Tried to ReadLine NULL file handle!\n" );
return NULL;
}
m_Stats.nReads++;
int nRead = 0;
// Read up to maxchars:
while( nRead < ( maxChars - 1 ) )
{
// Are we at the end of the file?
if( 1 != fh->Read( pOutput + nRead, 1 ) )
break;
// Translate for text mode files:
if( ( fh->m_type == FT_PACK_TEXT || fh->m_type == FT_MEMORY_TEXT ) && pOutput[nRead] == '\r' )
{
// Ignore \r
continue;
}
// We're done when we hit a '\n'
if( pOutput[nRead] == '\n' )
{
nRead++;
break;
}
// Get outta here if we find a NULL.
if( pOutput[nRead] == '\0' )
{
pOutput[nRead] = '\n';
nRead++;
break;
}
nRead++;
}
if( nRead < maxChars )
pOutput[nRead] = '\0';
m_Stats.nBytesRead += nRead;
return ( nRead ) ? pOutput : NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
// Output : long
//-----------------------------------------------------------------------------
fix windows build scripts, add windows opus support
2 years ago
time_t CBaseFileSystem::GetFileTime( const char *pFileName, const char *pPathID )
1
5 years ago
{
VPROF_BUDGET( "CBaseFileSystem::GetFileTime", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CHECK_DOUBLE_SLASHES( pFileName );
CSearchPathsIterator iter( this, &pFileName, pPathID );
char tempFileName[MAX_PATH];
Q_strncpy( tempFileName, pFileName, sizeof(tempFileName) );
Q_FixSlashes( tempFileName );
#ifdef _WIN32
Q_strlower( tempFileName );
#endif
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
fix windows build scripts, add windows opus support
2 years ago
time_t ft = FastFileTime( pSearchPath, tempFileName );
1
5 years ago
if ( ft != 0L )
{
if ( !pSearchPath->GetPackFile() && m_LogFuncs.Count() )
{
char pTmpFileName[ MAX_FILEPATH ];
if ( strchr( tempFileName, ':' ) )
{
Q_strncpy( pTmpFileName, tempFileName, sizeof( pTmpFileName ) );
}
else
{
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), tempFileName );
}
Q_FixSlashes( tempFileName );
LogAccessToFile( "filetime", pTmpFileName, "" );
}
return ft;
}
}
fix windows build scripts, add windows opus support
2 years ago
return (time_t)0L;
1
5 years ago
}
fix windows build scripts, add windows opus support
2 years ago
time_t CBaseFileSystem::GetPathTime( const char *pFileName, const char *pPathID )
1
5 years ago
{
fix windows build scripts, add windows opus support
2 years ago
VPROF_BUDGET( "CBaseFileSystem::GetPathTime", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
1
5 years ago
CSearchPathsIterator iter( this, &pFileName, pPathID );
char tempFileName[MAX_PATH];
Q_strncpy( tempFileName, pFileName, sizeof(tempFileName) );
Q_FixSlashes( tempFileName );
#ifdef _WIN32
Q_strlower( tempFileName );
#endif
fix windows build scripts, add windows opus support
2 years ago
time_t pathTime = 0L;
1
5 years ago
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
fix windows build scripts, add windows opus support
2 years ago
time_t ft = FastFileTime( pSearchPath, tempFileName );
1
5 years ago
if ( ft > pathTime )
pathTime = ft;
if ( ft != 0L )
{
if ( !pSearchPath->GetPackFile() && m_LogFuncs.Count() )
{
char pTmpFileName[ MAX_FILEPATH ];
if ( strchr( tempFileName, ':' ) )
{
Q_strncpy( pTmpFileName, tempFileName, sizeof( pTmpFileName ) );
}
else
{
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), tempFileName );
}
Q_FixSlashes( tempFileName );
LogAccessToFile( "filetime", pTmpFileName, "" );
}
}
}
return pathTime;
}
void CBaseFileSystem::MarkAllCRCsUnverified()
{
if ( IsX360() )
{
return;
}
m_FileTracker2.MarkAllCRCsUnverified();
}
void CBaseFileSystem::CacheFileCRCs( const char *pPathname, ECacheCRCType eType, IFileList *pFilter )
{
if ( IsX360() )
{
return;
}
}
EFileCRCStatus CBaseFileSystem::CheckCachedFileHash( const char *pPathID, const char *pRelativeFilename, int nFileFraction, FileHash_t *pFileHash )
{
return m_FileTracker2.CheckCachedFileHash( pPathID, pRelativeFilename, nFileFraction, pFileHash );
}
void CBaseFileSystem::EnableWhitelistFileTracking( bool bEnable, bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes )
{
if ( IsX360() )
{
m_WhitelistFileTrackingEnabled = false;
return;
}
if ( m_WhitelistFileTrackingEnabled != -1 )
{
Error( "CBaseFileSystem::EnableWhitelistFileTracking called more than once." );
}
Disable trusted key verification for sv_pure, fix mod_texture.txt loading
3 years ago
1
5 years ago
m_WhitelistFileTrackingEnabled = bEnable;
if ( m_WhitelistFileTrackingEnabled && bCacheAllVPKHashes )
{
CacheAllVPKFileHashes( bCacheAllVPKHashes, bRecalculateAndCheckHashes );
}
}
void CBaseFileSystem::CacheAllVPKFileHashes( bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes )
{
#ifdef SUPPORT_PACKED_STORE
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackedStore *pVPK = m_SearchPaths[i].GetPackedStore();
if ( pVPK == NULL )
continue;
if ( !pVPK->BTestDirectoryHash() )
{
Msg( "VPK dir file hash does not match. File corrupted or modified.\n" );
}
if ( !pVPK->BTestMasterChunkHash() )
{
Msg( "VPK chunk hash hash does not match. File corrupted or modified.\n" );
}
CUtlVector<ChunkHashFraction_t> &vecChunkHash = pVPK->AccessPackFileHashes();
CPackedStoreFileHandle fhandle = pVPK->GetHandleForHashingFiles();
CUtlVector<ChunkHashFraction_t> vecChunkHashFractionCopy;
if ( bRecalculateAndCheckHashes )
{
CUtlString sPackFileErrors;
pVPK->GetPackFileLoadErrorSummary( sPackFileErrors );
if ( sPackFileErrors.Length() )
{
Msg( "Errors occured loading files.\n" );
Msg( "%s", sPackFileErrors.String() );
Msg( "Verify integrity of your game files, perform memory and disk diagnostics on your system.\n" );
}
else
Msg( "No VPK Errors occured loading files.\n" );
Msg( "Recomputing all VPK file hashes.\n" );
vecChunkHashFractionCopy.Swap( vecChunkHash );
}
int cFailures = 0;
if ( vecChunkHash.Count() == 0 )
{
if ( vecChunkHashFractionCopy.Count() == 0 )
Msg( "File hash information not found: Hashing all VPK files for pure server operation.\n" );
pVPK->HashAllChunkFiles();
if ( vecChunkHashFractionCopy.Count() != 0 )
{
if ( vecChunkHash.Count() != vecChunkHashFractionCopy.Count() )
{
Msg( "VPK hash count does not match. VPK content may be corrupt.\n" );
}
else if ( Q_memcmp( vecChunkHash.Base(), vecChunkHashFractionCopy.Base(), vecChunkHash.Count()*sizeof(vecChunkHash[0])) != 0 )
{
Msg( "VPK hashes do not match. VPK content may be corrupt.\n" );
// find the actual mismatch
FOR_EACH_VEC( vecChunkHashFractionCopy, iHash )
{
if ( Q_memcmp( vecChunkHashFractionCopy[iHash].m_md5contents.bits, vecChunkHash[iHash].m_md5contents.bits, sizeof( vecChunkHashFractionCopy[iHash].m_md5contents.bits ) ) != 0 )
{
Msg( "VPK hash for file %d failure at offset %x.\n", vecChunkHashFractionCopy[iHash].m_nPackFileNumber, vecChunkHashFractionCopy[iHash].m_nFileFraction );
cFailures++;
}
}
}
}
}
if ( bCacheAllVPKHashes )
{
Msg( "Loaded %d VPK file hashes from %s for pure server operation.\n", vecChunkHash.Count(), pVPK->FullPathName() );
FOR_EACH_VEC( vecChunkHash, i )
{
m_FileTracker2.AddFileHashForVPKFile( vecChunkHash[i].m_nPackFileNumber, vecChunkHash[i].m_nFileFraction, vecChunkHash[i].m_cbChunkLen, vecChunkHash[i].m_md5contents, fhandle );
}
}
else
{
if ( cFailures == 0 && vecChunkHash.Count() == vecChunkHashFractionCopy.Count() )
Msg( "File hashes checked. %d matches. no failures.\n", vecChunkHash.Count() );
else
Msg( "File hashes checked. %d matches. %d failures.\n", vecChunkHash.Count(), cFailures );
}
}
#endif
}
bool CBaseFileSystem::CheckVPKFileHash( int PackFileID, int nPackFileNumber, int nFileFraction, MD5Value_t &md5Value )
{
#ifdef SUPPORT_PACKED_STORE
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
CPackedStore *pVPK = m_SearchPaths[i].GetPackedStore();
if ( pVPK == NULL || pVPK->m_PackFileID != PackFileID )
continue;
ChunkHashFraction_t fileHashFraction;
if ( pVPK->FindFileHashFraction( nPackFileNumber, nFileFraction, fileHashFraction ) )
{
CPackedStoreFileHandle fhandle = pVPK->GetHandleForHashingFiles();
fhandle.m_nFileNumber = nPackFileNumber;
char szFileName[MAX_PATH];
pVPK->GetPackFileName( fhandle, szFileName, sizeof(szFileName) );
char hex[ 34 ];
Q_memset( hex, 0, sizeof( hex ) );
Q_binarytohex( (const byte *)md5Value.bits, sizeof( md5Value.bits ), hex, sizeof( hex ) );
char hex2[ 34 ];
Q_memset( hex2, 0, sizeof( hex2 ) );
Q_binarytohex( (const byte *)fileHashFraction.m_md5contents.bits, sizeof( fileHashFraction.m_md5contents.bits ), hex2, sizeof( hex2 ) );
if ( Q_memcmp( fileHashFraction.m_md5contents.bits, md5Value.bits, sizeof(md5Value.bits) ) != 0 )
{
Msg( "File %s offset %x hash %s does not match ( should be %s ) \n", szFileName, nFileFraction, hex, hex2 );
return false;
}
else
{
return true;
}
}
}
#else
Error("CBaseFileSystem::CheckVPKFileHash should not be called, SUPPORT_PACKED_STORE not defined" );
#endif
return false;
}
void CBaseFileSystem::RegisterFileWhitelist( IPureServerWhitelist *pWhiteList, IFileList **pFilesToReload )
{
if ( pFilesToReload )
*pFilesToReload = NULL;
if ( IsX360() )
{
return;
}
if ( m_pPureServerWhitelist )
{
m_pPureServerWhitelist->Release();
m_pPureServerWhitelist = NULL;
}
if ( pWhiteList )
{
pWhiteList->AddRef();
m_pPureServerWhitelist = pWhiteList;
}
// update which search paths are considered trusted
FOR_EACH_VEC( m_SearchPaths, i )
{
SetSearchPathIsTrustedSource( &m_SearchPaths[i] );
}
// See if we need to reload any files
if ( pFilesToReload )
*pFilesToReload = m_FileTracker2.GetFilesToUnloadForWhitelistChange( pWhiteList );
}
void CBaseFileSystem::NotifyFileUnloaded( const char *pszFilename, const char *pPathId )
{
m_FileTracker2.NoteFileUnloaded( pszFilename, pPathId );
}
void CBaseFileSystem::SetSearchPathIsTrustedSource( CSearchPath *pSearchPath )
{
Disable trusted key verification for sv_pure, fix mod_texture.txt loading
3 years ago
#if 1
pSearchPath->m_bIsTrustedForPureServer = true;
#else // Broken, I am lazy to fix this
1
5 years ago
// Most paths are not considered trusted
pSearchPath->m_bIsTrustedForPureServer = false;
// If we don't have a pure server whitelist, we cannot say that any
// particular files are trusted. (But then again, all files will be
// accepted, so it won't really matter.)
if ( m_pPureServerWhitelist == NULL )
return;
// Treat map packs as trusted, because we will send the CRC of the map pack to the server
if ( pSearchPath->GetPackFile() && pSearchPath->GetPackFile()->m_bIsMapPath )
{
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Setting map pack search path %s as trusted\n", pSearchPath->GetDebugString() );
#endif
pSearchPath->m_bIsTrustedForPureServer = true;
return;
}
#ifdef SUPPORT_PACKED_STORE
// Only signed VPK's can be trusted
CPackedStoreRefCount *pVPK = pSearchPath->GetPackedStore();
if ( pVPK == NULL )
{
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Setting %s as untrusted (loose files)\n", pSearchPath->GetDebugString() );
#endif
return;
}
if ( !pVPK->m_bSignatureValid )
{
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Setting %s as untrusted (unsigned VPK)\n", pSearchPath->GetDebugString() );
#endif
return;
}
const CUtlVector<uint8> &key = pVPK->GetSignaturePublicKey();
for ( int iKeyIndex = 0 ; iKeyIndex < m_pPureServerWhitelist->GetTrustedKeyCount() ; ++iKeyIndex )
{
int nKeySz = 0;
const byte *pbKey = m_pPureServerWhitelist->GetTrustedKey( iKeyIndex, &nKeySz );
Assert( pbKey != NULL && nKeySz > 0 );
if ( key.Count() == nKeySz && V_memcmp( pbKey, key.Base(), nKeySz ) == 0 )
{
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Setting %s as untrusted\n", pSearchPath->GetDebugString() );
#endif
pSearchPath->m_bIsTrustedForPureServer = true;
return;
}
}
#ifdef PURE_SERVER_DEBUG_SPEW
Msg( "Setting %s as untrusted. (Key not in trusted key list)\n", pSearchPath->GetDebugString() );
#endif
#endif
Disable trusted key verification for sv_pure, fix mod_texture.txt loading
3 years ago
#endif
1
5 years ago
}
int CBaseFileSystem::GetUnverifiedFileHashes( CUnverifiedFileHash *pFiles, int nMaxFiles )
{
return m_FileTracker2.GetUnverifiedFileHashes( pFiles, nMaxFiles );
}
int CBaseFileSystem::GetWhitelistSpewFlags()
{
return m_WhitelistSpewFlags;
}
void CBaseFileSystem::SetWhitelistSpewFlags( int flags )
{
m_WhitelistSpewFlags = flags;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pString -
// maxCharsIncludingTerminator -
// fileTime -
//-----------------------------------------------------------------------------
fix windows build scripts, add windows opus support
2 years ago
void CBaseFileSystem::FileTimeToString( char *pString, int maxCharsIncludingTerminator, time_t fileTime )
1
5 years ago
{
if ( IsX360() )
{
char szTemp[ 256 ];
time_t time = fileTime;
V_strncpy( szTemp, ctime( &time ), sizeof( szTemp ) );
char *pFinalColon = Q_strrchr( szTemp, ':' );
if ( pFinalColon )
*pFinalColon = '\0';
// Clip off the day of the week
V_strncpy( pString, szTemp + 4, maxCharsIncludingTerminator );
}
else
{
time_t time = fileTime;
V_strncpy( pString, ctime( &time ), maxCharsIncludingTerminator );
// We see a linefeed at the end of these strings...if there is one, gobble it up
int len = V_strlen( pString );
if ( pString[ len - 1 ] == '\n' )
{
pString[ len - 1 ] = '\0';
}
pString[maxCharsIncludingTerminator-1] = '\0';
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::FileExists( const char *pFileName, const char *pPathID )
{
VPROF_BUDGET( "CBaseFileSystem::FileExists", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
CHECK_DOUBLE_SLASHES( pFileName );
FileHandle_t h = Open( pFileName, "rb", pPathID );
if ( h )
{
Close(h);
return true;
}
return false;
}
bool CBaseFileSystem::IsFileWritable( char const *pFileName, char const *pPathID /*=0*/ )
{
CHECK_DOUBLE_SLASHES( pFileName );
struct _stat buf;
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pPathID, tempPathID );
if ( Q_IsAbsolutePath( pFileName ) )
{
if( FS_stat( pFileName, &buf ) != -1 )
{
#ifdef WIN32
if( buf.st_mode & _S_IWRITE )
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#elif defined (LINUX) && !defined (ANDROID)
1
5 years ago
if( buf.st_mode & S_IWRITE )
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#elif ANDROID
if( buf.st_mode & S_IWUSR )
1
5 years ago
#else
if( buf.st_mode & S_IWRITE )
#endif
{
return true;
}
}
return false;
}
CSearchPathsIterator iter( this, &pFileName, pPathID, FILTER_CULLPACK );
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
char pTmpFileName[ MAX_FILEPATH ];
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), pFileName );
Q_FixSlashes( pTmpFileName );
if ( FS_stat( pTmpFileName, &buf ) != -1 )
{
#ifdef WIN32
if ( buf.st_mode & _S_IWRITE )
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#elif defined (LINUX) && !defined (ANDROID)
1
5 years ago
if ( buf.st_mode & S_IWRITE )
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#elif ANDROID
if ( buf.st_mode & S_IWUSR )
1
5 years ago
#else
if ( buf.st_mode & S_IWRITE )
#endif
{
return true;
}
}
}
return false;
}
bool CBaseFileSystem::SetFileWritable( char const *pFileName, bool writable, const char *pPathID /*= 0*/ )
{
CHECK_DOUBLE_SLASHES( pFileName );
#ifdef _WIN32
int pmode = writable ? ( _S_IWRITE | _S_IREAD ) : ( _S_IREAD );
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#elif ANDROID
int pmode = writable ? ( S_IWUSR | S_IRUSR ) : ( S_IRUSR );
1
5 years ago
#else
int pmode = writable ? ( S_IWRITE | S_IREAD ) : ( S_IREAD );
#endif
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pPathID, tempPathID );
if ( Q_IsAbsolutePath( pFileName ) )
{
return ( FS_chmod( pFileName, pmode ) == 0 );
}
CSearchPathsIterator iter( this, &pFileName, pPathID, FILTER_CULLPACK );
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
char pTmpFileName[ MAX_FILEPATH ];
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), pFileName );
Q_FixSlashes( pTmpFileName );
if ( FS_chmod( pTmpFileName, pmode ) == 0 )
{
return true;
}
}
// Failure
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::IsDirectory( const char *pFileName, const char *pathID )
{
CHECK_DOUBLE_SLASHES( pFileName );
// Allow for UNC-type syntax to specify the path ID.
struct _stat buf;
char pTempBuf[MAX_PATH];
Q_strncpy( pTempBuf, pFileName, sizeof(pTempBuf) );
Q_StripTrailingSlash( pTempBuf );
pFileName = pTempBuf;
char tempPathID[MAX_PATH];
ParsePathID( pFileName, pathID, tempPathID );
if ( Q_IsAbsolutePath( pFileName ) )
{
if ( FS_stat( pFileName, &buf ) != -1 )
{
if ( buf.st_mode & _S_IFDIR )
return true;
}
return false;
}
CSearchPathsIterator iter( this, &pFileName, pathID, FILTER_CULLPACK );
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
#ifdef SUPPORT_PACKED_STORE
if ( pSearchPath->GetPackedStore() )
{
CUtlStringList outDir, outFile;
pSearchPath->GetPackedStore()->GetFileAndDirLists( outDir, outFile, false );
FOR_EACH_VEC( outDir, i )
{
if ( !Q_stricmp( outDir[i], pFileName ) )
return true;
}
}
else
#endif // SUPPORT_PACKED_STORE
{
char pTmpFileName[ MAX_FILEPATH ];
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), pFileName );
Q_FixSlashes( pTmpFileName );
if ( FS_stat( pTmpFileName, &buf ) != -1 )
{
if ( buf.st_mode & _S_IFDIR )
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *path -
//-----------------------------------------------------------------------------
void CBaseFileSystem::CreateDirHierarchy( const char *pRelativePathT, const char *pathID )
{
// Allow for UNC-type syntax to specify the path ID.
char tempPathID[MAX_PATH];
ParsePathID(pRelativePathT, pathID, tempPathID); // use the original path param to preserve "//"
char pRelativePathBuff[ MAX_PATH ];
const char *pRelativePath = pRelativePathBuff;
FixUpPath ( pRelativePathT, pRelativePathBuff, sizeof( pRelativePathBuff ) );
CHECK_DOUBLE_SLASHES( pRelativePath );
char szScratchFileName[MAX_PATH];
if ( !Q_IsAbsolutePath( pRelativePath ) )
{
Assert( pathID );
ComputeFullWritePath( szScratchFileName, sizeof( szScratchFileName ), pRelativePath, pathID );
}
else
{
Q_strncpy( szScratchFileName, pRelativePath, sizeof(szScratchFileName) );
}
int len = strlen( szScratchFileName ) + 1;
char *end = szScratchFileName + len;
char *s = szScratchFileName;
while( s < end )
{
if( *s == CORRECT_PATH_SEPARATOR && s != szScratchFileName && ( IsLinux() || *( s - 1 ) != ':' ) )
{
*s = '\0';
#if defined( _WIN32 )
_mkdir( szScratchFileName );
#elif defined( POSIX )
mkdir( szScratchFileName, S_IRWXU | S_IRGRP | S_IROTH );// owner has rwx, rest have r
#endif
*s = CORRECT_PATH_SEPARATOR;
}
s++;
}
#if defined( _WIN32 )
_mkdir( szScratchFileName );
#elif defined( POSIX )
mkdir( szScratchFileName, S_IRWXU | S_IRGRP | S_IROTH );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pWildCard -
// *pHandle -
// Output : const char
//-----------------------------------------------------------------------------
const char *CBaseFileSystem::FindFirstEx( const char *pWildCard, const char *pPathID, FileFindHandle_t *pHandle )
{
CHECK_DOUBLE_SLASHES( pWildCard );
return FindFirstHelper( pWildCard, pPathID, pHandle, NULL );
}
const char *CBaseFileSystem::FindFirstHelper( const char *pWildCardT, const char *pPathID, FileFindHandle_t *pHandle, int *pFoundStoreID )
{
VPROF_BUDGET( "CBaseFileSystem::FindFirst", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
Assert(pWildCardT);
Assert(pHandle);
FileFindHandle_t hTmpHandle = m_FindData.AddToTail();
FindData_t *pFindData = &m_FindData[hTmpHandle];
Assert( pFindData );
if ( pPathID )
{
pFindData->m_FilterPathID = g_PathIDTable.AddString( pPathID );
}
char pWildCard[ MAX_PATH ];
FixUpPath ( pWildCardT, pWildCard, sizeof( pWildCard ) );
int maxlen = strlen( pWildCard ) + 1;
pFindData->wildCardString.AddMultipleToTail( maxlen );
Q_strncpy( pFindData->wildCardString.Base(), pWildCard, maxlen );
pFindData->findHandle = INVALID_HANDLE_VALUE;
if ( Q_IsAbsolutePath( pWildCard ) )
{
// Absolute path, cannot be VPK or Pak
pFindData->findHandle = FS_FindFirstFile( pWildCard, &pFindData->findData );
pFindData->currentSearchPathID = -1;
}
else
{
int c = m_SearchPaths.Count();
for( pFindData->currentSearchPathID = 0;
pFindData->currentSearchPathID < c;
pFindData->currentSearchPathID++ )
{
CSearchPath *pSearchPath = &m_SearchPaths[pFindData->currentSearchPathID];
if ( FilterByPathID( pSearchPath, pFindData->m_FilterPathID ) )
continue;
// already visited this path?
if ( pFindData->m_VisitedSearchPaths.MarkVisit( *pSearchPath ) )
continue;
// If this is a VPK or Pak file, build list of matches now and use helper
bool bIsVPKOrPak = false;
if ( pSearchPath->GetPackFile() )
{
// XXX(johns) This support didn't exist for a long time, and I'm now worried about various things
// looking for misc files suddenly finding them in the (untrusted) BSP and causing security
// nightmares. For now, restricting FindFirst() support to BSPs only when the BSP search path
// is explicitly requested, but this would otherwise work fine.
if ( !pPathID || V_strcmp( pPathID, "BSP" ) != 0 )
{
continue;
}
Assert( pFindData->m_dirMatchesFromVPKOrPak.Count() == 0 );
Assert( pFindData->m_fileMatchesFromVPKOrPak.Count() == 0 );
pSearchPath->GetPackFile()->GetFileAndDirLists( pWildCard, pFindData->m_dirMatchesFromVPKOrPak, pFindData->m_fileMatchesFromVPKOrPak, true );
bIsVPKOrPak = true;
}
#ifdef SUPPORT_PACKED_STORE
if ( pSearchPath->GetPackedStore() )
{
Assert( pFindData->m_dirMatchesFromVPKOrPak.Count() == 0 );
Assert( pFindData->m_fileMatchesFromVPKOrPak.Count() == 0 );
pSearchPath->GetPackedStore()->GetFileAndDirLists( pWildCard, pFindData->m_dirMatchesFromVPKOrPak, pFindData->m_fileMatchesFromVPKOrPak, true );
bIsVPKOrPak = true;
}
#endif
if ( bIsVPKOrPak )
{
if ( FindNextFileInVPKOrPakHelper( pFindData ) )
{
// Remember that we visited this file already.
pFindData->m_VisitedFiles.Insert( pFindData->findData.cFileName, 0 );
*pHandle = hTmpHandle;
return pFindData->findData.cFileName;
}
continue;
}
// Otherwise, raw FS find for relative path
char pTmpFileName[ MAX_FILEPATH ];
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), pFindData->wildCardString.Base() );
Q_FixSlashes( pTmpFileName );
pFindData->findHandle = FS_FindFirstFile( pTmpFileName, &pFindData->findData );
pFindData->m_CurrentStoreID = pSearchPath->m_storeId;
if( pFindData->findHandle != INVALID_HANDLE_VALUE )
break;
}
}
// We have a result from the filesystem
if( pFindData->findHandle != INVALID_HANDLE_VALUE )
{
// Remember that we visited this file already.
pFindData->m_VisitedFiles.Insert( pFindData->findData.cFileName, 0 );
if ( pFoundStoreID )
*pFoundStoreID = pFindData->m_CurrentStoreID;
*pHandle = hTmpHandle;
return pFindData->findData.cFileName;
}
// Handle failure here
pFindData = 0;
m_FindData.Remove(hTmpHandle);
*pHandle = -1;
return NULL;
}
const char *CBaseFileSystem::FindFirst( const char *pWildCard, FileFindHandle_t *pHandle )
{
return FindFirstEx( pWildCard, NULL, pHandle );
}
// Get the next file, trucking through the path. . don't check for duplicates.
bool CBaseFileSystem::FindNextFileHelper( FindData_t *pFindData, int *pFoundStoreID )
{
// Try the same search path that we were already searching on.
if( FS_FindNextFile( pFindData->findHandle, &pFindData->findData ) )
{
if ( pFoundStoreID )
*pFoundStoreID = pFindData->m_CurrentStoreID;
return true;
}
if ( FindNextFileInVPKOrPakHelper( pFindData ) )
return true;
// This happens when we searched a full path
if ( pFindData->currentSearchPathID < 0 )
return false;
pFindData->currentSearchPathID++;
if ( pFindData->findHandle != INVALID_HANDLE_VALUE )
{
FS_FindClose( pFindData->findHandle );
}
pFindData->findHandle = INVALID_HANDLE_VALUE;
int c = m_SearchPaths.Count();
for( ; pFindData->currentSearchPathID < c; ++pFindData->currentSearchPathID )
{
CSearchPath *pSearchPath = &m_SearchPaths[pFindData->currentSearchPathID];
if ( FilterByPathID( pSearchPath, pFindData->m_FilterPathID ) )
continue;
// already visited this path
if ( pFindData->m_VisitedSearchPaths.MarkVisit( *pSearchPath ) )
continue;
if ( pSearchPath->GetPackFile() )
{
// XXX(johns) This support didn't exist for a long time, and I'm now worried about various things
// looking for misc files suddenly finding them in the (untrusted) BSP and causing security
// nightmares. For now, restricting FindFirst() support to BSPs only when the BSP search path
// is explicitly requested, but this would otherwise work fine.
if ( !pFindData->m_FilterPathID || V_strcmp( g_PathIDTable.String( pFindData->m_FilterPathID ), "BSP" ) != 0 )
{
continue;
}
Assert( pFindData->m_dirMatchesFromVPKOrPak.Count() == 0 );
Assert( pFindData->m_fileMatchesFromVPKOrPak.Count() == 0 );
pSearchPath->GetPackFile()->GetFileAndDirLists( pFindData->wildCardString.Base(), pFindData->m_dirMatchesFromVPKOrPak, pFindData->m_fileMatchesFromVPKOrPak, true );
if ( FindNextFileInVPKOrPakHelper( pFindData ) )
return true;
continue;
}
#ifdef SUPPORT_PACKED_STORE
if ( pSearchPath->GetPackedStore() )
{
Assert( pFindData->m_dirMatchesFromVPKOrPak.Count() == 0 );
Assert( pFindData->m_fileMatchesFromVPKOrPak.Count() == 0 );
pSearchPath->GetPackedStore()->GetFileAndDirLists( pFindData->wildCardString.Base(), pFindData->m_dirMatchesFromVPKOrPak, pFindData->m_fileMatchesFromVPKOrPak, true );
if ( FindNextFileInVPKOrPakHelper( pFindData ) )
return true;
continue;
}
#endif
char pTmpFileName[ MAX_FILEPATH ];
Q_snprintf( pTmpFileName, sizeof( pTmpFileName ), "%s%s", pSearchPath->GetPathString(), pFindData->wildCardString.Base() );
Q_FixSlashes( pTmpFileName );
pFindData->findHandle = FS_FindFirstFile( pTmpFileName, &pFindData->findData );
pFindData->m_CurrentStoreID = pSearchPath->m_storeId;
if( pFindData->findHandle != INVALID_HANDLE_VALUE )
{
if ( pFoundStoreID )
*pFoundStoreID = pFindData->m_CurrentStoreID;
return true;
}
}
return false;
}
bool CBaseFileSystem::FindNextFileInVPKOrPakHelper( FindData_t *pFindData )
{
// Return the next one from the list of VPK matches if there is one
if ( pFindData->m_fileMatchesFromVPKOrPak.Count() > 0 )
{
V_strncpy( pFindData->findData.cFileName, V_UnqualifiedFileName( pFindData->m_fileMatchesFromVPKOrPak[0] ), sizeof( pFindData->findData.cFileName ) );
pFindData->findData.dwFileAttributes = 0;
delete pFindData->m_fileMatchesFromVPKOrPak.Head();
pFindData->m_fileMatchesFromVPKOrPak.RemoveMultipleFromHead( 1 );
return true;
}
// Return the next one from the list of VPK matches if there is one
if ( pFindData->m_dirMatchesFromVPKOrPak.Count() > 0 )
{
V_strncpy( pFindData->findData.cFileName, V_UnqualifiedFileName( pFindData->m_dirMatchesFromVPKOrPak[0] ), sizeof( pFindData->findData.cFileName ) );
pFindData->findData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
delete pFindData->m_dirMatchesFromVPKOrPak.Head();
pFindData->m_dirMatchesFromVPKOrPak.RemoveMultipleFromHead( 1 );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
// Output : const char
//-----------------------------------------------------------------------------
const char *CBaseFileSystem::FindNext( FileFindHandle_t handle )
{
VPROF_BUDGET( "CBaseFileSystem::FindNext", VPROF_BUDGETGROUP_OTHER_FILESYSTEM );
FindData_t *pFindData = &m_FindData[handle];
while( 1 )
{
if( FindNextFileHelper( pFindData, NULL ) )
{
if ( pFindData->m_VisitedFiles.Find( pFindData->findData.cFileName ) == -1 )
{
pFindData->m_VisitedFiles.Insert( pFindData->findData.cFileName, 0 );
return pFindData->findData.cFileName;
}
}
else
{
return NULL;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::FindIsDirectory( FileFindHandle_t handle )
{
FindData_t *pFindData = &m_FindData[handle];
return !!( pFindData->findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
//-----------------------------------------------------------------------------
void CBaseFileSystem::FindClose( FileFindHandle_t handle )
{
if ( ( handle < 0 ) || ( !m_FindData.IsInList( handle ) ) )
return;
FindData_t *pFindData = &m_FindData[handle];
Assert(pFindData);
if ( pFindData->findHandle != INVALID_HANDLE_VALUE)
{
FS_FindClose( pFindData->findHandle );
}
pFindData->findHandle = INVALID_HANDLE_VALUE;
pFindData->wildCardString.Purge();
pFindData->m_fileMatchesFromVPKOrPak.PurgeAndDeleteElements();
pFindData->m_dirMatchesFromVPKOrPak.PurgeAndDeleteElements();
m_FindData.Remove( handle );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
//-----------------------------------------------------------------------------
void CBaseFileSystem::GetLocalCopy( const char *pFileName )
{
// do nothing. . everything is local.
}
//-----------------------------------------------------------------------------
// Purpose: Fixes up Path names. Will fix up platform specific slashes, remove
// any ../ or ./, fix //s, and lowercase anything under the directory
// that the game is installed to. We expect all files to be lower cased
// there - especially on Linux (where case sensitivity is the norm).
//
// Input : *pFileName - Original name to convert
// *pFixedUpFileName - a buffer to put the converted filename into
// sizeFixedUpFileName - the size of the above buffer in chars
//-----------------------------------------------------------------------------
bool CBaseFileSystem::FixUpPath( const char *pFileName, char *pFixedUpFileName, int sizeFixedUpFileName )
{
// If appropriate fixes up the filename to ensure that it's handled properly by the system.
//
V_strncpy( pFixedUpFileName, pFileName, sizeFixedUpFileName );
V_FixSlashes( pFixedUpFileName, CORRECT_PATH_SEPARATOR );
// V_RemoveDotSlashes( pFixedUpFileName, CORRECT_PATH_SEPARATOR, true );
V_FixDoubleSlashes( pFixedUpFileName );
if ( !V_IsAbsolutePath( pFixedUpFileName ) )
{
V_strlower( pFixedUpFileName );
}
else
{
// Get the BASE_PATH, skip past - if necessary, and lowercase the rest
// Not just yet...
int iBaseLength = 0;
char pBaseDir[MAX_PATH];
// Need to get "BASE_PATH" from the filesystem paths, and then check this name against it.
//
iBaseLength = GetSearchPath( "BASE_PATH", true, pBaseDir, sizeof( pBaseDir ) );
if ( iBaseLength )
{
// If the first part of the pFixedUpFilename is pBaseDir
// then lowercase the part after that.
if ( *pBaseDir && (iBaseLength+1 < V_strlen( pFixedUpFileName ) ) && (0 != V_strncmp( pBaseDir, pFixedUpFileName, iBaseLength ) ) )
{
V_strlower( &pFixedUpFileName[iBaseLength-1] );
}
}
}
// Msg("CBaseFileSystem::FixUpPath: Converted %s to %s\n", pFileName, pFixedUpFileName); // too noisy
#ifdef NEVER // Useful if you're trying to see why your file may not be found (if you have a mixed case file)
if (strncmp(pFixedUpFileName, pFileName, 256))
{
printf("FixUpPath->Converting %s to %s\n",pFileName, pFixedUpFileName);
}
#endif // NEVER
return true;
}
//-----------------------------------------------------------------------------
// Converts a partial path into a full path
// Relative paths that are pack based are returned as an absolute path .../zip?.zip/foo
// A pack absolute path can be sent back in for opening, and the file will be properly
// detected as pack based and mounted inside the pack.
//-----------------------------------------------------------------------------
const char *CBaseFileSystem::RelativePathToFullPath( const char *pFileName, const char *pPathID, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars, PathTypeFilter_t pathFilter, PathTypeQuery_t *pPathType )
{
CHECK_DOUBLE_SLASHES( pFileName );
struct _stat buf;
if ( pPathType )
{
*pPathType = PATH_IS_NORMAL;
}
// Convert filename to lowercase. All files in the
// game logical filesystem must be accessed by lowercase name
char szLowercaseFilename[ MAX_PATH ];
FixUpPath( pFileName, szLowercaseFilename, sizeof( szLowercaseFilename ) );
pFileName = szLowercaseFilename;
// Fill in the default in case it's not found...
V_strncpy( pDest, pFileName, maxLenInChars );
// @FD This is arbitrary and seems broken. If the caller needs this filter, they should
// request it with the flag themselves. As it is, I cannot search all the file paths
// for a file using this function because there is no option that says, "No, really, I
// mean ALL SEARCH PATHS." The current problem I'm trying to fix is that sounds are not
// working if they are in the BSP. I wrote code that assumed that I could just ask for
// the absolute path of a file, since we are able to open files with these absolute
// filenames, and that each particular filesystem call wouldn't have its own individual
// quirks.
// if ( IsPC() && pathFilter == FILTER_NONE )
// {
// // X360TBD: PC legacy behavior never returned pack paths
// // do legacy behavior to ensure naive callers don't break
// pathFilter = FILTER_CULLPACK;
// }
CSearchPathsIterator iter( this, &pFileName, pPathID, pathFilter );
for ( CSearchPath *pSearchPath = iter.GetFirst(); pSearchPath != NULL; pSearchPath = iter.GetNext() )
{
CPackFile *pPack = pSearchPath->GetPackFile();
if ( pPack )
{
if ( pPack->ContainsFile( pFileName ) )
{
if ( pPathType )
{
if ( pPack->m_bIsMapPath )
{
*pPathType |= PATH_IS_MAPPACKFILE;
}
else
{
*pPathType |= PATH_IS_PACKFILE;
}
if ( pSearchPath->m_bIsRemotePath )
{
*pPathType |= PATH_IS_REMOTE;
}
}
// form an encoded absolute path that can be decoded by our FS as pak based
const char *pszPackName = pPack->m_ZipName.String();
int len = V_strlen( pszPackName );
int nTotalLen = len + 1 + V_strlen( pFileName );
if ( nTotalLen >= maxLenInChars )
{
::Warning( "File %s was found in %s, but resulting abs filename won't fit in callers buffer of %d bytes\n",
pFileName, pszPackName, maxLenInChars );
Assert( false );
return NULL;
}
V_strncpy( pDest, pszPackName, maxLenInChars );
V_AppendSlash( pDest, maxLenInChars );
V_strncat( pDest, pFileName, maxLenInChars );
Assert( V_strlen( pDest ) == nTotalLen );
return pDest;
}
continue;
}
// Found in VPK?
#ifdef SUPPORT_PACKED_STORE
CPackedStore *pVPK = pSearchPath->GetPackedStore();
if ( pVPK )
{
CPackedStoreFileHandle vpkHandle = pVPK->OpenFile( pFileName );
if ( vpkHandle )
{
const char *pszVpkName = vpkHandle.m_pOwner->FullPathName();
Assert( V_GetFileExtension( pszVpkName ) != NULL );
int len = V_strlen( pszVpkName );
int nTotalLen = len + 1 + V_strlen( pFileName );
if ( nTotalLen >= maxLenInChars )
{
::Warning( "File %s was found in %s, but resulting abs filename won't fit in callers buffer of %d bytes\n",
pFileName, pszVpkName, maxLenInChars );
Assert( false );
return NULL;
}
V_strncpy( pDest, pszVpkName, maxLenInChars );
V_AppendSlash( pDest, maxLenInChars );
V_strncat( pDest, pFileName, maxLenInChars );
V_FixSlashes( pDest );
return pDest;
}
continue;
}
#endif
char pTmpFileName[ MAX_FILEPATH ];
V_sprintf_safe( pTmpFileName, "%s%s", pSearchPath->GetPathString(), pFileName );
V_FixSlashes( pTmpFileName );
if ( FS_stat( pTmpFileName, &buf ) != -1 )
{
V_strncpy( pDest, pTmpFileName, maxLenInChars );
if ( pPathType && pSearchPath->m_bIsRemotePath )
{
*pPathType |= PATH_IS_REMOTE;
}
return pDest;
}
}
// not found
return NULL;
}
const char *CBaseFileSystem::GetLocalPath( const char *pFileName, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars )
{
CHECK_DOUBLE_SLASHES( pFileName );
return RelativePathToFullPath( pFileName, NULL, pDest, maxLenInChars );
}
//-----------------------------------------------------------------------------
// Returns true on success, otherwise false if it can't be resolved
//-----------------------------------------------------------------------------
bool CBaseFileSystem::FullPathToRelativePathEx( const char *pFullPath, const char *pPathId, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars )
{
CHECK_DOUBLE_SLASHES( pFullPath );
int nInlen = V_strlen( pFullPath );
if ( nInlen <= 0 )
{
pDest[ 0 ] = 0;
return false;
}
V_strncpy( pDest, pFullPath, maxLenInChars );
char pInPath[ MAX_FILEPATH ];
V_strcpy_safe( pInPath, pFullPath );
#ifdef _WIN32
V_strlower( pInPath );
#endif
V_FixSlashes( pInPath );
CUtlSymbol lookup;
if ( pPathId )
{
lookup = g_PathIDTable.AddString( pPathId );
}
int c = m_SearchPaths.Count();
for( int i = 0; i < c; i++ )
{
// FIXME: Should this work with embedded pak files?
if ( m_SearchPaths[i].GetPackFile() && m_SearchPaths[i].GetPackFile()->m_bIsMapPath )
continue;
// Skip paths that are not on the specified search path
if ( FilterByPathID( &m_SearchPaths[i], lookup ) )
continue;
char pSearchBase[ MAX_FILEPATH ];
V_strncpy( pSearchBase, m_SearchPaths[i].GetPathString(), sizeof( pSearchBase ) );
#ifdef _WIN32
V_strlower( pSearchBase );
#endif
V_FixSlashes( pSearchBase );
int nSearchLen = V_strlen( pSearchBase );
if ( V_strnicmp( pSearchBase, pInPath, nSearchLen ) )
continue;
V_strncpy( pDest, &pInPath[ nSearchLen ], maxLenInChars );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Obsolete version
//-----------------------------------------------------------------------------
bool CBaseFileSystem::FullPathToRelativePath( const char *pFullPath, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars )
{
return FullPathToRelativePathEx( pFullPath, NULL, pDest, maxLenInChars );
}
//-----------------------------------------------------------------------------
// Returns true on successfully retrieve case-sensitive full path, otherwise false
//-----------------------------------------------------------------------------
bool CBaseFileSystem::GetCaseCorrectFullPath_Ptr( const char *pFullPath, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars )
{
CHECK_DOUBLE_SLASHES( pFullPath );
#ifndef _WIN32
V_strncpy( pDest, pFullPath, maxLenInChars );
return true;
#else
char szCurrentDir[MAX_PATH];
V_strcpy_safe( szCurrentDir, pFullPath );
V_StripLastDir( szCurrentDir, sizeof( szCurrentDir ) );
CUtlString strSearchName = pFullPath;
strSearchName.StripTrailingSlash();
strSearchName = strSearchName.Slice( V_strlen( szCurrentDir ), strSearchName.Length() );
CUtlString strSearchPath = szCurrentDir;
strSearchPath += "*";
CUtlString strFoundCaseCorrectName;
FileFindHandle_t findHandle;
const char *pszCaseCorrectName = FindFirst( strSearchPath.Get(), &findHandle );
while ( pszCaseCorrectName )
{
if ( V_stricmp( strSearchName.String(), pszCaseCorrectName ) == 0 )
{
strFoundCaseCorrectName = pszCaseCorrectName;
break;
}
pszCaseCorrectName = FindNext( findHandle );
}
FindClose( findHandle );
// Not found
if ( strFoundCaseCorrectName.IsEmpty() )
{
V_strncpy( pDest, pFullPath, maxLenInChars );
return false;
}
// If drive path, no need to recurse anymore.
bool bResult = false;
char szDir[MAX_PATH];
if ( !IsDirectory( szCurrentDir, NULL ) )
{
V_strupr( szCurrentDir );
V_strncpy( szDir, szCurrentDir, sizeof( szDir ) );
bResult = true;
}
else
{
bResult = GetCaseCorrectFullPath( szCurrentDir, szDir );
}
// connect the current path with the case-correct dir/file name
V_MakeAbsolutePath( pDest, maxLenInChars, strFoundCaseCorrectName.String(), szDir );
return bResult;
#endif // _WIN32
}
//-----------------------------------------------------------------------------
// Deletes a file
//-----------------------------------------------------------------------------
void CBaseFileSystem::RemoveFile( char const* pRelativePath, const char *pathID )
{
CHECK_DOUBLE_SLASHES( pRelativePath );
// Allow for UNC-type syntax to specify the path ID.
char tempPathID[MAX_PATH];
ParsePathID( pRelativePath, pathID, tempPathID );
Assert( pathID || !IsX360() );
// Opening for write or append uses Write Path
char szScratchFileName[MAX_PATH];
if ( Q_IsAbsolutePath( pRelativePath ) )
{
Q_strncpy( szScratchFileName, pRelativePath, sizeof( szScratchFileName ) );
}
else
{
ComputeFullWritePath( szScratchFileName, sizeof( szScratchFileName ), pRelativePath, pathID );
}
int fail = unlink( szScratchFileName );
if ( fail != 0 )
{
Warning( FILESYSTEM_WARNING, "Unable to remove %s!\n", szScratchFileName );
}
}
//-----------------------------------------------------------------------------
// Renames a file
//-----------------------------------------------------------------------------
bool CBaseFileSystem::RenameFile( char const *pOldPath, char const *pNewPath, const char *pathID )
{
Assert( pOldPath && pNewPath );
CHECK_DOUBLE_SLASHES( pOldPath );
CHECK_DOUBLE_SLASHES( pNewPath );
// Allow for UNC-type syntax to specify the path ID.
char pPathIdCopy[MAX_PATH];
const char *pOldPathId = pathID;
if ( pathID )
{
Q_strncpy( pPathIdCopy, pathID, sizeof( pPathIdCopy ) );
pOldPathId = pPathIdCopy;
}
char tempOldPathID[MAX_PATH];
ParsePathID( pOldPath, pOldPathId, tempOldPathID );
Assert( pOldPathId );
// Allow for UNC-type syntax to specify the path ID.
char tempNewPathID[MAX_PATH];
ParsePathID( pNewPath, pathID, tempNewPathID );
Assert( pathID );
char pNewFileName[ MAX_PATH ];
char szScratchFileName[MAX_PATH];
// The source file may be in a fallback directory, so just resolve the actual path, don't assume pathid...
RelativePathToFullPath( pOldPath, pOldPathId, szScratchFileName, sizeof( szScratchFileName ) );
// Figure out the dest path
if ( !Q_IsAbsolutePath( pNewPath ) )
{
ComputeFullWritePath( pNewFileName, sizeof( pNewFileName ), pNewPath, pathID );
}
else
{
Q_strncpy( pNewFileName, pNewPath, sizeof(pNewFileName) );
}
// Make sure the directory exitsts, too
char pPathOnly[ MAX_PATH ];
Q_strncpy( pPathOnly, pNewFileName, sizeof( pPathOnly ) );
Q_StripFilename( pPathOnly );
CreateDirHierarchy( pPathOnly, pathID );
// Now copy the file over
int fail = rename( szScratchFileName, pNewFileName );
if (fail != 0)
{
Warning( FILESYSTEM_WARNING, "Unable to rename %s to %s!\n", szScratchFileName, pNewFileName );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : **ppdir -
//-----------------------------------------------------------------------------
bool CBaseFileSystem::GetCurrentDirectory( char* pDirectory, int maxlen )
{
#if defined( _WIN32 ) && !defined( _X360 )
if ( !::GetCurrentDirectoryA( maxlen, pDirectory ) )
#elif defined( POSIX ) || defined( _X360 )
if ( !getcwd( pDirectory, maxlen ) )
#endif
return false;
Q_FixSlashes(pDirectory);
// Strip the last slash
int len = strlen(pDirectory);
if ( pDirectory[ len-1 ] == CORRECT_PATH_SEPARATOR )
{
pDirectory[ len-1 ] = 0;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pfnWarning - warning function callback
//-----------------------------------------------------------------------------
void CBaseFileSystem::SetWarningFunc( void (*pfnWarning)( const char *fmt, ... ) )
{
m_pfnWarning = pfnWarning;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : level -
//-----------------------------------------------------------------------------
void CBaseFileSystem::SetWarningLevel( FileWarningLevel_t level )
{
m_fwLevel = level;
}
const FileSystemStatistics *CBaseFileSystem::GetFilesystemStatistics()
{
return &m_Stats;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : level -
// *fmt -
// ... -
//-----------------------------------------------------------------------------
void CBaseFileSystem::Warning( FileWarningLevel_t level, const char *fmt, ... )
{
if ( level > m_fwLevel )
return;
if ( ( fs_warning_mode.GetInt() == 1 && !ThreadInMainThread() ) || ( fs_warning_mode.GetInt() == 2 && ThreadInMainThread() ) )
return;
va_list argptr;
char warningtext[ 4096 ];
va_start( argptr, fmt );
Q_vsnprintf( warningtext, sizeof( warningtext ), fmt, argptr );
va_end( argptr );
// Dump to stdio
printf( "%s", warningtext );
if ( m_pfnWarning )
{
(*m_pfnWarning)( warningtext );
}
else
{
#ifdef _WIN32
Plat_DebugString( warningtext );
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::COpenedFile::COpenedFile( void )
{
m_pFile = NULL;
m_pName = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::COpenedFile::~COpenedFile( void )
{
delete[] m_pName;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : src -
//-----------------------------------------------------------------------------
CBaseFileSystem::COpenedFile::COpenedFile( const COpenedFile& src )
{
m_pFile = src.m_pFile;
if ( src.m_pName )
{
int len = strlen( src.m_pName ) + 1;
m_pName = new char[ len ];
Q_strncpy( m_pName, src.m_pName, len );
}
else
{
m_pName = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : src -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFileSystem::COpenedFile::operator==( const CBaseFileSystem::COpenedFile& src ) const
{
return src.m_pFile == m_pFile;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
//-----------------------------------------------------------------------------
void CBaseFileSystem::COpenedFile::SetName( char const *name )
{
delete[] m_pName;
int len = strlen( name ) + 1;
m_pName = new char[ len ];
Q_strncpy( m_pName, name, len );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char
//-----------------------------------------------------------------------------
char const *CBaseFileSystem::COpenedFile::GetName( void )
{
return m_pName ? m_pName : "???";
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath::CSearchPath( void )
{
m_Path = g_PathIDTable.AddString( "" );
m_pDebugPath = "";
m_storeId = 0;
m_pPackFile = NULL;
m_pPathIDInfo = NULL;
m_bIsRemotePath = false;
m_pPackedStore = NULL;
m_bIsTrustedForPureServer = false;
}
const char *CBaseFileSystem::CSearchPath::GetDebugString() const
{
if ( GetPackFile() )
{
return GetPackFile()->m_ZipName;
}
#ifdef SUPPORT_PACKED_STORE
if ( GetPackedStore() )
{
return GetPackedStore()->FullPathName();
}
#endif
return GetPathString();
}
bool CBaseFileSystem::CSearchPath::IsMapPath() const
{
return GetPackFile()->m_bIsMapPath;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath::~CSearchPath( void )
{
if ( m_pPackFile )
{
m_pPackFile->Release();
}
if ( m_pPackedStore )
{
m_pPackedStore->Release();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath *CBaseFileSystem::CSearchPathsIterator::GetFirst()
{
if ( m_SearchPaths.Count() )
{
m_visits.Reset();
m_iCurrent = -1;
return GetNext();
}
return &m_EmptySearchPath;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseFileSystem::CSearchPath *CBaseFileSystem::CSearchPathsIterator::GetNext()
{
CSearchPath *pSearchPath = NULL;
for ( m_iCurrent++; m_iCurrent < m_SearchPaths.Count(); m_iCurrent++ )
{
pSearchPath = &m_SearchPaths[m_iCurrent];
if ( m_PathTypeFilter == FILTER_CULLPACK && pSearchPath->GetPackFile() )
continue;
if ( m_PathTypeFilter == FILTER_CULLNONPACK && !pSearchPath->GetPackFile() )
continue;
if ( CBaseFileSystem::FilterByPathID( pSearchPath, m_pathID ) )
continue;
// 360 can optionally ignore a local search path in dvddev mode
// ignoring a local search path falls through to its cloned remote path
// map paths are exempt from this exclusion logic
if ( IsX360() && ( m_DVDMode == DVDMODE_DEV ) && m_Filename[0] && !pSearchPath->m_bIsRemotePath )
{
bool bIsMapPath = pSearchPath->GetPackFile() && pSearchPath->GetPackFile()->m_bIsMapPath;
if ( !bIsMapPath )
{
bool bIgnorePath = false;
char szExcludePath[MAX_PATH];
char szFilename[MAX_PATH];
V_ComposeFileName( pSearchPath->GetPathString(), m_Filename, szFilename, sizeof( szFilename ) );
for ( int i = 0; i < m_ExcludePaths.Count(); i++ )
{
if ( g_pFullFileSystem->String( m_ExcludePaths[i], szExcludePath, sizeof( szExcludePath ) ) )
{
if ( !V_strnicmp( szFilename, szExcludePath, strlen( szExcludePath ) ) )
{
bIgnorePath = true;
break;
}
}
}
if ( bIgnorePath )
{
// filename matches exclusion path, skip it
continue;
}
}
}
if ( !m_visits.MarkVisit( *pSearchPath ) )
break;
}
if ( m_iCurrent < m_SearchPaths.Count() )
{
return pSearchPath;
}
return NULL;
}
void CBaseFileSystem::CSearchPathsIterator::CopySearchPaths( const CUtlVector<CSearchPath> &searchPaths )
{
m_SearchPaths = searchPaths;
for ( int i = 0; i < m_SearchPaths.Count(); i++ )
{
if ( m_SearchPaths[i].GetPackFile() )
{
m_SearchPaths[i].GetPackFile()->AddRef();
}
else if ( m_SearchPaths[i].GetPackedStore() )
{
m_SearchPaths[i].GetPackedStore()->AddRef();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Load/unload a DLL
//-----------------------------------------------------------------------------
CSysModule *CBaseFileSystem::LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly )
{
CHECK_DOUBLE_SLASHES( pFileName );
fix loading libraries with lib prefix
4 years ago
CSysModule *pModule = NULL;
1
5 years ago
LogFileAccess( pFileName );
if ( !pPathID )
{
pPathID = "EXECUTABLE_PATH"; // default to the bin dir
}
char tempPathID[ MAX_PATH ];
ParsePathID( pFileName, pPathID, tempPathID );
tier1: rewrite Sys_LoadModule
2 years ago
1
5 years ago
CUtlSymbol lookup = g_PathIDTable.AddString( pPathID );
// a pathID has been specified, find the first match in the path list
tier1: rewrite Sys_LoadModule
2 years ago
#ifndef ANDROID
1
5 years ago
int c = m_SearchPaths.Count();
for ( int i = 0; i < c; i++ )
{
// pak files don't have modules
if ( m_SearchPaths[i].GetPackFile() )
continue;
if ( FilterByPathID( &m_SearchPaths[i], lookup ) )
continue;
Q_snprintf( tempPathID, sizeof(tempPathID), "%s%s", m_SearchPaths[i].GetPathString(), pFileName ); // append the path to this dir.
fix loading libraries with lib prefix
4 years ago
pModule = Sys_LoadModule( tempPathID );
1
5 years ago
if ( pModule )
{
// we found the binary in one of our search paths
return pModule;
}
fix loading libraries with lib prefix
4 years ago
#ifdef POSIX
Q_snprintf( tempPathID, sizeof(tempPathID), "%slib%s", m_SearchPaths[i].GetPathString(), pFileName ); // append the path to this dir.
pModule = Sys_LoadModule( tempPathID );
if ( pModule )
return pModule;
#endif
}
Initial android support (#17) * Upload Android armv7 libs * Fix debug build * utlvector: fix undefined behavior * wscript: add --use-ccache option * wscript: store ccache in a separate directory * Propertly use gl4es * fontconfig: fix font detection * [android]remove fontconfig dependency * Add build guide for other platforms Co-authored-by: JusicP <slender87844@gmail.com> Co-authored-by: nillerusr <nillerusr@users.noreply.github.com>
3 years ago
#endif
if( !pModule )
pModule = Sys_LoadModule( pFileName );
1
5 years ago
fix loading libraries with lib prefix
4 years ago
return pModule;
1
5 years ago
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFileSystem::UnloadModule( CSysModule *pModule )
{
Sys_UnloadModule( pModule );
}
//-----------------------------------------------------------------------------
// Purpose: Adds a filesystem logging function
//-----------------------------------------------------------------------------
void CBaseFileSystem::AddLoggingFunc( FileSystemLoggingFunc_t logFunc )
{
Assert(!m_LogFuncs.IsValidIndex(m_LogFuncs.Find(logFunc)));
m_LogFuncs.AddToTail(logFunc);
}
//-----------------------------------------------------------------------------
// Purpose: Removes a filesystem logging function
//-----------------------------------------------------------------------------
void CBaseFileSystem::RemoveLoggingFunc( FileSystemLoggingFunc_t logFunc )
{
m_LogFuncs.FindAndRemove(logFunc);
}
//-----------------------------------------------------------------------------
// Make sure that slashes are of the right kind and that there is a slash at the
// end of the filename.
// WARNING!!: assumes that you have an extra byte allocated in the case that you need
// a slash at the end.
//-----------------------------------------------------------------------------
static void AddSeperatorAndFixPath( char *str )
{
char *lastChar = &str[strlen( str ) - 1];
if( *lastChar != CORRECT_PATH_SEPARATOR && *lastChar != INCORRECT_PATH_SEPARATOR )
{
lastChar[1] = CORRECT_PATH_SEPARATOR;
lastChar[2] = '\0';
}
Q_FixSlashes( str );
if ( IsX360() )
{
// 360 FS won't resolve any path with ../
V_RemoveDotSlashes( str );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFileName -
// Output : FileNameHandle_t
//-----------------------------------------------------------------------------
FileNameHandle_t CBaseFileSystem::FindOrAddFileName( char const *pFileName )
{
return m_FileNames.FindOrAddFileName( pFileName );
}
FileNameHandle_t CBaseFileSystem::FindFileName( char const *pFileName )
{
return m_FileNames.FindFileName( pFileName );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : handle -
// Output : char const
//-----------------------------------------------------------------------------
bool CBaseFileSystem::String( const FileNameHandle_t& handle, char *buf, int buflen )
{
return m_FileNames.String( handle, buf, buflen );
}
int CBaseFileSystem::GetPathIndex( const FileNameHandle_t &handle )
{
return m_FileNames.PathIndex(handle);
}
CBaseFileSystem::CPathIDInfo* CBaseFileSystem::FindOrAddPathIDInfo( const CUtlSymbol &id, int bByRequestOnly )
{
for ( int i=0; i < m_PathIDInfos.Count(); i++ )
{
CBaseFileSystem::CPathIDInfo *pInfo = m_PathIDInfos[i];
if ( pInfo->GetPathID() == id )
{
if ( bByRequestOnly != -1 )
{
pInfo->m_bByRequestOnly = (bByRequestOnly != 0);
}
return pInfo;
}
}
// Add a new one.
CBaseFileSystem::CPathIDInfo *pInfo = new CBaseFileSystem::CPathIDInfo;
m_PathIDInfos.AddToTail( pInfo );
pInfo->SetPathID( id );
pInfo->m_bByRequestOnly = (bByRequestOnly == 1);
return pInfo;
}
void CBaseFileSystem::MarkPathIDByRequestOnly( const char *pPathID, bool bRequestOnly )
{
FindOrAddPathIDInfo( g_PathIDTable.AddString( pPathID ), bRequestOnly );
}
#if defined( TRACK_BLOCKING_IO )
void CBaseFileSystem::EnableBlockingFileAccessTracking( bool state )
{
m_bBlockingFileAccessReportingEnabled = state;
}
bool CBaseFileSystem::IsBlockingFileAccessEnabled() const
{
return m_bBlockingFileAccessReportingEnabled;
}
IBlockingFileItemList *CBaseFileSystem::RetrieveBlockingFileAccessInfo()
{
Assert( m_pBlockingItems );
return m_pBlockingItems;
}
void CBaseFileSystem::RecordBlockingFileAccess( bool synchronous, const FileBlockingItem& item )
{
AUTO_LOCK( m_BlockingFileMutex );
// Not tracking anything
if ( !m_bBlockingFileAccessReportingEnabled )
return;
if ( synchronous && !m_bAllowSynchronousLogging && ( item.m_ItemType == FILESYSTEM_BLOCKING_SYNCHRONOUS ) )
return;
// Track it
m_pBlockingItems->Add( item );
}
bool CBaseFileSystem::SetAllowSynchronousLogging( bool state )
{
bool oldState = m_bAllowSynchronousLogging;
m_bAllowSynchronousLogging = state;
return oldState;
}
void CBaseFileSystem::BlockingFileAccess_EnterCriticalSection()
{
m_BlockingFileMutex.Lock();
}
void CBaseFileSystem::BlockingFileAccess_LeaveCriticalSection()
{
m_BlockingFileMutex.Unlock();
}
#endif // TRACK_BLOCKING_IO
bool CBaseFileSystem::GetFileTypeForFullPath( char const *pFullPath, wchar_t *buf, size_t bufSizeInBytes )
{
#if !defined( _X360 ) && !defined( POSIX )
wchar_t wcharpath[512];
::MultiByteToWideChar( CP_UTF8, 0, pFullPath, -1, wcharpath, sizeof( wcharpath ) / sizeof(wchar_t) );
wcharpath[(sizeof( wcharpath ) / sizeof(wchar_t)) - 1] = L'\0';
SHFILEINFOW info = { 0 };
DWORD_PTR dwResult = SHGetFileInfoW(
wcharpath,
0,
&info,
sizeof( info ),
SHGFI_TYPENAME
);
if ( dwResult )
{
wcsncpy( buf, info.szTypeName, ( bufSizeInBytes / sizeof( wchar_t ) ) );
buf[( bufSizeInBytes / sizeof( wchar_t ) ) - 1] = L'\0';
return true;
}
else
#endif
{
char ext[32];
Q_ExtractFileExtension( pFullPath, ext, sizeof( ext ) );
#ifdef POSIX
_snwprintf( buf, ( bufSizeInBytes / sizeof( wchar_t ) ) - 1, L"%s File", V_strupr( ext ) ); // Matches what Windows does
#else
_snwprintf( buf, ( bufSizeInBytes / sizeof( wchar_t ) ) - 1, L".%S", ext );
#endif
buf[( bufSizeInBytes / sizeof( wchar_t ) ) - 1] = L'\0';
}
return false;
}
bool CBaseFileSystem::GetOptimalIOConstraints( FileHandle_t hFile, unsigned *pOffsetAlign, unsigned *pSizeAlign, unsigned *pBufferAlign )
{
if ( pOffsetAlign )
*pOffsetAlign = 1;
if ( pSizeAlign )
*pSizeAlign = 1;
if ( pBufferAlign )
*pBufferAlign = 1;
return false;
}
//-----------------------------------------------------------------------------
FileCacheHandle_t CBaseFileSystem::CreateFileCache( )
{
return new CFileCacheObject( this );
}
//-----------------------------------------------------------------------------
void CBaseFileSystem::AddFilesToFileCache( FileCacheHandle_t cacheId, const char **ppFileNames, int nFileNames, const char *pPathID )
{
// For now, assuming that we're only used with GAME.
Assert( pPathID && Q_strcasecmp( pPathID, "GAME" ) == 0 );
return static_cast< CFileCacheObject * >( cacheId )->AddFiles( ppFileNames, nFileNames );
}
//-----------------------------------------------------------------------------
bool CBaseFileSystem::IsFileCacheLoaded( FileCacheHandle_t cacheId )
{
return static_cast< CFileCacheObject * >( cacheId )->IsReady();
}
//-----------------------------------------------------------------------------
void CBaseFileSystem::DestroyFileCache( FileCacheHandle_t cacheId )
{
delete static_cast< CFileCacheObject * >( cacheId );
}
//-----------------------------------------------------------------------------
bool CBaseFileSystem::IsFileCacheFileLoaded( FileCacheHandle_t cacheId, const char* pFileName )
{
#ifdef _DEBUG
CFileCacheObject* pFileCache = static_cast< CFileCacheObject * >( cacheId );
bool bFileIsHeldByCache = false;
{
AUTO_LOCK( pFileCache->m_InfosMutex );
for ( int i = 0; i < pFileCache->m_Infos.Count(); ++i )
{
if ( pFileCache->m_Infos[i]->pFileName && Q_strcmp( pFileCache->m_Infos[i]->pFileName, pFileName ) )
{
bFileIsHeldByCache = true;
break;
}
}
}
Assert( bFileIsHeldByCache );
#endif
AUTO_LOCK( m_MemoryFileMutex );
return m_MemoryFileHash.Find( pFileName ) != m_MemoryFileHash.InvalidHandle();
}
//-----------------------------------------------------------------------------
bool CBaseFileSystem::RegisterMemoryFile( CMemoryFileBacking *pFile, CMemoryFileBacking **ppExistingFileWithRef )
{
Assert( pFile->m_pFS == static_cast< IFileSystem* >( this ) );
Assert( pFile->m_pFileName && pFile->m_pFileName[0] );
AUTO_LOCK( m_MemoryFileMutex );
CMemoryFileBacking *pInTable = m_MemoryFileHash[ m_MemoryFileHash.Insert( pFile->m_pFileName, pFile ) ];
pInTable->m_nRegistered++;
pInTable->AddRef(); // either for table or for ppExistingFileWithRef return
if ( pFile == pInTable )
{
Assert( pInTable->m_nRegistered == 1 );
*ppExistingFileWithRef = NULL;
return true;
}
else
{
Assert( pInTable->m_nRegistered > 1 );
*ppExistingFileWithRef = pInTable;
return false;
}
}
//-----------------------------------------------------------------------------
void CBaseFileSystem::UnregisterMemoryFile( CMemoryFileBacking *pFile )
{
Assert( pFile->m_pFS == static_cast< IFileSystem* >( this ) && pFile->m_nRegistered > 0 );
bool bRelease = false;
{
AUTO_LOCK( m_MemoryFileMutex );
pFile->m_nRegistered--;
if ( pFile->m_nRegistered == 0 )
{
m_MemoryFileHash.Remove( pFile->m_pFileName );
bRelease = true;
}
}
// Release potentially a complex op, prefer to perform it outside of mutex.
if (bRelease)
{
pFile->Release();
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructs a file handle
// Input : base file system handle
// Output :
//-----------------------------------------------------------------------------
CFileHandle::CFileHandle( CBaseFileSystem* fs )
{
Init( fs );
}
CFileHandle::~CFileHandle()
{
Assert( IsValid() );
#if !defined( _RETAIL )
delete[] m_pszTrueFileName;
#endif
if ( m_pPackFileHandle )
{
delete m_pPackFileHandle;
m_pPackFileHandle = NULL;
}
if ( m_pFile )
{
m_fs->Trace_FClose( m_pFile );
m_pFile = NULL;
}
m_nMagic = FREE_MAGIC;
}
void CFileHandle::Init( CBaseFileSystem *fs )
{
m_nMagic = MAGIC;
m_pFile = NULL;
m_nLength = 0;
m_type = FT_NORMAL;
m_pPackFileHandle = NULL;
m_fs = fs;
#if !defined( _RETAIL )
m_pszTrueFileName = 0;
#endif
}
bool CFileHandle::IsValid()
{
return ( m_nMagic == MAGIC );
}
int CFileHandle::GetSectorSize()
{
Assert( IsValid() );
if ( m_pFile )
{
return m_fs->FS_GetSectorSize( m_pFile );
}
else if ( m_pPackFileHandle )
{
return m_pPackFileHandle->GetSectorSize();
}
else if ( m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return 1;
}
else
{
return -1;
}
}
bool CFileHandle::IsOK()
{
#if defined( SUPPORT_PACKED_STORE )
if ( m_VPKHandle )
{
return true;
}
#endif
if ( m_pFile )
{
return ( IsValid() && m_fs->FS_ferror( m_pFile ) == 0 );
}
else if ( m_pPackFileHandle || m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return IsValid();
}
m_fs->Warning( FILESYSTEM_WARNING, "FS: Tried to IsOk NULL file pointer inside valid file handle!\n" );
return false;
}
void CFileHandle::Flush()
{
Assert( IsValid() );
if ( m_pFile )
{
m_fs->FS_fflush( m_pFile );
}
}
void CFileHandle::SetBufferSize( int nBytes )
{
Assert( IsValid() );
if ( m_pFile )
{
m_fs->FS_setbufsize( m_pFile, nBytes );
}
else if ( m_pPackFileHandle )
{
m_pPackFileHandle->SetBufferSize( nBytes );
}
}
int CFileHandle::Read( void* pBuffer, int nLength )
{
Assert( IsValid() );
return Read( pBuffer, -1, nLength );
}
int CFileHandle::Read( void* pBuffer, int nDestSize, int nLength )
{
Assert( IsValid() );
#if defined( SUPPORT_PACKED_STORE )
if ( m_VPKHandle )
{
if ( nDestSize >= 0 )
nLength = MIN( nLength, nDestSize );
return m_VPKHandle.Read( pBuffer, nLength );
}
#endif
// Is this a regular file or a pack file?
if ( m_pFile )
{
return m_fs->FS_fread( pBuffer, nDestSize, nLength, m_pFile );
}
else if ( m_pPackFileHandle )
{
// Pack file handle handles clamping all the reads:
return m_pPackFileHandle->Read( pBuffer, nDestSize, nLength );
}
else if ( m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return static_cast< CMemoryFileHandle* >( this )->Read( pBuffer, nDestSize, nLength );
}
return 0;
}
int CFileHandle::Write( const void* pBuffer, int nLength )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
if( ThreadInMainThread() )
{
tmPlotI32( TELEMETRY_LEVEL0, TMPT_MEMORY, 0, nLength, "FileBytesWrite" );
}
Assert( IsValid() );
if ( !m_pFile )
{
m_fs->Warning( FILESYSTEM_WARNING, "FS: Tried to Write NULL file pointer inside valid file handle!\n" );
return 0;
}
size_t nBytesWritten = m_fs->FS_fwrite( (void*)pBuffer, nLength, m_pFile );
m_fs->Trace_FWrite(nBytesWritten,m_pFile);
return nBytesWritten;
}
int CFileHandle::Seek( int64 nOffset, int nWhence )
{
Assert( IsValid() );
#if defined( SUPPORT_PACKED_STORE )
if ( m_VPKHandle )
{
return m_VPKHandle.Seek( nOffset, nWhence );
}
#endif
if ( m_pFile )
{
m_fs->FS_fseek( m_pFile, nOffset, nWhence );
// TODO - FS_fseek should return the resultant offset
return 0;
}
else if ( m_pPackFileHandle )
{
return m_pPackFileHandle->Seek( nOffset, nWhence );
}
else if ( m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return static_cast< CMemoryFileHandle* >( this )->Seek( nOffset, nWhence );
}
return -1;
}
int CFileHandle::Tell()
{
Assert( IsValid() );
#if defined( SUPPORT_PACKED_STORE )
if ( m_VPKHandle )
{
return m_VPKHandle.Tell();
}
#endif
if ( m_pFile )
{
return m_fs->FS_ftell( m_pFile );
}
else if ( m_pPackFileHandle )
{
return m_pPackFileHandle->Tell();
}
else if ( m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return static_cast< CMemoryFileHandle* >( this )->Tell();
}
return -1;
}
int CFileHandle::Size()
{
Assert( IsValid() );
int nReturnedSize = -1;
#if defined( SUPPORT_PACKED_STORE )
if ( m_VPKHandle )
{
return m_VPKHandle.m_nFileSize;
}
#endif
if ( m_pFile )
{
nReturnedSize = m_nLength;
}
else if ( m_pPackFileHandle )
{
nReturnedSize = m_pPackFileHandle->Size();
}
else if ( m_type == FT_MEMORY_BINARY || m_type == FT_MEMORY_TEXT )
{
return static_cast< CMemoryFileHandle* >( this )->Size();
}
return nReturnedSize;
}
int64 CFileHandle::AbsoluteBaseOffset()
{
Assert( IsValid() );
if ( !m_pFile && m_pPackFileHandle )
{
return m_pPackFileHandle->AbsoluteBaseOffset();
}
else
{
return 0;
}
}
bool CFileHandle::EndOfFile()
{
Assert( IsValid() );
return ( Tell() >= Size() );
}
//-----------------------------------------------------------------------------
int CMemoryFileHandle::Read( void* pBuffer, int nDestSize, int nLength )
{
nLength = min( nLength, (int) m_nLength - m_nPosition );
if ( nLength > 0 )
{
Assert( m_nPosition >= 0 );
memcpy( pBuffer, m_pBacking->m_pData + m_nPosition, nLength );
m_nPosition += nLength;
return nLength;
}
if ( m_nPosition >= (int) m_nLength )
{
return -1;
}
return 0;
}
int CMemoryFileHandle::Seek( int64 nOffset64, int nWhence )
{
if ( nWhence == SEEK_SET )
{
m_nPosition = (int) clamp( nOffset64, 0ll, m_nLength );
}
else if ( nWhence == SEEK_CUR )
{
m_nPosition += (int) clamp( nOffset64, -(int64)m_nPosition, m_nLength - m_nPosition );
}
else if ( nWhence == SEEK_END )
{
m_nPosition = (int) m_nLength + (int) clamp( nOffset64, -m_nLength, 0ll );
}
return m_nPosition;
}
//-----------------------------------------------------------------------------
CBaseFileSystem::CFileCacheObject::CFileCacheObject( CBaseFileSystem* pFS )
: m_pFS( pFS )
{
}
void CBaseFileSystem::CFileCacheObject::AddFiles( const char **ppFileNames, int nFileNames )
{
CUtlVector< Info_t* > infos;
infos.SetCount( nFileNames );
for ( int i = 0; i < nFileNames; ++i )
{
infos[i] = new Info_t;
Info_t &info = *infos[i];
info.pFileName = strdup( ppFileNames[i] );
V_FixSlashes( (char*) info.pFileName );
#ifdef _WIN32
Q_strlower( (char*) info.pFileName );
#endif
info.hIOAsync = NULL;
info.pBacking = NULL;
info.pOwner = NULL;
}
AUTO_LOCK( m_InfosMutex );
int offset = m_Infos.AddMultipleToTail( nFileNames, infos.Base() );
m_nPending += nFileNames;
ProcessNewEntries(offset);
}
void CBaseFileSystem::CFileCacheObject::ProcessNewEntries( int start )
{
for ( int i = start; i < m_Infos.Count(); ++i )
{
Info_t &info = *m_Infos[i];
if ( !info.pOwner )
{
info.pOwner = this;
// NOTE: currently only caching files with GAME pathID
FileAsyncRequest_t request;
request.pszFilename = info.pFileName;
request.pszPathID = "GAME";
request.flags = FSASYNC_FLAGS_ALLOCNOFREE;
request.pfnCallback = &IOCallback;
request.pContext = &info;
if ( m_pFS->AsyncRead( request, &info.hIOAsync ) != FSASYNC_OK )
{
--m_nPending;
}
}
}
}
void CBaseFileSystem::CFileCacheObject::IOCallback( const FileAsyncRequest_t &request, int nBytesRead, FSAsyncStatus_t err )
{
Assert( request.pContext );
Info_t &info = *(Info_t *)request.pContext;
CMemoryFileBacking *pBacking = new CMemoryFileBacking( info.pOwner->m_pFS );
pBacking->m_pData = NULL;
pBacking->m_pFileName = info.pFileName;
pBacking->m_nLength = ( err == FSASYNC_OK && nBytesRead == 0 ) ? 0 : -1;
if ( request.pData )
{
if ( err == FSASYNC_OK && nBytesRead > 0 )
{
pBacking->m_pData = (const char*) request.pData; // transfer data ownership
pBacking->m_nLength = nBytesRead;
}
else
{
info.pOwner->m_pFS->FreeOptimalReadBuffer( request.pData );
}
}
CMemoryFileBacking *pExistingBacking = NULL;
if ( !info.pOwner->m_pFS->RegisterMemoryFile( pBacking, &pExistingBacking ) )
{
// Someone already registered this file
info.pFileName = pExistingBacking->m_pFileName;
pBacking->Release();
pBacking = pExistingBacking;
}
//DevWarning("preload %s %d\n", request.pszFilename, pBacking->m_nLength);
info.pBacking = pBacking;
info.pOwner->m_nPending--;
}
CBaseFileSystem::CFileCacheObject::~CFileCacheObject()
{
AUTO_LOCK( m_InfosMutex );
for ( int i = 0; i < m_Infos.Count(); ++i )
{
Info_t& info = *m_Infos[i];
if ( info.hIOAsync )
{
// job is guaranteed to not be running after abort
m_pFS->AsyncAbort( info.hIOAsync );
m_pFS->AsyncRelease( info.hIOAsync );
}
if ( info.pBacking )
{
m_pFS->UnregisterMemoryFile( info.pBacking );
info.pBacking->Release();
}
else
{
free( (char*) info.pFileName );
}
delete m_Infos[i];
}
Assert( m_nPending == 0 );
}