diff --git a/game/shared/entitylist_base.h b/game/shared/entitylist_base.h index e2fb56a8..fc3058da 100644 --- a/game/shared/entitylist_base.h +++ b/game/shared/entitylist_base.h @@ -24,6 +24,8 @@ public: int m_SerialNumber; CEntInfo *m_pPrev; CEntInfo *m_pNext; + string_t m_iName; + string_t m_iClassName; void ClearLinks(); }; diff --git a/game/shared/takedamageinfo.cpp b/game/shared/takedamageinfo.cpp index 3b21c1ba..208687e0 100644 --- a/game/shared/takedamageinfo.cpp +++ b/game/shared/takedamageinfo.cpp @@ -29,6 +29,7 @@ BEGIN_SIMPLE_DATADESC( CTakeDamageInfo ) DEFINE_FIELD( m_iDamageStats, FIELD_INTEGER), DEFINE_FIELD( m_iAmmoType, FIELD_INTEGER), DEFINE_FIELD( m_flRadius, FIELD_FLOAT), + DEFINE_FIELD( m_iDamagedOtherPlayers, FIELD_INTEGER), END_DATADESC() void CTakeDamageInfo::Init( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, const Vector &damageForce, const Vector &damagePosition, const Vector &reportedPosition, float flDamage, int bitsDamageType, int iCustomDamage ) diff --git a/game/shared/takedamageinfo.h b/game/shared/takedamageinfo.h index e9eb6cf9..ede4396e 100644 --- a/game/shared/takedamageinfo.h +++ b/game/shared/takedamageinfo.h @@ -116,6 +116,12 @@ protected: int m_iDamageStats; int m_iAmmoType; // AmmoType of the weapon used to cause this damage, if any float m_flRadius; + + // CS:GO + int m_iDamagedOtherPlayers; + int m_iObjectsPenetrated; + uint32 m_uiBulletID; + uint8 m_uiRecoilIndex; DECLARE_SIMPLE_DATADESC(); }; diff --git a/game/shared/usercmd.h b/game/shared/usercmd.h index 6927417e..b17f6164 100644 --- a/game/shared/usercmd.h +++ b/game/shared/usercmd.h @@ -179,6 +179,9 @@ public: // Player instantaneous view angles. QAngle viewangles; + + Vector aimdirection; + // Intended velocities // forward velocity. float forwardmove; @@ -224,6 +227,10 @@ public: Vector skill_dest; short skill_dest_ent; #endif + + QAngle freeaimangles; + QAngle muzzleangles; + Vector muzzleposition; }; void ReadUsercmd( bf_read *buf, CUserCmd *move, CUserCmd *from ); diff --git a/public/cdll_int.h b/public/cdll_int.h index 60654f73..bb3edf5a 100644 --- a/public/cdll_int.h +++ b/public/cdll_int.h @@ -98,8 +98,6 @@ typedef struct player_info_s bool fakeplayer; // true if player is the HLTV proxy bool ishltv; - // true if player is the Replay proxy - bool isreplay; // custom files CRC for this player CRC32_t customFiles[MAX_CUSTOM_FILES]; // this counter increases each time the server downloaded a new file diff --git a/public/dt_send.h b/public/dt_send.h index 05ca24b7..4f7824d2 100644 --- a/public/dt_send.h +++ b/public/dt_send.h @@ -277,7 +277,7 @@ private: inline int SendProp::GetOffset() const { - return m_Offset; + return m_Offset & 0xFFFFF; } inline void SendProp::SetOffset( int i ) diff --git a/public/edict.h b/public/edict.h index 61376747..c2d14b1e 100644 --- a/public/edict.h +++ b/public/edict.h @@ -49,6 +49,7 @@ public: // Current map string_t mapname; + string_t mapGroupName; int mapversion; string_t startspot; MapLoadType_t eLoadType; // How the current map was loaded diff --git a/public/eiface.h b/public/eiface.h index 5cc8c0c3..576abe6f 100644 --- a/public/eiface.h +++ b/public/eiface.h @@ -16,6 +16,7 @@ #include "convar.h" #include "icvar.h" #include "edict.h" +#include "iclient.h" #include "mathlib/vplane.h" #include "iserverentity.h" #include "engine/ivmodelinfo.h" @@ -72,7 +73,7 @@ typedef struct player_info_s player_info_t; #define DLLEXPORT /* */ #endif -#define INTERFACEVERSION_VENGINESERVER "VEngineServer022" +#define INTERFACEVERSION_VENGINESERVER "VEngineServer023" struct bbox_t { @@ -352,6 +353,9 @@ public: // Cleans up the cluster list virtual void CleanUpEntityClusterList( PVSInfo_t *pPVSInfo ) = 0; + + virtual void SetAchievementMgr( IAchievementMgr * ) = 0; + virtual IAchievementMgr* GetAchievementMgr() = 0; virtual int GetAppID() = 0; @@ -404,6 +408,7 @@ public: virtual bool IsCreatingReslist() = 0; virtual bool IsCreatingXboxReslist() = 0; virtual bool IsDedicatedServerForXbox() = 0; + virtual bool IsDedicatedServerForPS3() = 0; virtual void Pause( bool bPause, bool bForce = false ) = 0; @@ -431,7 +436,7 @@ public: // Calls ShootPaintSphere virtual bool SpherePaintSurface( const model_t *pModel, const Vector &, unsigned char, float, float ) = 0; - virtual void SphereTracePaintSurface( const model_t *pModel, const Vector &, const Vector &, float, CUtlVector> & ) = 0; + virtual void SphereTracePaintSurface( const model_t *pModel, const Vector &, const Vector &, float, CUtlVector & ) = 0; virtual void RemoveAllPaint() = 0; @@ -448,13 +453,17 @@ public: virtual void SetNoClipEnabled( bool bEnabled ) = 0; - virtual void GetPaintmapDataRLE( CUtlVector> &mapdata ) = 0; - virtual void LoadPaintmapDataRLE( CUtlVector> &mapdata ) = 0; + virtual void GetPaintmapDataRLE( CUtlVector &mapdata ) = 0; + virtual void LoadPaintmapDataRLE( CUtlVector &mapdata ) = 0; virtual void SendPaintmapDataToClient( edict_t *pEdict ) = 0; virtual float GetLatencyForChoreoSounds() = 0; - virtual int GetClientCrossPlayPlatform( int client_index ) = 0; + virtual CrossPlayPlatform_t GetClientCrossPlayPlatform( int ent_num ) = 0; + + virtual void EnsureInstanceBaseline( int ent_num ) = 0; + + virtual bool ReserveServerForQueuedGame( const char *szReservationPayload ) = 0; }; #define INTERFACEVERSION_SERVERGAMEDLL "ServerGameDLL005" @@ -578,6 +587,14 @@ public: virtual void ServerHibernationUpdate( bool bHibernating ) = 0; virtual bool ShouldPreferSteamAuth() = 0; + + virtual bool ShouldAllowDirectConnect() = 0; + virtual bool FriendsReqdForDirectConnect() = 0; + virtual bool IsLoadTestServer() = 0; + virtual bool IsValveDS() = 0; + virtual KeyValues *GetExtendedServerInfoForNewClient() = 0; + virtual void UpdateGCInformation() = 0; + virtual void ReportGCQueuedMatchStart( int32 iReservationStage, uint32 *puiConfirmedAccounts, int numConfirmedAccounts ) = 0; }; //----------------------------------------------------------------------------- diff --git a/public/filesystem.h b/public/filesystem.h index 1c125bf0..02408b23 100644 --- a/public/filesystem.h +++ b/public/filesystem.h @@ -5,6 +5,19 @@ // $NoKeywords: $ //===========================================================================// +#include + +#include "tier0/threadtools.h" +#include "tier0/memalloc.h" +#include "tier1/interface.h" +#include "tier1/utlsymbol.h" +#include "tier1/utlstring.h" +#include "appframework/IAppSystem.h" +#include "tier1/checksum_crc.h" +#include "tier1/checksum_md5.h" +#include "tier1/refcount.h" +#include "tier2/tier2.h" + #ifndef FILESYSTEM_H #define FILESYSTEM_H @@ -12,20 +25,6 @@ #pragma once #endif -#include - -#include "tier0/threadtools.h" -#include "tier0/memalloc.h" -#include "tier0/tslist.h" -#include "tier1/interface.h" -#include "tier1/utlsymbol.h" -#include "tier1/utlstring.h" -//#include "tier1/functors.h" -#include "tier1/checksum_crc.h" -#include "tier1/utlqueue.h" -#include "appframework/IAppSystem.h" -#include "tier2/tier2.h" - //----------------------------------------------------------------------------- // Forward declarations //----------------------------------------------------------------------------- @@ -33,8 +32,11 @@ class CUtlBuffer; class KeyValues; class IFileList; +class IThreadPool; +class CMemoryFileBacking; typedef void * FileHandle_t; +typedef void * FileCacheHandle_t; typedef int FileFindHandle_t; typedef void (*FileSystemLoggingFunc_t)( const char *fileName, const char *accessType ); typedef int WaitForResourcesHandle_t; @@ -43,6 +45,40 @@ typedef int WaitForResourcesHandle_t; typedef void* HANDLE; #endif +#define USE_CRC_FILE_TRACKING 0 + +// Turn on some extra pure server debug spew in certain builds. +// WARNING: This spew can be used by hackers to locate places to hack +// the code to bypas sv_pure! Be careful! +#if defined( _DEBUG ) || defined( STAGING_ONLY ) + #define PURE_SERVER_DEBUG_SPEW +#endif + +/// How strict will the pure server be for a particular set of files +enum EPureServerFileClass +{ + ePureServerFileClass_Unknown = -1, // dummy debugging value + ePureServerFileClass_Any = 0, + ePureServerFileClass_AnyTrusted, + ePureServerFileClass_CheckHash, +}; + +class IPureServerWhitelist +{ +public: + + // Reference counting + virtual void AddRef() = 0; + virtual void Release() = 0; + + // What should we do with a particular file? + virtual EPureServerFileClass GetFileClass( const char *pszFilename ) = 0; + + // Access list of trusted keys which we will allow to set trusted content + virtual int GetTrustedKeyCount() const = 0; + virtual const byte *GetTrustedKey( int iKeyIndex, int *nKeySize ) const = 0; +}; + //----------------------------------------------------------------------------- // Enums used by the interface //----------------------------------------------------------------------------- @@ -103,19 +139,18 @@ enum PATH_IS_NORMAL = 0x00, // normal path, not pack based PATH_IS_PACKFILE = 0x01, // path is a pack file PATH_IS_MAPPACKFILE = 0x02, // path is a map pack file - PATH_IS_DVDDEV = 0x04, // path is the dvddev cache + PATH_IS_REMOTE = 0x04, // path is the remote filesystem }; typedef uint32 PathTypeQuery_t; #define IS_PACKFILE( n ) ( n & ( PATH_IS_PACKFILE | PATH_IS_MAPPACKFILE ) ) -#define IS_DVDDEV( n ) ( n & PATH_IS_DVDDEV ) +#define IS_REMOTE( n ) ( n & PATH_IS_REMOTE ) enum DVDMode_t { DVDMODE_OFF = 0, // not using dvd DVDMODE_STRICT = 1, // dvd device only DVDMODE_DEV = 2, // dev mode, mutiple devices ok - DVDMODE_DEV_VISTA = 3, // dev mode from a vista host, mutiple devices ok }; // In non-retail builds, enable the file blocking access tracking stuff... @@ -277,6 +312,8 @@ const FSAsyncFile_t FS_INVALID_ASYNC_FILE = (FSAsyncFile_t)(0x0000ffff); //--------------------------------------------------------- enum FSAsyncStatus_t { + FSASYNC_ERR_NOT_MINE = -8, // Filename not part of the specified file system, try a different one. (Used internally to find the right filesystem) + FSASYNC_ERR_RETRY_LATER = -7, // Failure for a reason that might be temporary. You might retry, but not immediately. (E.g. Network problems) FSASYNC_ERR_ALIGNMENT = -6, // read parameters invalid for unbuffered IO FSASYNC_ERR_FAILURE = -5, // hard subsystem failure FSASYNC_ERR_READING = -4, // read error on file @@ -307,7 +344,8 @@ enum FSAsyncFlags_t enum EFileCRCStatus { k_eFileCRCStatus_CantOpenFile, // We don't have this file. - k_eFileCRCStatus_GotCRC + k_eFileCRCStatus_GotCRC, + k_eFileCRCStatus_FileInVPK }; // Used in CacheFileCRCs. @@ -326,13 +364,6 @@ enum ECacheCRCType struct FileAsyncRequest_t; typedef void (*FSAsyncCallbackFunc_t)(const FileAsyncRequest_t &request, int nBytesRead, FSAsyncStatus_t err); -//----------------------------------------------------------------------------- -// Used to add results from async directory scans -//----------------------------------------------------------------------------- -typedef void (*FSAsyncScanAddFunc_t)( void* pContext, char* pFoundPath, char* pFoundFile ); -typedef void (*FSAsyncScanCompleteFunc_t)( void* pContext, FSAsyncStatus_t err ); - - //--------------------------------------------------------- // Description of an async request //--------------------------------------------------------- @@ -353,6 +384,52 @@ struct FileAsyncRequest_t }; +struct FileHash_t +{ + enum EFileHashType_t + { + k_EFileHashTypeUnknown = 0, + k_EFileHashTypeEntireFile = 1, + k_EFileHashTypeIncompleteFile = 2, + }; + FileHash_t() + { + m_eFileHashType = FileHash_t::k_EFileHashTypeUnknown; + m_cbFileLen = 0; + m_PackFileID = 0; + m_nPackFileNumber = 0; + } + int m_eFileHashType; + CRC32_t m_crcIOSequence; + MD5Value_t m_md5contents; + int m_cbFileLen; + int m_PackFileID; + int m_nPackFileNumber; + + bool operator==( const FileHash_t &src ) const + { + return m_crcIOSequence == src.m_crcIOSequence && + m_md5contents == src.m_md5contents && + m_eFileHashType == src.m_eFileHashType; + } + bool operator!=( const FileHash_t &src ) const + { + return m_crcIOSequence != src.m_crcIOSequence || + m_md5contents != src.m_md5contents || + m_eFileHashType != src.m_eFileHashType; + } + +}; + +class CUnverifiedFileHash +{ +public: + char m_PathID[MAX_PATH]; + char m_Filename[MAX_PATH]; + int m_nFileFraction; + FileHash_t m_FileHash; +}; + class CUnverifiedCRCFile { public: @@ -361,6 +438,13 @@ public: CRC32_t m_CRC; }; +class CUnverifiedMD5File +{ +public: + char m_PathID[MAX_PATH]; + char m_Filename[MAX_PATH]; + unsigned char bits[MD5_DIGEST_LENGTH]; +}; // Spew flags for SetWhitelistSpewFlags (set with the fs_whitelist_spew_flags cvar). // Update the comment for the fs_whitelist_spew_flags cvar if you change these. @@ -368,22 +452,44 @@ public: #define WHITELIST_SPEW_RELOAD_FILES 0x0002 // show files the filesystem is telling the engine to reload #define WHITELIST_SPEW_DONT_RELOAD_FILES 0x0004 // show files the filesystem is NOT telling the engine to reload +//----------------------------------------------------------------------------- +// Interface to fetch a file asynchronously from any source. This is used +// as a hook +//----------------------------------------------------------------------------- +abstract_class IAsyncFileFetch { +public: + typedef void *Handle; -// DLC license mask flags is 32 publisher defined bits -// MSW 16 bits in 8.8: Type.SubVersion -// LSW 16 bits: Flags + /// Initiate a request. Returns error status, or on success + /// returns an opaque handle used to terminate the job + /// + /// Should return FSASYNC_ERR_NOT_MINE if the filename isn't + /// handled by this interface + /// + /// The callback is required, and is the only mechanism to communicate + /// status. (No polling.) The request is automatically destroyed anytime + /// after the callback is executed. + virtual FSAsyncStatus_t Start( const FileAsyncRequest_t &request, Handle *pOutHandle, IThreadPool *pThreadPool ) = 0; -// return id component -#define DLC_LICENSE_ID( x ) ( ( ( (unsigned int)( x ) ) >> 24 ) & 0x000000FF ) -// returns minor version component (not generally used, i.e. we dont rev dlc's yet) -#define DLC_LICENSE_MINORVERSION( x ) ( ( ( (unsigned int)( x ) ) >> 16 ) & 0x000000FF ) -// returns license flags -#define DLC_LICENSE_FLAGS( x ) ( ( ( (unsigned int)( x ) ) & 0x0000FFFF ) ) - -#define DLCFLAGS_PRESENCE_ONLY 0x0001 // causes no search path loadout + /// Attempt to complete any active work, returning status. The callback WILL + /// be executed (this is necessary in case we allocated the buffer). + /// Afterwards, the request is automatically destroyed. + virtual FSAsyncStatus_t FinishSynchronous( Handle hControl ) = 0; + /// Terminate any active work and destroy all resources and bookkeeping info. + /// The callback will NOT be executed. + virtual FSAsyncStatus_t Abort( Handle hControl ) = 0; +}; +// This interface is for VPK files to communicate with FileTracker +abstract_class IThreadedFileMD5Processor +{ +public: + virtual int SubmitThreadedMD5Request( uint8 *pubBuffer, int cubBuffer, int PackFileID, int nPackFileNumber, int nPackFileFraction ) = 0; + virtual bool BlockUntilMD5RequestComplete( int iRequest, MD5Value_t *pMd5ValueOut ) = 0; + virtual bool IsMD5RequestComplete( int iRequest, MD5Value_t *pMd5ValueOut ) = 0; +}; //----------------------------------------------------------------------------- // Base file system interface @@ -538,12 +644,6 @@ public: FileFindHandle_t *pHandle ) = 0; - virtual void FindFileAbsoluteList( - CUtlVector &output, - const char *pWildCard, - const char *pPathID - ) = 0; - //-------------------------------------------------------- // File name and directory operations //-------------------------------------------------------- @@ -583,6 +683,12 @@ public: virtual bool AsyncSuspend() = 0; virtual bool AsyncResume() = 0; + /// Add async fetcher interface. This gives apps a hook to intercept async requests and + /// pull the data from a source of their choosing. The immediate use case is to load + /// assets from the CDN via HTTP. + virtual void AsyncAddFetcher( IAsyncFileFetch *pFetcher ) = 0; + virtual void AsyncRemoveFetcher( IAsyncFileFetch *pFetcher ) = 0; + //------------------------------------ // Functions to hold a file open if planning on doing mutiple reads. Use is optional, // and is taken only as a hint @@ -673,10 +779,13 @@ public: NUM_PRELOAD_TYPES }; + virtual void LoadCompiledKeyValues( KeyValuesPreloadType_t type, char const *archiveFile ) = 0; + // 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 ) = 0; virtual bool LoadKeyValues( KeyValues& head, KeyValuesPreloadType_t type, char const *filename, char const *pPathID = 0 ) = 0; + virtual bool ExtractRootKeyName( KeyValuesPreloadType_t type, char *outbuf, size_t bufsize, char const *filename, char const *pPathID = 0 ) = 0; virtual FSAsyncStatus_t AsyncWrite(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend = false, FSAsyncControl_t *pControl = NULL ) = 0; virtual FSAsyncStatus_t AsyncWriteFile(const char *pFileName, const CUtlBuffer *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend = false, FSAsyncControl_t *pControl = NULL ) = 0; @@ -684,8 +793,6 @@ public: FSAsyncStatus_t AsyncReadCreditAlloc( const FileAsyncRequest_t &request, const char *pszFile, int line, FSAsyncControl_t *phControl = NULL ) { return AsyncReadMultipleCreditAlloc( &request, 1, pszFile, line, phControl ); } virtual FSAsyncStatus_t AsyncReadMultipleCreditAlloc( const FileAsyncRequest_t *pRequests, int nRequests, const char *pszFile, int line, FSAsyncControl_t *phControls = NULL ) = 0; - virtual FSAsyncStatus_t AsyncDirectoryScan( const char* pSearchSpec, bool recurseFolders, void* pContext, FSAsyncScanAddFunc_t pfnAdd, FSAsyncScanCompleteFunc_t pfnDone, FSAsyncControl_t *pControl = NULL ) = 0; - virtual bool GetFileTypeForFullPath( char const *pFullPath, wchar_t *buf, size_t bufSizeInBytes ) = 0; //-------------------------------------------------------- @@ -720,29 +827,10 @@ public: // This should be called ONCE at startup. Multiplayer games (gameinfo.txt does not contain singleplayer_only) // want to enable this so sv_pure works. - virtual void EnableWhitelistFileTracking( bool bEnable ) = 0; + virtual void EnableWhitelistFileTracking( bool bEnable, bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes ) = 0; // This is called when the client connects to a server using a pure_server_whitelist.txt file. - // - // Files listed in pWantCRCList will have CRCs calculated for them IF they come off disk - // (and those CRCs will come out of GetUnverifiedCRCFiles). - // - // Files listed in pAllowFromDiskList will be allowed to load from disk. All other files will - // be forced to come from Steam. - // - // The filesystem hangs onto the whitelists you pass in here, and it will Release() them when it closes down - // or when you call this function again. - // - // NOTE: The whitelists you pass in here will be accessed from multiple threads, so make sure the - // IsFileInList function is thread safe. - // - // If pFilesToReload is non-null, the filesystem will hand back a list of files that should be reloaded because they - // are now "dirty". For example, if you were on a non-pure server and you loaded a certain model, and then you connected - // to a pure server that said that model had to come from Steam, then pFilesToReload would specify that model - // and the engine should reload it so it can come from Steam. - // - // Be sure to call Release() on pFilesToReload. - virtual void RegisterFileWhitelist( IFileList *pWantCRCList, IFileList *pAllowFromDiskList, IFileList **pFilesToReload ) = 0; + virtual void RegisterFileWhitelist( IPureServerWhitelist *pWhiteList, IFileList **pFilesToReload ) = 0; // Called when the client logs onto a server. Any files that came off disk should be marked as // unverified because this server may have a different set of files it wants to guarantee. @@ -751,7 +839,7 @@ public: // As the server loads whitelists when it transitions maps, it calls this to calculate CRCs for any files marked // with check_crc. Then it calls CheckCachedFileCRC later when it gets client requests to verify CRCs. virtual void CacheFileCRCs( const char *pPathname, ECacheCRCType eType, IFileList *pFilter ) = 0; - virtual EFileCRCStatus CheckCachedFileCRC( const char *pPathID, const char *pRelativeFilename, CRC32_t *pCRC ) = 0; + virtual EFileCRCStatus CheckCachedFileHash( const char *pPathID, const char *pRelativeFilename, int nFileFraction, FileHash_t *pFileHash ) = 0; // Fills in the list of files that have been loaded off disk and have not been verified. // Returns the number of files filled in (between 0 and nMaxFiles). @@ -759,7 +847,7 @@ public: // This also removes any files it's returning from the unverified CRC list, so they won't be // returned from here again. // The client sends batches of these to the server to verify. - virtual int GetUnverifiedCRCFiles( CUnverifiedCRCFile *pFiles, int nMaxFiles ) = 0; + virtual int GetUnverifiedFileHashes( CUnverifiedFileHash *pFiles, int nMaxFiles ) = 0; // Control debug message output. // Pass a combination of WHITELIST_SPEW_ flags. @@ -769,37 +857,61 @@ public: // Installs a callback used to display a dirty disk dialog virtual void InstallDirtyDiskReportFunc( FSDirtyDiskReportFunc_t func ) = 0; - virtual bool IsLaunchedFromXboxHDD() = 0; - virtual bool IsInstalledToXboxHDDCache() = 0; - virtual bool IsDVDHosted() = 0; - virtual bool IsInstallAllowed() = 0; + //-------------------------------------------------------- + // Low-level file caching. Cached files are loaded into memory and used + // to satisfy read requests (sync and async) until the cache is destroyed. + // NOTE: this could defeat file whitelisting, if a file were loaded in + // a non-whitelisted environment and then reused. Clients should not cache + // files across moves between pure/non-pure environments. + //-------------------------------------------------------- + virtual FileCacheHandle_t CreateFileCache() = 0; + virtual void AddFilesToFileCache( FileCacheHandle_t cacheId, const char **ppFileNames, int nFileNames, const char *pPathID ) = 0; + virtual bool IsFileCacheFileLoaded( FileCacheHandle_t cacheId, const char* pFileName ) = 0; + virtual bool IsFileCacheLoaded( FileCacheHandle_t cacheId ) = 0; + virtual void DestroyFileCache( FileCacheHandle_t cacheId ) = 0; - virtual int GetSearchPathID( char *pPath, int nMaxLen ) = 0; - virtual bool FixupSearchPathsAfterInstall() = 0; - - virtual FSDirtyDiskReportFunc_t GetDirtyDiskReportFunc() = 0; + // 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) - virtual void AddVPKFile( char const *pszName, SearchPathAdd_t addType = PATH_ADD_TO_TAIL ) = 0; - virtual void RemoveVPKFile( char const *pszName ) = 0; - virtual void GetVPKFileNames( CUtlVector &destVector ) = 0; - virtual void RemoveAllMapSearchPaths() = 0; - virtual void SyncDvdDevCache() = 0; + // 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 ) = 0; - virtual bool GetStringFromKVPool( CRC32_t poolKey, unsigned int key, char *pOutBuff, int buflen ) = 0; + // Unregister a CMemoryFileBacking; must balance with RegisterMemoryFile. + virtual void UnregisterMemoryFile( CMemoryFileBacking *pFile ) = 0; - virtual bool DiscoverDLC( int iController ) = 0; - virtual int IsAnyDLCPresent( bool *pbDLCSearchPathMounted = NULL ) = 0; - virtual bool GetAnyDLCInfo( int iDLC, unsigned int *pLicenseMask, wchar_t *pTitleBuff, int nOutTitleSize ) = 0; - virtual int IsAnyCorruptDLC() = 0; - virtual bool GetAnyCorruptDLCInfo( int iCorruptDLC, wchar_t *pTitleBuff, int nOutTitleSize ) = 0; - virtual bool AddDLCSearchPaths() = 0; - virtual bool IsSpecificDLCPresent( unsigned int nDLCPackage ) = 0; + virtual void CacheAllVPKFileHashes( bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes ) = 0; + virtual bool CheckVPKFileHash( int PackFileID, int nPackFileNumber, int nFileFraction, MD5Value_t &md5Value ) = 0; - // call this to look for CPU-hogs during loading processes. When you set this, a breakpoint - // will be issued whenever the indicated # of seconds go by without an i/o request. Passing - // 0.0 will turn off the functionality. - virtual void SetIODelayAlarm( float flThreshhold ) = 0; + // Called when we unload a file, to remove that file's info for pure server purposes. + virtual void NotifyFileUnloaded( const char *pszFilename, const char *pPathId ) = 0; +}; +//----------------------------------------------------------------------------- +// Memory file backing, which you can use to fake out the filesystem, caching data +// in memory and have it associated with a file +//----------------------------------------------------------------------------- +class CMemoryFileBacking : public CRefCounted +{ +public: + CMemoryFileBacking( IFileSystem* pFS ) : m_pFS( pFS ), m_nRegistered( 0 ), m_pFileName( NULL ), m_pData( NULL ), m_nLength( 0 ) { } + ~CMemoryFileBacking() { free( (char*) m_pFileName ); if ( m_pData ) m_pFS->FreeOptimalReadBuffer( (char*) m_pData ); } + + IFileSystem* m_pFS; + int m_nRegistered; + const char* m_pFileName; + const char* m_pData; + int m_nLength; + +private: + CMemoryFileBacking( const CMemoryFileBacking& ); // not defined + CMemoryFileBacking& operator=( const CMemoryFileBacking& ); // not defined }; //----------------------------------------------------------------------------- diff --git a/public/filesystem_passthru.h b/public/filesystem_passthru.h index 01db1a93..51931121 100644 --- a/public/filesystem_passthru.h +++ b/public/filesystem_passthru.h @@ -134,7 +134,6 @@ public: virtual void RemoveLoggingFunc( FileSystemLoggingFunc_t logFunc ) { m_pFileSystemPassThru->RemoveLoggingFunc( logFunc ); } virtual FSAsyncStatus_t AsyncReadMultiple( const FileAsyncRequest_t *pRequests, int nRequests, FSAsyncControl_t *pControls ) { return m_pFileSystemPassThru->AsyncReadMultiple( pRequests, nRequests, pControls ); } virtual FSAsyncStatus_t AsyncReadMultipleCreditAlloc( const FileAsyncRequest_t *pRequests, int nRequests, const char *pszFile, int line, FSAsyncControl_t *pControls ) { return m_pFileSystemPassThru->AsyncReadMultipleCreditAlloc( pRequests, nRequests, pszFile, line, pControls ); } - virtual FSAsyncStatus_t AsyncDirectoryScan( const char* pSearchSpec, bool recurseFolders, void* pContext, FSAsyncScanAddFunc_t pfnAdd, FSAsyncScanCompleteFunc_t pfnDone, FSAsyncControl_t *pControl = NULL ) { return m_pFileSystemPassThru->AsyncDirectoryScan( pSearchSpec, recurseFolders, pContext, pfnAdd, pfnDone, pControl ); } virtual FSAsyncStatus_t AsyncFinish(FSAsyncControl_t hControl, bool wait) { return m_pFileSystemPassThru->AsyncFinish( hControl, wait ); } virtual FSAsyncStatus_t AsyncGetResult( FSAsyncControl_t hControl, void **ppData, int *pSize ) { return m_pFileSystemPassThru->AsyncGetResult( hControl, ppData, pSize ); } virtual FSAsyncStatus_t AsyncAbort(FSAsyncControl_t hControl) { return m_pFileSystemPassThru->AsyncAbort( hControl ); } @@ -144,6 +143,8 @@ public: virtual void AsyncRelease( FSAsyncControl_t hControl ) { m_pFileSystemPassThru->AsyncRelease( hControl ); } virtual FSAsyncStatus_t AsyncBeginRead( const char *pszFile, FSAsyncFile_t *phFile ) { return m_pFileSystemPassThru->AsyncBeginRead( pszFile, phFile ); } virtual FSAsyncStatus_t AsyncEndRead( FSAsyncFile_t hFile ) { return m_pFileSystemPassThru->AsyncEndRead( hFile ); } + virtual void AsyncAddFetcher( IAsyncFileFetch *pFetcher ) { m_pFileSystemPassThru->AsyncAddFetcher( pFetcher ); } + virtual void AsyncRemoveFetcher( IAsyncFileFetch *pFetcher ) { m_pFileSystemPassThru->AsyncRemoveFetcher( pFetcher ); } virtual const FileSystemStatistics *GetFilesystemStatistics() { return m_pFileSystemPassThru->GetFilesystemStatistics(); } virtual WaitForResourcesHandle_t WaitForResources( const char *resourcelist ) { return m_pFileSystemPassThru->WaitForResources( resourcelist ); } virtual bool GetWaitForResourcesProgress( WaitForResourcesHandle_t handle, @@ -165,11 +166,6 @@ public: const char *pPathID, FileFindHandle_t *pHandle ) { return m_pFileSystemPassThru->FindFirstEx( pWildCard, pPathID, pHandle ); } - virtual void FindFileAbsoluteList( - CUtlVector &output, - const char *pWildCard, - const char *pPathID - ) { m_pFileSystemPassThru->FindFileAbsoluteList( output, pWildCard, pPathID ); } virtual void MarkPathIDByRequestOnly( const char *pPathID, bool bRequestOnly ) { m_pFileSystemPassThru->MarkPathIDByRequestOnly( pPathID, bRequestOnly ); } virtual bool AddPackFile( const char *fullpath, const char *pathID ) { return m_pFileSystemPassThru->AddPackFile( fullpath, pathID ); } virtual FSAsyncStatus_t AsyncAppend(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t *pControl ) { return m_pFileSystemPassThru->AsyncAppend( pFileName, pSrc, nSrcBytes, bFreeMemory, pControl); } @@ -197,10 +193,13 @@ public: virtual void SetupPreloadData() {} virtual void DiscardPreloadData() {} + virtual void LoadCompiledKeyValues( KeyValuesPreloadType_t type, char const *archiveFile ) { m_pFileSystemPassThru->LoadCompiledKeyValues( type, 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 ) { return m_pFileSystemPassThru->LoadKeyValues( type, filename, pPathID ); } virtual bool LoadKeyValues( KeyValues& head, KeyValuesPreloadType_t type, char const *filename, char const *pPathID = 0 ) { return m_pFileSystemPassThru->LoadKeyValues( head, type, filename, pPathID ); } + virtual bool ExtractRootKeyName( KeyValuesPreloadType_t type, char *outbuf, size_t bufsize, char const *filename, char const *pPathID = 0 ) { return m_pFileSystemPassThru->ExtractRootKeyName( type, outbuf, bufsize, filename, pPathID ); } virtual bool GetFileTypeForFullPath( char const *pFullPath, wchar_t *buf, size_t bufSizeInBytes ) { return m_pFileSystemPassThru->GetFileTypeForFullPath( pFullPath, buf, bufSizeInBytes ); } @@ -218,51 +217,38 @@ public: virtual DVDMode_t GetDVDMode() { return m_pFileSystemPassThru->GetDVDMode(); } - virtual void EnableWhitelistFileTracking( bool bEnable ) - { m_pFileSystemPassThru->EnableWhitelistFileTracking( bEnable ); } - virtual void RegisterFileWhitelist( IFileList *pForceMatchList, IFileList *pAllowFromDiskList, IFileList **pFilesToReload ) - { m_pFileSystemPassThru->RegisterFileWhitelist( pForceMatchList, pAllowFromDiskList, pFilesToReload ); } + virtual void EnableWhitelistFileTracking( bool bEnable, bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes ) + { m_pFileSystemPassThru->EnableWhitelistFileTracking( bEnable, bCacheAllVPKHashes, bRecalculateAndCheckHashes ); } + virtual void RegisterFileWhitelist( IPureServerWhitelist *pWhiteList, IFileList **ppFilesToReload ) + { m_pFileSystemPassThru->RegisterFileWhitelist( pWhiteList, ppFilesToReload ); } virtual void MarkAllCRCsUnverified() { m_pFileSystemPassThru->MarkAllCRCsUnverified(); } virtual void CacheFileCRCs( const char *pPathname, ECacheCRCType eType, IFileList *pFilter ) { return m_pFileSystemPassThru->CacheFileCRCs( pPathname, eType, pFilter ); } - virtual EFileCRCStatus CheckCachedFileCRC( const char *pPathID, const char *pRelativeFilename, CRC32_t *pCRC ) - { return m_pFileSystemPassThru->CheckCachedFileCRC( pPathID, pRelativeFilename, pCRC ); } - virtual int GetUnverifiedCRCFiles( CUnverifiedCRCFile *pFiles, int nMaxFiles ) - { return m_pFileSystemPassThru->GetUnverifiedCRCFiles( pFiles, nMaxFiles ); } + virtual EFileCRCStatus CheckCachedFileHash( const char *pPathID, const char *pRelativeFilename, int nFileFraction, FileHash_t *pFileHash ) + { return m_pFileSystemPassThru->CheckCachedFileHash( pPathID, pRelativeFilename, nFileFraction, pFileHash ); } + virtual int GetUnverifiedFileHashes( CUnverifiedFileHash *pFiles, int nMaxFiles ) + { return m_pFileSystemPassThru->GetUnverifiedFileHashes( pFiles, nMaxFiles ); } virtual int GetWhitelistSpewFlags() { return m_pFileSystemPassThru->GetWhitelistSpewFlags(); } virtual void SetWhitelistSpewFlags( int spewFlags ) { m_pFileSystemPassThru->SetWhitelistSpewFlags( spewFlags ); } virtual void InstallDirtyDiskReportFunc( FSDirtyDiskReportFunc_t func ) { m_pFileSystemPassThru->InstallDirtyDiskReportFunc( func ); } - virtual bool IsLaunchedFromXboxHDD() { return m_pFileSystemPassThru->IsLaunchedFromXboxHDD(); } - virtual bool IsInstalledToXboxHDDCache() { return m_pFileSystemPassThru->IsInstalledToXboxHDDCache(); } - virtual bool IsDVDHosted() { return m_pFileSystemPassThru->IsDVDHosted(); } - virtual bool IsInstallAllowed() { return m_pFileSystemPassThru->IsInstallAllowed(); } - virtual int GetSearchPathID( char *pPath, int nMaxLen ) { return m_pFileSystemPassThru->GetSearchPathID( pPath, nMaxLen ); } - virtual bool FixupSearchPathsAfterInstall() { return m_pFileSystemPassThru->FixupSearchPathsAfterInstall(); } + virtual FileCacheHandle_t CreateFileCache() { return m_pFileSystemPassThru->CreateFileCache(); } + virtual void AddFilesToFileCache( FileCacheHandle_t cacheId, const char **ppFileNames, int nFileNames, const char *pPathID ) { m_pFileSystemPassThru->AddFilesToFileCache( cacheId, ppFileNames, nFileNames, pPathID ); } + virtual bool IsFileCacheFileLoaded( FileCacheHandle_t cacheId, const char *pFileName ) { return m_pFileSystemPassThru->IsFileCacheFileLoaded( cacheId, pFileName ); } + virtual bool IsFileCacheLoaded( FileCacheHandle_t cacheId ) { return m_pFileSystemPassThru->IsFileCacheLoaded( cacheId ); } + virtual void DestroyFileCache( FileCacheHandle_t cacheId ) { m_pFileSystemPassThru->DestroyFileCache( cacheId ); } - virtual FSDirtyDiskReportFunc_t GetDirtyDiskReportFunc() { return m_pFileSystemPassThru->GetDirtyDiskReportFunc(); } - - virtual void AddVPKFile( char const *pPkName, SearchPathAdd_t addType = PATH_ADD_TO_TAIL ) { m_pFileSystemPassThru->AddVPKFile( pPkName, addType ); } - virtual void RemoveVPKFile( char const *pPkName ) { m_pFileSystemPassThru->RemoveVPKFile( pPkName ); } - virtual void GetVPKFileNames( CUtlVector &destVector ) { m_pFileSystemPassThru->GetVPKFileNames( destVector ); } - - virtual void RemoveAllMapSearchPaths( void ) { m_pFileSystemPassThru->RemoveAllMapSearchPaths(); } - - virtual void SyncDvdDevCache( void ) { m_pFileSystemPassThru->SyncDvdDevCache(); } - - virtual bool GetStringFromKVPool( CRC32_t poolKey, unsigned int key, char *pOutBuff, int buflen ) { return m_pFileSystemPassThru->GetStringFromKVPool( poolKey, key, pOutBuff, buflen ); } - - virtual bool DiscoverDLC( int iController ) { return m_pFileSystemPassThru->DiscoverDLC( iController ); } - virtual int IsAnyDLCPresent( bool *pbDLCSearchPathMounted = NULL ) { return m_pFileSystemPassThru->IsAnyDLCPresent( pbDLCSearchPathMounted ); } - virtual bool GetAnyDLCInfo( int iDLC, unsigned int *pLicenseMask, wchar_t *pTitleBuff, int nOutTitleSize ) { return m_pFileSystemPassThru->GetAnyDLCInfo( iDLC, pLicenseMask, pTitleBuff, nOutTitleSize ); } - virtual int IsAnyCorruptDLC() { return m_pFileSystemPassThru->IsAnyCorruptDLC(); } - virtual bool GetAnyCorruptDLCInfo( int iCorruptDLC, wchar_t *pTitleBuff, int nOutTitleSize ) { return m_pFileSystemPassThru->GetAnyCorruptDLCInfo( iCorruptDLC, pTitleBuff, nOutTitleSize ); } - virtual bool AddDLCSearchPaths() { return m_pFileSystemPassThru->AddDLCSearchPaths(); } - virtual bool IsSpecificDLCPresent( unsigned int nDLCPackage ) { return m_pFileSystemPassThru->IsSpecificDLCPresent( nDLCPackage ); } - virtual void SetIODelayAlarm( float flThreshhold ) { m_pFileSystemPassThru->SetIODelayAlarm( flThreshhold ); } + virtual bool RegisterMemoryFile( CMemoryFileBacking *pFile, CMemoryFileBacking **ppExistingFileWithRef ) { return m_pFileSystemPassThru->RegisterMemoryFile( pFile, ppExistingFileWithRef ); } + virtual void UnregisterMemoryFile( CMemoryFileBacking *pFile ) { m_pFileSystemPassThru->UnregisterMemoryFile( pFile ); } + virtual void CacheAllVPKFileHashes( bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes ) + { return m_pFileSystemPassThru->CacheAllVPKFileHashes( bCacheAllVPKHashes, bRecalculateAndCheckHashes ); } + virtual bool CheckVPKFileHash( int PackFileID, int nPackFileNumber, int nFileFraction, MD5Value_t &md5Value ) + { return m_pFileSystemPassThru->CheckVPKFileHash( PackFileID, nPackFileNumber, nFileFraction, md5Value ); } + virtual void NotifyFileUnloaded( const char *pszFilename, const char *pPathId ) + { m_pFileSystemPassThru->NotifyFileUnloaded( pszFilename, pPathId ); } protected: IFileSystem *m_pFileSystemPassThru; diff --git a/public/globalvars_base.h b/public/globalvars_base.h index 1ae8c727..7c9e5cc9 100644 --- a/public/globalvars_base.h +++ b/public/globalvars_base.h @@ -24,6 +24,8 @@ public: // This can be used to filter debug output or to catch the client or server in the act. bool IsClient() const; + + bool IsRemoteClient() const; // for encoding m_flSimulationTime, m_flAnimTime int GetNetworkBase( int nTick, int nEntity ); @@ -79,6 +81,10 @@ private: // Set to true in client code. bool m_bClient; +public: + bool m_bRemoteClient; + +private: // 100 (i.e., tickcount is rounded down to this base and then the "delta" from this base is networked int nTimestampNetworkingBase; // 32 (entindex() % nTimestampRandomizeWindow ) is subtracted from gpGlobals->tickcount to set the networking basis, prevents @@ -106,4 +112,9 @@ inline bool CGlobalVarsBase::IsClient() const return m_bClient; } +inline bool CGlobalVarsBase::IsRemoteClient() const +{ + return m_bRemoteClient; +} + #endif // GLOBALVARS_BASE_H diff --git a/public/iclient.h b/public/iclient.h index 9133994e..34400818 100644 --- a/public/iclient.h +++ b/public/iclient.h @@ -19,6 +19,15 @@ class INetMessage; struct NetMessageCvar_t; struct USERID_t; +enum CrossPlayPlatform_t +{ + CROSSPLAYPLATFORM_UNKNOWN, + CROSSPLAYPLATFORM_PC, + CROSSPLAYPLATFORM_X360, + CROSSPLAYPLATFORM_PS3, + CROSSPLAYPLATFORM_LAST, +}; + abstract_class IClient : public INetChannelHandler { public: @@ -76,8 +85,6 @@ public: virtual bool IsFakeClient( void ) const = 0; // returns true, if client is a HLTV proxy virtual bool IsHLTV( void ) const = 0; - // returns true, if client is a Replay proxy - virtual bool IsReplay( void ) const = 0; // returns true, if client hears this player virtual bool IsHearingClient(int index) const = 0; // returns true, if client hears this player by proximity @@ -99,7 +106,7 @@ public: virtual bool IsHumanPlayer() const = 0; - virtual int GetClientPlatform() const = 0; + virtual CrossPlayPlatform_t GetClientPlatform() const = 0; }; #endif // ICLIENT_H diff --git a/public/igameevents.h b/public/igameevents.h index a2a08a0c..578812bd 100644 --- a/public/igameevents.h +++ b/public/igameevents.h @@ -78,12 +78,14 @@ public: virtual uint64 GetUint64( const char *keyName = NULL, uint64 defaultValue = 0 ) = 0; virtual float GetFloat( const char *keyName = NULL, float defaultValue = 0.0f ) = 0; virtual const char *GetString( const char *keyName = NULL, const char *defaultValue = "" ) = 0; + virtual const wchar_t * GetWString(char const *keyName = NULL, const wchar_t *defaultValue = L"") = 0; virtual void SetBool( const char *keyName, bool value ) = 0; virtual void SetInt( const char *keyName, int value ) = 0; virtual void SetUint64( const char *keyName, uint64 value ) = 0; virtual void SetFloat( const char *keyName, float value ) = 0; virtual void SetString( const char *keyName, const char *value ) = 0; + virtual void SetWString( const char *keyName, const wchar_t *value ) = 0; }; #define EVENT_DEBUG_ID_INIT 42 diff --git a/public/networkvar.h b/public/networkvar.h index 8887a2cf..51724d84 100644 --- a/public/networkvar.h +++ b/public/networkvar.h @@ -18,8 +18,9 @@ #include "basehandle.h" #endif - +#ifdef _MSC_VER #pragma warning( disable : 4284 ) // warning C4284: return type for 'CNetworkVarT::operator ->' is 'int *' (ie; not a UDT or reference to a UDT. Will produce errors if applied using infix notation) +#endif #define MyOffsetOf( type, var ) ( (int)&((type*)0)->var ) diff --git a/public/tier0/platform.h b/public/tier0/platform.h index f56e3786..b5e03e6a 100644 --- a/public/tier0/platform.h +++ b/public/tier0/platform.h @@ -293,29 +293,61 @@ typedef unsigned int uint; // Maximum and minimum representable values -#ifndef PLATFORM_OSX +#if !defined(PLATFORM_OSX) && !defined(__STDC_LIMIT_MACROS) +#ifndef INT8_MAX #define INT8_MAX SCHAR_MAX +#endif +#ifndef INT16_MAX #define INT16_MAX SHRT_MAX +#endif +#ifndef INT32_MAX #define INT32_MAX LONG_MAX +#endif +#ifndef INT64_MAX #define INT64_MAX (((int64)~0) >> 1) +#endif +#ifndef INT8_MIN #define INT8_MIN SCHAR_MIN +#endif +#ifndef INT16_MIN #define INT16_MIN SHRT_MIN +#endif +#ifndef INT32_MIN #define INT32_MIN LONG_MIN +#endif +#ifndef INT64_MIN #define INT64_MIN (((int64)1) << 63) +#endif +#ifndef UINT8_MAX #define UINT8_MAX ((uint8)~0) +#endif +#ifndef UINT16_MAX #define UINT16_MAX ((uint16)~0) +#endif +#ifndef UINT32_MAX #define UINT32_MAX ((uint32)~0) +#endif +#ifndef UINT16_MAX #define UINT64_MAX ((uint64)~0) +#endif +#ifndef UINT8_MIN #define UINT8_MIN 0 +#endif +#ifndef UINT16_MIN #define UINT16_MIN 0 +#endif +#ifndef UINT32_MIN #define UINT32_MIN 0 +#endif +#ifndef UINT64_MIN #define UINT64_MIN 0 +#endif -#endif // PLATFORM_OSX +#endif // !PLATFORM_OSX && !__STDC_LIMIT_MACROS #ifndef UINT_MIN #define UINT_MIN UINT32_MIN @@ -1127,8 +1159,19 @@ struct CPUInformation CPUInformation(): m_Size(0){} }; +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunknown-pragmas" +#pragma clang diagnostic ignored "-Wreturn-type-c-linkage" +#endif + PLATFORM_INTERFACE const CPUInformation& GetCPUInformation(); +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + PLATFORM_INTERFACE void GetCurrentDate( int *pDay, int *pMonth, int *pYear ); PLATFORM_INTERFACE void GetCurrentDayOfTheWeek( int *pDay ); // 0 = Sunday PLATFORM_INTERFACE void GetCurrentDayOfTheYear( int *pDay ); // 0 = Jan 1 diff --git a/public/tier0/threadtools.h b/public/tier0/threadtools.h index abb36908..622c4261 100644 --- a/public/tier0/threadtools.h +++ b/public/tier0/threadtools.h @@ -890,9 +890,22 @@ template <> struct CAutoLockTypeDeducer { typed #define AUTO_LOCK_( type, mutex ) \ CAutoLockT< type > UNIQUE_ID( static_cast( mutex ) ) -#define AUTO_LOCK( mutex ) \ - AUTO_LOCK_( typeof(CAutoLockTypeDeducer::Type_t), mutex ) +#if defined(GNUC) +template T strip_cv_quals_for_mutex(T&); +template T strip_cv_quals_for_mutex(const T&); +template T strip_cv_quals_for_mutex(volatile T&); +template T strip_cv_quals_for_mutex(const volatile T&); + +#define AUTO_LOCK( mutex ) \ + AUTO_LOCK_( typeof(::strip_cv_quals_for_mutex(mutex)), mutex ) + +#else // GNUC + +#define AUTO_LOCK( mutex ) \ + AUTO_LOCK_( CAutoLockTypeDeducer::Type_t, mutex ) + +#endif #define AUTO_LOCK_FM( mutex ) \ AUTO_LOCK_( CThreadFastMutex, mutex ) diff --git a/public/tier1/checksum_md5.h b/public/tier1/checksum_md5.h index 134d2b52..a050119b 100644 --- a/public/tier1/checksum_md5.h +++ b/public/tier1/checksum_md5.h @@ -13,6 +13,18 @@ // 16 bytes == 128 bit digest #define MD5_DIGEST_LENGTH 16 +#define MD5_BIT_LENGTH ( MD5_DIGEST_LENGTH * sizeof(unsigned char) ) +struct MD5Value_t +{ + unsigned char bits[MD5_DIGEST_LENGTH]; + + void Zero(); + bool IsZero() const; + + bool operator==( const MD5Value_t &src ) const; + bool operator!=( const MD5Value_t &src ) const; + +}; // MD5 Hash typedef struct @@ -28,6 +40,23 @@ void MD5Final( unsigned char digest[ MD5_DIGEST_LENGTH ], MD5Context_t *context char *MD5_Print(unsigned char *digest, int hashlen ); +/// Convenience wrapper to calculate the MD5 for a buffer, all in one step, without +/// bothering with the context object. +void MD5_ProcessSingleBuffer( const void *p, int len, MD5Value_t &md5Result ); + unsigned int MD5_PseudoRandom(unsigned int nSeed); +/// Returns true if the values match. +bool MD5_Compare( const MD5Value_t &data, const MD5Value_t &compare ); + +inline bool MD5Value_t::operator==( const MD5Value_t &src ) const +{ + return MD5_Compare( *this, src ); +} + +inline bool MD5Value_t::operator!=( const MD5Value_t &src ) const +{ + return !MD5_Compare( *this, src ); +} + #endif // CHECKSUM_MD5_H diff --git a/public/tier1/convar.h b/public/tier1/convar.h index 29fddb72..8e800fab 100644 --- a/public/tier1/convar.h +++ b/public/tier1/convar.h @@ -371,8 +371,8 @@ public: FnChangeCallback_t GetChangeCallback( int slot ) const { return m_pParent->m_fnChangeCallbacks[ slot ]; } // Retrieve value - FORCEINLINE_CVAR float GetFloat( void ) const; - FORCEINLINE_CVAR int GetInt( void ) const; + virtual float GetFloat( void ) const; + virtual int GetInt( void ) const; FORCEINLINE_CVAR Color GetColor( void ) const; FORCEINLINE_CVAR bool GetBool() const { return !!GetInt(); } FORCEINLINE_CVAR char const *GetString( void ) const; diff --git a/tier1/checksum_md5.cpp b/tier1/checksum_md5.cpp index 0c4aeefa..4a774aff 100644 --- a/tier1/checksum_md5.cpp +++ b/tier1/checksum_md5.cpp @@ -232,7 +232,7 @@ void MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5Context_t *ctx) MD5Transform(ctx->buf, (unsigned int *) ctx->in); //byteReverse((unsigned char *) ctx->buf, 4); memcpy(digest, ctx->buf, MD5_DIGEST_LENGTH); - memset(ctx, 0, sizeof(MD5Context_t)); /* In case it's sensitive */ + memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ } //----------------------------------------------------------------------------- @@ -269,3 +269,37 @@ unsigned int MD5_PseudoRandom(unsigned int nSeed) return *(unsigned int*)(digest+6); // use 4 middle bytes for random value } + +//----------------------------------------------------------------------------- +bool MD5_Compare( const MD5Value_t &data, const MD5Value_t &compare ) +{ + return V_memcmp( data.bits, compare.bits, MD5_DIGEST_LENGTH ) == 0; +} + +//----------------------------------------------------------------------------- +void MD5Value_t::Zero() +{ + V_memset( bits, 0, sizeof( bits ) ); +} + +//----------------------------------------------------------------------------- +bool MD5Value_t::IsZero() const +{ + for ( size_t i = 0 ; i < Q_ARRAYSIZE( bits ) ; ++i ) + { + if ( bits[i] != 0 ) + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +void MD5_ProcessSingleBuffer( const void *p, int len, MD5Value_t &md5Result ) +{ + Assert( len >= 0 ); + MD5Context_t ctx; + MD5Init( &ctx ); + MD5Update( &ctx, (unsigned char const *)p, len ); + MD5Final( md5Result.bits, &ctx ); +}