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.

1002 lines
35 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#ifndef BASEFILESYSTEM_H
#define BASEFILESYSTEM_H
#ifdef _WIN32
#pragma once
#endif
#if defined( _WIN32 )
#if !defined( _X360 )
#include <io.h>
#include <direct.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#undef GetCurrentDirectory
#undef GetJob
#undef AddJob
#include "tier0/threadtools.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <malloc.h>
#include <string.h>
#include "tier1/utldict.h"
#elif defined(POSIX)
#include <unistd.h> // unlink
#include "linux_support.h"
#define INVALID_HANDLE_VALUE (void *)-1
// undo the prepended "_" 's
#define _chmod chmod
#define _stat stat
#define _alloca alloca
#define _S_IFDIR S_IFDIR
#endif
#include <time.h>
#include "refcount.h"
#include "filesystem.h"
#include "tier1/utlvector.h"
#include <stdarg.h>
#include "tier1/utlhashtable.h"
#include "tier1/utlrbtree.h"
#include "tier1/utlsymbol.h"
#include "tier1/utllinkedlist.h"
#include "tier1/utlstring.h"
#include "tier1/UtlSortVector.h"
#include "bspfile.h"
#include "tier1/utldict.h"
#include "tier1/tier1.h"
#include "byteswap.h"
#include "threadsaferefcountedobject.h"
#include "filetracker.h"
// #include "filesystem_init.h"
#if defined( SUPPORT_PACKED_STORE )
#include "vpklib/packedstore.h"
#endif
#include "tier0/memdbgon.h"
#ifdef _WIN32
#define CORRECT_PATH_SEPARATOR '\\'
#define INCORRECT_PATH_SEPARATOR '/'
#elif defined(POSIX)
#define CORRECT_PATH_SEPARATOR '/'
#define INCORRECT_PATH_SEPARATOR '\\'
#endif
#ifdef _WIN32
#define PATHSEPARATOR(c) ((c) == '\\' || (c) == '/')
#elif defined(POSIX)
#define PATHSEPARATOR(c) ((c) == '/')
#endif //_WIN32
#define MAX_FILEPATH 512
extern CUtlSymbolTableMT g_PathIDTable;
enum FileMode_t
{
FM_BINARY,
FM_TEXT
};
enum FileType_t
{
FT_NORMAL,
FT_PACK_BINARY,
FT_PACK_TEXT,
FT_MEMORY_BINARY,
FT_MEMORY_TEXT
};
class IThreadPool;
class CBlockingFileItemList;
class KeyValues;
class CCompiledKeyValuesReader;
class CBaseFileSystem;
class CPackFileHandle;
class CPackFile;
class IFileList;
class CFileOpenInfo;
class CFileAsyncReadJob;
//-----------------------------------------------------------------------------
class CFileHandle
{
public:
CFileHandle( CBaseFileSystem* fs );
virtual ~CFileHandle();
void Init( CBaseFileSystem* fs );
int GetSectorSize();
bool IsOK();
void Flush();
void SetBufferSize( int nBytes );
int Read( void* pBuffer, int nLength );
int Read( void* pBuffer, int nDestSize, int nLength );
int Write( const void* pBuffer, int nLength );
int Seek( int64 nOffset, int nWhence );
int Tell();
int Size();
int64 AbsoluteBaseOffset();
bool EndOfFile();
#if !defined( _RETAIL )
char *m_pszTrueFileName;
char const *Name() const { return m_pszTrueFileName ? m_pszTrueFileName : ""; }
void SetName( char const *pName )
{
Assert( pName );
Assert( !m_pszTrueFileName );
int len = Q_strlen( pName );
m_pszTrueFileName = new char[len + 1];
memcpy( m_pszTrueFileName, pName, len + 1 );
}
#endif
CPackFileHandle *m_pPackFileHandle;
#if defined( SUPPORT_PACKED_STORE )
CPackedStoreFileHandle m_VPKHandle;
#endif
int64 m_nLength;
FileType_t m_type;
FILE *m_pFile;
protected:
CBaseFileSystem *m_fs;
enum
{
MAGIC = 0x43464861, // 'CFHa',
FREE_MAGIC = 0x4672654d // 'FreM'
};
unsigned int m_nMagic;
bool IsValid();
};
class CMemoryFileHandle : public CFileHandle
{
public:
CMemoryFileHandle( CBaseFileSystem* pFS, CMemoryFileBacking* pBacking )
: CFileHandle( pFS ), m_pBacking( pBacking ), m_nPosition( 0 ) { m_nLength = pBacking->m_nLength; }
~CMemoryFileHandle() { m_pBacking->Release(); }
int Read( void* pBuffer, int nDestSize, int nLength );
int Seek( int64 nOffset, int nWhence );
int Tell() { return m_nPosition; }
int Size() { return (int) m_nLength; }
CMemoryFileBacking *m_pBacking;
int m_nPosition;
private:
CMemoryFileHandle( const CMemoryFileHandle& ); // not defined
CMemoryFileHandle& operator=( const CMemoryFileHandle& ); // not defined
};
//-----------------------------------------------------------------------------
#ifdef AsyncRead
#undef AsyncRead
#undef AsyncReadMutiple
#endif
#ifdef SUPPORT_PACKED_STORE
class CPackedStoreRefCount : public CPackedStore, public CRefCounted<CRefCountServiceMT>
{
public:
CPackedStoreRefCount( char const *pFileBasename, char *pszFName, IBaseFileSystem *pFS );
bool m_bSignatureValid;
};
#else
class CPackedStoreRefCount : public CRefCounted<CRefCountServiceMT>
{
};
#endif
//-----------------------------------------------------------------------------
abstract_class CBaseFileSystem : public CTier1AppSystem< IFileSystem >
{
friend class CPackFileHandle;
friend class CZipPackFileHandle;
friend class CPackFile;
friend class CZipPackFile;
friend class CFileHandle;
friend class CFileTracker;
friend class CFileTracker2;
friend class CFileOpenInfo;
typedef CTier1AppSystem< IFileSystem > BaseClass;
public:
CBaseFileSystem();
~CBaseFileSystem();
// Methods of IAppSystem
virtual void *QueryInterface( const char *pInterfaceName );
virtual InitReturnVal_t Init();
virtual void Shutdown();
void InitAsync();
void ShutdownAsync();
void ParsePathID( const char* &pFilename, const char* &pPathID, char tempPathID[MAX_PATH] );
// file handling
virtual FileHandle_t Open( const char *pFileName, const char *pOptions, const char *pathID );
virtual FileHandle_t OpenEx( const char *pFileName, const char *pOptions, unsigned flags = 0, const char *pathID = 0, char **ppszResolvedFilename = NULL );
virtual void Close( FileHandle_t );
virtual void Seek( FileHandle_t file, int pos, FileSystemSeek_t method );
virtual unsigned int Tell( FileHandle_t file );
virtual unsigned int Size( FileHandle_t file );
virtual unsigned int Size( const char *pFileName, const char *pPathID );
virtual void SetBufferSize( FileHandle_t file, unsigned nBytes );
virtual bool IsOk( FileHandle_t file );
virtual void Flush( FileHandle_t file );
virtual bool Precache( const char *pFileName, const char *pPathID );
virtual bool EndOfFile( FileHandle_t file );
virtual int Read( void *pOutput, int size, FileHandle_t file );
virtual int ReadEx( void* pOutput, int sizeDest, int size, FileHandle_t file );
virtual int Write( void const* pInput, int size, FileHandle_t file );
virtual char *ReadLine( char *pOutput, int maxChars, FileHandle_t file );
virtual int FPrintf( FileHandle_t file, PRINTF_FORMAT_STRING const char *pFormat, ... ) FMTFUNCTION( 3, 4 );
// Reads/writes files to utlbuffers
virtual bool ReadFile( const char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes, int nStartingByte, FSAllocFunc_t pfnAlloc = NULL );
virtual bool WriteFile( const char *pFileName, const char *pPath, CUtlBuffer &buf );
virtual bool UnzipFile( const char *pFileName, const char *pPath, const char *pDestination );
virtual int ReadFileEx( const char *pFileName, const char *pPath, void **ppBuf, bool bNullTerminate, bool bOptimalAlloc, int nMaxBytes = 0, int nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL );
virtual bool ReadToBuffer( FileHandle_t hFile, CUtlBuffer &buf, int nMaxBytes = 0, FSAllocFunc_t pfnAlloc = NULL );
// Optimal buffer
bool GetOptimalIOConstraints( FileHandle_t hFile, unsigned *pOffsetAlign, unsigned *pSizeAlign, unsigned *pBufferAlign );
void *AllocOptimalReadBuffer( FileHandle_t hFile, unsigned nSize, unsigned nOffset ) { return malloc( nSize ); }
void FreeOptimalReadBuffer( void *p ) { free( p ); }
// Gets the current working directory
virtual bool GetCurrentDirectory( char* pDirectory, int maxlen );
// this isn't implementable on STEAM as is.
virtual void CreateDirHierarchy( const char *path, const char *pathID );
// returns true if the file is a directory
virtual bool IsDirectory( const char *pFileName, const char *pathID );
// path info
virtual const char *GetLocalPath( const char *pFileName, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars );
virtual bool FullPathToRelativePath( const char *pFullpath, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars );
virtual bool GetCaseCorrectFullPath_Ptr( const char *pFullPath, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars );
// removes a file from disk
virtual void RemoveFile( char const* pRelativePath, const char *pathID );
// Remove all search paths (including write path?)
virtual void RemoveAllSearchPaths( void );
// Purpose: Removes all search paths for a given pathID, such as all "GAME" paths.
virtual void RemoveSearchPaths( const char *pathID );
// STUFF FROM IFileSystem
// Add paths in priority order (mod dir, game dir, ....)
// Can also add pak files (errr, NOT YET!)
virtual void AddSearchPath( const char *pPath, const char *pathID, SearchPathAdd_t addType );
virtual bool RemoveSearchPath( const char *pPath, const char *pathID );
virtual void PrintSearchPaths( void );
virtual void MarkPathIDByRequestOnly( const char *pPathID, bool bRequestOnly );
virtual bool FileExists( const char *pFileName, const char *pPathID = NULL );
virtual long GetFileTime( const char *pFileName, const char *pPathID = NULL );
virtual bool IsFileWritable( char const *pFileName, const char *pPathID = NULL );
virtual bool SetFileWritable( char const *pFileName, bool writable, const char *pPathID = 0 );
virtual void FileTimeToString( char *pString, int maxChars, long fileTime );
virtual const char *FindFirst( const char *pWildCard, FileFindHandle_t *pHandle );
virtual const char *FindFirstEx( const char *pWildCard, const char *pPathID, FileFindHandle_t *pHandle );
virtual const char *FindNext( FileFindHandle_t handle );
virtual bool FindIsDirectory( FileFindHandle_t handle );
virtual void FindClose( FileFindHandle_t handle );
virtual void PrintOpenedFiles( void );
virtual void SetWarningFunc( void (*pfnWarning)( PRINTF_FORMAT_STRING const char *fmt, ... ) );
virtual void SetWarningLevel( FileWarningLevel_t level );
virtual void AddLoggingFunc( FileSystemLoggingFunc_t logFunc );
virtual void RemoveLoggingFunc( FileSystemLoggingFunc_t logFunc );
virtual bool RenameFile( char const *pOldPath, char const *pNewPath, const char *pathID );
virtual void GetLocalCopy( const char *pFileName );
virtual bool FixUpPath( const char *pFileName, char *pFixedUpFileName, int sizeFixedUpFileName );
virtual FileNameHandle_t FindOrAddFileName( char const *pFileName );
virtual FileNameHandle_t FindFileName( char const *pFileName );
virtual bool String( const FileNameHandle_t& handle, char *buf, int buflen );
virtual int GetPathIndex( const FileNameHandle_t &handle );
long GetPathTime( const char *pFileName, const char *pPathID );
virtual void EnableWhitelistFileTracking( bool bEnable, bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes );
virtual void RegisterFileWhitelist( IPureServerWhitelist *pWhiteList, IFileList **ppFilesToReload ) OVERRIDE;
virtual void MarkAllCRCsUnverified();
virtual void CacheFileCRCs( const char *pPathname, ECacheCRCType eType, IFileList *pFilter );
//void CacheFileCRCs_R( const char *pPathname, ECacheCRCType eType, IFileList *pFilter, CUtlDict<int,int> &searchPathNames );
virtual EFileCRCStatus CheckCachedFileHash( const char *pPathID, const char *pRelativeFilename, int nFileFraction, FileHash_t *pFileHash );
virtual int GetUnverifiedFileHashes( CUnverifiedFileHash *pFiles, int nMaxFiles );
virtual int GetWhitelistSpewFlags();
virtual void SetWhitelistSpewFlags( int flags );
virtual void InstallDirtyDiskReportFunc( FSDirtyDiskReportFunc_t func );
// Low-level file caching
virtual FileCacheHandle_t CreateFileCache();
virtual void AddFilesToFileCache( FileCacheHandle_t cacheId, const char **ppFileNames, int nFileNames, const char *pPathID );
virtual bool IsFileCacheFileLoaded( FileCacheHandle_t cacheId, const char* pFileName );
virtual bool IsFileCacheLoaded( FileCacheHandle_t cacheId );
virtual void DestroyFileCache( FileCacheHandle_t cacheId );
virtual void CacheAllVPKFileHashes( bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes );
virtual bool CheckVPKFileHash( int PackFileID, int nPackFileNumber, int nFileFraction, MD5Value_t &md5Value );
virtual void NotifyFileUnloaded( const char *pszFilename, const char *pPathId ) OVERRIDE;
// Returns the file system statistics retreived by the implementation. Returns NULL if not supported.
virtual const FileSystemStatistics *GetFilesystemStatistics();
// Load dlls
virtual CSysModule *LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly );
virtual void UnloadModule( CSysModule *pModule );
//--------------------------------------------------------
// asynchronous file loading
//--------------------------------------------------------
virtual FSAsyncStatus_t AsyncReadMultiple( const FileAsyncRequest_t *pRequests, int nRequests, FSAsyncControl_t *pControls );
virtual FSAsyncStatus_t AsyncReadMultipleCreditAlloc( const FileAsyncRequest_t *pRequests, int nRequests, const char *pszFile, int line, FSAsyncControl_t *phControls = NULL );
virtual FSAsyncStatus_t AsyncFinish( FSAsyncControl_t hControl, bool wait );
virtual FSAsyncStatus_t AsyncGetResult( FSAsyncControl_t hControl, void **ppData, int *pSize );
virtual FSAsyncStatus_t AsyncAbort( FSAsyncControl_t hControl );
virtual FSAsyncStatus_t AsyncStatus( FSAsyncControl_t hControl );
virtual FSAsyncStatus_t AsyncSetPriority(FSAsyncControl_t hControl, int newPriority);
virtual FSAsyncStatus_t AsyncFlush();
virtual FSAsyncStatus_t AsyncAppend(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t *pControl) { return AsyncWrite( pFileName, pSrc, nSrcBytes, bFreeMemory, true, pControl); }
virtual FSAsyncStatus_t AsyncWrite(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t *pControl);
virtual FSAsyncStatus_t AsyncWriteFile(const char *pFileName, const CUtlBuffer *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t *pControl);
virtual FSAsyncStatus_t AsyncAppendFile(const char *pDestFileName, const char *pSrcFileName, FSAsyncControl_t *pControl);
virtual void AsyncFinishAll( int iToPriority = INT_MIN );
virtual void AsyncFinishAllWrites();
virtual bool AsyncSuspend();
virtual bool AsyncResume();
virtual void AsyncAddRef( FSAsyncControl_t hControl );
virtual void AsyncRelease( FSAsyncControl_t hControl );
virtual FSAsyncStatus_t AsyncBeginRead( const char *pszFile, FSAsyncFile_t *phFile );
virtual FSAsyncStatus_t AsyncEndRead( FSAsyncFile_t hFile );
virtual void AsyncAddFetcher( IAsyncFileFetch *pFetcher );
virtual void AsyncRemoveFetcher( IAsyncFileFetch *pFetcher );
//--------------------------------------------------------
// pack files
//--------------------------------------------------------
bool AddPackFile( const char *pFileName, const char *pathID );
bool AddPackFileFromPath( const char *pPath, const char *pakfile, bool bCheckForAppendedPack, const char *pathID );
// converts a partial path into a full path
// can be filtered to restrict path types and can provide info about resolved path
virtual const char *RelativePathToFullPath( const char *pFileName, const char *pPathID, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars, PathTypeFilter_t pathFilter = FILTER_NONE, PathTypeQuery_t *pPathType = NULL );
// Returns the search path, each path is separated by ;s. Returns the length of the string returned
virtual int GetSearchPath( const char *pathID, bool bGetPackFiles, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars );
#if defined( TRACK_BLOCKING_IO )
virtual void EnableBlockingFileAccessTracking( bool state );
virtual bool IsBlockingFileAccessEnabled() const;
virtual IBlockingFileItemList *RetrieveBlockingFileAccessInfo();
virtual void RecordBlockingFileAccess( bool synchronous, const FileBlockingItem& item );
virtual bool SetAllowSynchronousLogging( bool state );
#endif
virtual bool GetFileTypeForFullPath( char const *pFullPath, wchar_t *buf, size_t bufSizeInBytes );
virtual void BeginMapAccess();
virtual void EndMapAccess();
virtual bool FullPathToRelativePathEx( const char *pFullpath, const char *pPathId, OUT_Z_CAP(maxLenInChars) char *pDest, int maxLenInChars );
FSAsyncStatus_t SyncRead( const FileAsyncRequest_t &request );
FSAsyncStatus_t SyncWrite(const char *pszFilename, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend );
FSAsyncStatus_t SyncAppendFile(const char *pAppendToFileName, const char *pAppendFromFileName );
FSAsyncStatus_t SyncGetFileSize( const FileAsyncRequest_t &request );
void DoAsyncCallback( const FileAsyncRequest_t &request, void *pData, int nBytesRead, FSAsyncStatus_t result );
void SetupPreloadData();
void DiscardPreloadData();
virtual void LoadCompiledKeyValues( KeyValuesPreloadType_t type, char const *archiveFile );
// 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
virtual KeyValues *LoadKeyValues( KeyValuesPreloadType_t type, char const *filename, char const *pPathID = 0 );
virtual bool LoadKeyValues( KeyValues& head, KeyValuesPreloadType_t type, char const *filename, char const *pPathID = 0 );
virtual bool ExtractRootKeyName( KeyValuesPreloadType_t type, char *outbuf, size_t bufsize, char const *filename, char const *pPathID = 0 );
virtual DVDMode_t GetDVDMode() { return m_DVDMode; }
FSDirtyDiskReportFunc_t GetDirtyDiskReportFunc() { return m_DirtyDiskReportFunc; }
//-----------------------------------------------------------------------------
// MemoryFile cache implementation
//-----------------------------------------------------------------------------
class CFileCacheObject;
// XXX For now, we assume that all path IDs are "GAME", never cache files
// outside of the game search path, and preferentially return those files
// whenever anyone searches for a match even if an on-disk file in another
// folder would have been found first in a traditional search. extending
// the memory cache to cover non-game files isn't necessary right now, but
// should just be a matter of defining a more complex key type. (henryg)
// Register a CMemoryFileBacking; must balance with UnregisterMemoryFile.
// Returns false and outputs an ref-bumped pointer to the existing entry
// if the same file has already been registered by someone else; this must
// be Unregistered to maintain the balance.
virtual bool RegisterMemoryFile( CMemoryFileBacking *pFile, CMemoryFileBacking **ppExistingFileWithRef );
// Unregister a CMemoryFileBacking; must balance with RegisterMemoryFile.
virtual void UnregisterMemoryFile( CMemoryFileBacking *pFile );
//------------------------------------
// Synchronous path for file operations
//------------------------------------
class CPathIDInfo
{
public:
const CUtlSymbol& GetPathID() const;
const char* GetPathIDString() const;
void SetPathID( CUtlSymbol id );
public:
// See MarkPathIDByRequestOnly.
bool m_bByRequestOnly;
private:
CUtlSymbol m_PathID;
const char *m_pDebugPathID;
};
////////////////////////////////////////////////
// IMPLEMENTATION DETAILS FOR CBaseFileSystem //
////////////////////////////////////////////////
class CSearchPath
{
public:
CSearchPath( void );
~CSearchPath( void );
const char* GetPathString() const;
const char* GetDebugString() const;
// Path ID ("game", "mod", "gamebin") accessors.
const CUtlSymbol& GetPathID() const;
const char* GetPathIDString() const;
// Search path (c:\hl2\hl2) accessors.
void SetPath( CUtlSymbol id );
const CUtlSymbol& GetPath() const;
void SetPackFile(CPackFile *pPackFile) { m_pPackFile = pPackFile; }
CPackFile *GetPackFile() const { return m_pPackFile; }
#ifdef SUPPORT_PACKED_STORE
void SetPackedStore( CPackedStoreRefCount *pPackedStore ) { m_pPackedStore = pPackedStore; }
#endif
CPackedStoreRefCount *GetPackedStore() const { return m_pPackedStore; }
bool IsMapPath() const;
int m_storeId;
// Used to track if its search
CPathIDInfo *m_pPathIDInfo;
bool m_bIsRemotePath;
bool m_bIsTrustedForPureServer;
private:
CUtlSymbol m_Path;
const char *m_pDebugPath;
CPackFile *m_pPackFile;
CPackedStoreRefCount *m_pPackedStore;
};
class CSearchPathsVisits
{
public:
void Reset()
{
m_Visits.RemoveAll();
}
bool MarkVisit( const CSearchPath &searchPath )
{
if ( m_Visits.Find( searchPath.m_storeId ) == m_Visits.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
m_Visits.AddToTail( searchPath.m_storeId );
return false;
}
return true;
}
private:
CUtlVector<int> m_Visits; // This is a copy of IDs for the search paths we've visited, so
};
class CSearchPathsIterator
{
public:
CSearchPathsIterator( CBaseFileSystem *pFileSystem, const char **ppszFilename, const char *pszPathID, PathTypeFilter_t pathTypeFilter = FILTER_NONE )
: m_iCurrent( -1 ),
m_PathTypeFilter( pathTypeFilter )
{
char tempPathID[MAX_PATH];
if ( *ppszFilename && (*ppszFilename)[0] == '/' && (*ppszFilename)[1] == '/' ) // ONLY '//' (and not '\\') for our special format
{
// Allow for UNC-type syntax to specify the path ID.
pFileSystem->ParsePathID( *ppszFilename, pszPathID, tempPathID );
}
if ( pszPathID )
{
m_pathID = g_PathIDTable.AddString( pszPathID );
}
else
{
m_pathID = UTL_INVAL_SYMBOL;
}
if ( *ppszFilename && !Q_IsAbsolutePath( *ppszFilename ) )
{
// Copy paths to minimize mutex lock time
pFileSystem->m_SearchPathsMutex.Lock();
CopySearchPaths( pFileSystem->m_SearchPaths );
pFileSystem->m_SearchPathsMutex.Unlock();
pFileSystem->FixUpPath ( *ppszFilename, m_Filename, sizeof( m_Filename ) );
}
else
{
// If it's an absolute path, it isn't worth using the paths at all. Simplify
// client logic by pretending there's a search path of 1
m_EmptyPathIDInfo.m_bByRequestOnly = false;
m_EmptySearchPath.m_pPathIDInfo = &m_EmptyPathIDInfo;
m_EmptySearchPath.SetPath( m_pathID );
m_EmptySearchPath.m_storeId = -1;
m_Filename[0] = '\0';
}
}
CSearchPathsIterator( CBaseFileSystem *pFileSystem, const char *pszPathID, PathTypeFilter_t pathTypeFilter = FILTER_NONE )
: m_iCurrent( -1 ),
m_PathTypeFilter( pathTypeFilter )
{
if ( pszPathID )
{
m_pathID = g_PathIDTable.AddString( pszPathID );
}
else
{
m_pathID = UTL_INVAL_SYMBOL;
}
// Copy paths to minimize mutex lock time
pFileSystem->m_SearchPathsMutex.Lock();
CopySearchPaths( pFileSystem->m_SearchPaths );
pFileSystem->m_SearchPathsMutex.Unlock();
m_Filename[0] = '\0';
}
CSearchPath *GetFirst();
CSearchPath *GetNext();
private:
CSearchPathsIterator( const CSearchPathsIterator & );
void operator=(const CSearchPathsIterator &);
void CopySearchPaths( const CUtlVector<CSearchPath> &searchPaths );
int m_iCurrent;
CUtlSymbol m_pathID;
CUtlVector<CSearchPath> m_SearchPaths;
CSearchPathsVisits m_visits;
CSearchPath m_EmptySearchPath;
CPathIDInfo m_EmptyPathIDInfo;
PathTypeFilter_t m_PathTypeFilter;
char m_Filename[MAX_PATH]; // set for relative names only
};
friend class CSearchPathsIterator;
struct FindData_t
{
WIN32_FIND_DATA findData;
int currentSearchPathID;
CUtlVector<char> wildCardString;
HANDLE findHandle;
CSearchPathsVisits m_VisitedSearchPaths; // This is a copy of IDs for the search paths we've visited, so avoids searching duplicate paths.
int m_CurrentStoreID; // CSearchPath::m_storeId of the current search path.
CUtlSymbol m_FilterPathID; // What path ID are we looking at? Ignore all others. (Only set by FindFirstEx).
CUtlDict<int,int> m_VisitedFiles; // We go through the search paths in priority order, and we use this to make sure
// that we don't return the same file more than once.
CUtlStringList m_fileMatchesFromVPKOrPak;
CUtlStringList m_dirMatchesFromVPKOrPak;
};
friend class CSearchPath;
IPureServerWhitelist *m_pPureServerWhitelist;
int m_WhitelistSpewFlags; // Combination of WHITELIST_SPEW_ flags.
// logging functions
CUtlVector< FileSystemLoggingFunc_t > m_LogFuncs;
CThreadMutex m_SearchPathsMutex;
CUtlVector< CSearchPath > m_SearchPaths;
CUtlVector<CPathIDInfo*> m_PathIDInfos;
CUtlLinkedList<FindData_t> m_FindData;
CSearchPath *FindSearchPathByStoreId( int storeId );
int m_iMapLoad;
// Global list of pack file handles
CUtlVector<CPackFile *> m_ZipFiles;
FILE *m_pLogFile;
bool m_bOutputDebugString;
IThreadPool * m_pThreadPool;
CThreadFastMutex m_AsyncCallbackMutex;
// Statistics:
FileSystemStatistics m_Stats;
#if defined( TRACK_BLOCKING_IO )
CBlockingFileItemList *m_pBlockingItems;
bool m_bBlockingFileAccessReportingEnabled;
bool m_bAllowSynchronousLogging;
friend class CBlockingFileItemList;
friend class CAutoBlockReporter;
#endif
CFileTracker2 m_FileTracker2;
protected:
//----------------------------------------------------------------------------
// Purpose: Functions implementing basic file system behavior.
//----------------------------------------------------------------------------
virtual FILE *FS_fopen( const char *filename, const char *options, unsigned flags, int64 *size ) = 0;
virtual void FS_setbufsize( FILE *fp, unsigned nBytes ) = 0;
virtual void FS_fclose( FILE *fp ) = 0;
virtual void FS_fseek( FILE *fp, int64 pos, int seekType ) = 0;
virtual long FS_ftell( FILE *fp ) = 0;
virtual int FS_feof( FILE *fp ) = 0;
size_t FS_fread( void *dest, size_t size, FILE *fp ) { return FS_fread( dest, (size_t)-1, size, fp ); }
virtual size_t FS_fread( void *dest, size_t destSize, size_t size, FILE *fp ) = 0;
virtual size_t FS_fwrite( const void *src, size_t size, FILE *fp ) = 0;
virtual bool FS_setmode( FILE *fp, FileMode_t mode ) { return false; }
virtual size_t FS_vfprintf( FILE *fp, const char *fmt, va_list list ) = 0;
virtual int FS_ferror( FILE *fp ) = 0;
virtual int FS_fflush( FILE *fp ) = 0;
virtual char *FS_fgets( char *dest, int destSize, FILE *fp ) = 0;
virtual int FS_stat( const char *path, struct _stat *buf, bool *pbLoadedFromSteamCache=NULL ) = 0;
virtual int FS_chmod( const char *path, int pmode ) = 0;
virtual HANDLE FS_FindFirstFile( const char *findname, WIN32_FIND_DATA *dat) = 0;
virtual bool FS_FindNextFile(HANDLE handle, WIN32_FIND_DATA *dat) = 0;
virtual bool FS_FindClose(HANDLE handle) = 0;
virtual int FS_GetSectorSize( FILE * ) { return 1; }
#if defined( TRACK_BLOCKING_IO )
void BlockingFileAccess_EnterCriticalSection();
void BlockingFileAccess_LeaveCriticalSection();
CThreadMutex m_BlockingFileMutex;
#endif
void GetFileNameForHandle( FileHandle_t handle, char *buf, size_t buflen );
protected:
//-----------------------------------------------------------------------------
// Purpose: For tracking unclosed files
// NOTE: The symbol table could take up memory that we don't want to eat here.
// In that case, we shouldn't store them in a table, or we should store them as locally allocates stings
// so we can control the size
//-----------------------------------------------------------------------------
class COpenedFile
{
public:
COpenedFile( void );
~COpenedFile( void );
COpenedFile( const COpenedFile& src );
bool operator==( const COpenedFile& src ) const;
void SetName( char const *name );
char const *GetName( void );
FILE *m_pFile;
char *m_pName;
};
CThreadFastMutex m_MemoryFileMutex;
CUtlHashtable< const char*, CMemoryFileBacking* > m_MemoryFileHash;
//CUtlRBTree< COpenedFile, int > m_OpenedFiles;
CThreadMutex m_OpenedFilesMutex;
CUtlVector <COpenedFile> m_OpenedFiles;
static bool OpenedFileLessFunc( COpenedFile const& src1, COpenedFile const& src2 );
FileWarningLevel_t m_fwLevel;
void (*m_pfnWarning)( PRINTF_FORMAT_STRING const char *fmt, ... );
FILE *Trace_FOpen( const char *filename, const char *options, unsigned flags, int64 *size );
void Trace_FClose( FILE *fp );
void Trace_FRead( int size, FILE* file );
void Trace_FWrite( int size, FILE* file );
void Trace_DumpUnclosedFiles( void );
public:
void LogAccessToFile( char const *accesstype, char const *fullpath, char const *options );
void Warning( FileWarningLevel_t level, PRINTF_FORMAT_STRING const char *fmt, ... );
protected:
// Note: if pFoundStoreID is passed in, then it will set that to the CSearchPath::m_storeId value of the search path it found the file in.
const char* FindFirstHelper( const char *pWildCard, const char *pPathID, FileFindHandle_t *pHandle, int *pFoundStoreID );
bool FindNextFileHelper( FindData_t *pFindData, int *pFoundStoreID );
bool FindNextFileInVPKOrPakHelper( FindData_t *pFindData );
void RemoveAllMapSearchPaths( void );
void AddMapPackFile( const char *pPath, const char *pPathID, SearchPathAdd_t addType );
void AddPackFiles( const char *pPath, const CUtlSymbol &pathID, SearchPathAdd_t addType );
bool PreparePackFile( CPackFile &packfile, int offsetofpackinmetafile, int64 filelen );
void AddVPKFile( const char *pPath, const char *pPathID, SearchPathAdd_t addType );
bool RemoveVPKFile( const char *pPath, const char *pPathID );
void HandleOpenRegularFile( CFileOpenInfo &openInfo, bool bIsAbsolutePath );
FileHandle_t FindFileInSearchPath( CFileOpenInfo &openInfo );
long FastFileTime( const CSearchPath *path, const char *pFileName );
const char *GetWritePath( const char *pFilename, const char *pathID );
// Computes a full write path
void ComputeFullWritePath( char* pDest, int maxlen, const char *pWritePathID, char const *pRelativePath );
void AddSearchPathInternal( const char *pPath, const char *pathID, SearchPathAdd_t addType, bool bAddPackFiles );
// Opens a file for read or write
FileHandle_t OpenForRead( const char *pFileName, const char *pOptions, unsigned flags, const char *pathID, char **ppszResolvedFilename = NULL );
FileHandle_t OpenForWrite( const char *pFileName, const char *pOptions, const char *pathID );
CSearchPath *FindWritePath( const char *pFilename, const char *pathID );
// Helper function for fs_log file logging
void LogFileAccess( const char *pFullFileName );
bool LookupKeyValuesRootKeyName( char const *filename, char const *pPathID, char *rootName, size_t bufsize );
void UnloadCompiledKeyValues();
// If bByRequestOnly is -1, then it will default to false if it doesn't already exist, and it
// won't change it if it does already exist. Otherwise, it will be set to the value of bByRequestOnly.
CPathIDInfo* FindOrAddPathIDInfo( const CUtlSymbol &id, int bByRequestOnly );
static bool FilterByPathID( const CSearchPath *pSearchPath, const CUtlSymbol &pathID );
// Global/shared filename/path table
CUtlFilenameSymbolTable m_FileNames;
int m_WhitelistFileTrackingEnabled; // -1 if unset, 0 if disabled (single player), 1 if enabled (multiplayer).
FSDirtyDiskReportFunc_t m_DirtyDiskReportFunc;
void SetSearchPathIsTrustedSource( CSearchPath *pPath );
struct CompiledKeyValuesPreloaders_t
{
CompiledKeyValuesPreloaders_t() :
m_CacheFile( 0 ),
m_pReader( 0 )
{
}
FileNameHandle_t m_CacheFile;
CCompiledKeyValuesReader *m_pReader;
};
CompiledKeyValuesPreloaders_t m_PreloadData[ NUM_PRELOAD_TYPES ];
static CUtlSymbol m_GamePathID;
static CUtlSymbol m_BSPPathID;
static DVDMode_t m_DVDMode;
// Pack exclude paths are strictly for 360 to allow holes in search paths and pack files
// which fall through to support new or dynamic data on the host pc.
static CUtlVector< FileNameHandle_t > m_ExcludePaths;
/// List of installed hooks to intercept async file operations
CUtlVector< IAsyncFileFetch * > m_vecAsyncFetchers;
/// List of active async jobs being serviced by customer fetchers
CUtlVector< CFileAsyncReadJob * > m_vecAsyncCustomFetchJobs;
/// Remove a custom fetch job from the list (and release our reference)
friend class CFileAsyncReadJob;
void RemoveAsyncCustomFetchJob( CFileAsyncReadJob *pJob );
};
inline const CUtlSymbol& CBaseFileSystem::CPathIDInfo::GetPathID() const
{
return m_PathID;
}
inline const char* CBaseFileSystem::CPathIDInfo::GetPathIDString() const
{
return g_PathIDTable.String( m_PathID );
}
inline const char* CBaseFileSystem::CSearchPath::GetPathString() const
{
return g_PathIDTable.String( m_Path );
}
inline void CBaseFileSystem::CPathIDInfo::SetPathID( CUtlSymbol sym )
{
m_PathID = sym;
m_pDebugPathID = GetPathIDString();
}
inline const CUtlSymbol& CBaseFileSystem::CSearchPath::GetPathID() const
{
return m_pPathIDInfo->GetPathID();
}
inline const char* CBaseFileSystem::CSearchPath::GetPathIDString() const
{
return m_pPathIDInfo->GetPathIDString();
}
inline void CBaseFileSystem::CSearchPath::SetPath( CUtlSymbol id )
{
m_Path = id;
m_pDebugPath = g_PathIDTable.String( m_Path );
}
inline const CUtlSymbol& CBaseFileSystem::CSearchPath::GetPath() const
{
return m_Path;
}
inline bool CBaseFileSystem::FilterByPathID( const CSearchPath *pSearchPath, const CUtlSymbol &pathID )
{
if ( (UtlSymId_t)pathID == UTL_INVAL_SYMBOL )
{
// They didn't specify a specific search path, so if this search path's path ID is by
// request only, then ignore it.
return pSearchPath->m_pPathIDInfo->m_bByRequestOnly;
}
else
{
// Bit of a hack, but specifying "BSP" as the search path will search in "GAME" for only the map/.bsp pack file path
if ( pathID == m_BSPPathID )
{
if ( pSearchPath->GetPathID() != m_GamePathID )
return true;
if ( !pSearchPath->GetPackFile() )
return true;
if ( !pSearchPath->IsMapPath() )
return true;
return false;
}
else
{
return (pSearchPath->GetPathID() != pathID);
}
}
}
#if defined( TRACK_BLOCKING_IO )
class CAutoBlockReporter
{
public:
CAutoBlockReporter( CBaseFileSystem *fs, bool synchronous, char const *filename, int eBlockType, int nTypeOfAccess ) :
m_pFS( fs ),
m_Item( eBlockType, filename, 0.0f, nTypeOfAccess ),
m_bSynchronous( synchronous )
{
Assert( m_pFS );
m_Timer.Start();
}
CAutoBlockReporter( CBaseFileSystem *fs, bool synchronous, FileHandle_t handle, int eBlockType, int nTypeOfAccess ) :
m_pFS( fs ),
m_Item( eBlockType, NULL, 0.0f, nTypeOfAccess ),
m_bSynchronous( synchronous )
{
Assert( m_pFS );
char name[ 512 ];
m_pFS->GetFileNameForHandle( handle, name, sizeof( name ) );
m_Item.SetFileName( name );
m_Timer.Start();
}
~CAutoBlockReporter()
{
m_Timer.End();
m_Item.m_flElapsed = m_Timer.GetDuration().GetSeconds();
m_pFS->RecordBlockingFileAccess( m_bSynchronous, m_Item );
}
private:
CBaseFileSystem *m_pFS;
CFastTimer m_Timer;
FileBlockingItem m_Item;
bool m_bSynchronous;
};
#define AUTOBLOCKREPORTER_FN( name, fs, sync, filename, blockType, accessType ) CAutoBlockReporter block##name( fs, sync, filename, blockType, accessType );
#define AUTOBLOCKREPORTER_FH( name, fs, sync, handle, blockType, accessType ) CAutoBlockReporter block##name( fs, sync, handle, blockType, accessType );
#else
#define AUTOBLOCKREPORTER_FN( name, fs, sync, filename, blockType, accessType ) // Nothing
#define AUTOBLOCKREPORTER_FH( name, fs, sync, handle , blockType, accessType ) // Nothing
#endif
// singleton accessor
CBaseFileSystem *BaseFileSystem();
#include "tier0/memdbgoff.h"
#endif // BASEFILESYSTEM_H