diff options
Diffstat (limited to 'filesystem/basefilesystem.h')
| -rw-r--r-- | filesystem/basefilesystem.h | 1001 |
1 files changed, 1001 insertions, 0 deletions
diff --git a/filesystem/basefilesystem.h b/filesystem/basefilesystem.h new file mode 100644 index 0000000..e413db7 --- /dev/null +++ b/filesystem/basefilesystem.h @@ -0,0 +1,1001 @@ +//========= 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 |