//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ //=============================================================================// #include "basefilesystem.h" #include "steamcommon.h" #include "SteamInterface.h" #include "tier0/dbg.h" #include "tier0/icommandline.h" #include "steam/steam_api.h" #ifdef POSIX #include #ifdef LINUX #include #endif #include #define _S_IWRITE S_IWRITE #define _S_IWRITE S_IWRITE #define _S_IFREG S_IFREG #define FILE_ATTRIBUTE_OFFLINE 0x1000 #endif #ifdef _WIN32 extern "C" { __declspec(dllimport) int __stdcall IsDebuggerPresent(); } #endif ISteamInterface *steam = NULL; static SteamHandle_t g_pLastErrorFile; static TSteamError g_tLastError; static TSteamError g_tLastErrorNoFile; void CheckError( SteamHandle_t fp, TSteamError & steamError) { if (steamError.eSteamError == eSteamErrorContentServerConnect) { // fatal error #ifdef WIN32 // kill the current window so the user can see the error HWND hwnd = GetForegroundWindow(); if (hwnd) { DestroyWindow(hwnd); } // show the error MessageBox(NULL, "Could not acquire necessary game files because the connection to Steam servers was lost.", "Source - Fatal Error", MB_OK | MB_ICONEXCLAMATION); // get out of here immediately TerminateProcess(GetCurrentProcess(), 0); #else fprintf( stderr, "Could not acquire necessary game files because the connection to Steam servers was lost." ); exit(-1); #endif return; } if (fp) { if (steamError.eSteamError != eSteamErrorNone || g_tLastError.eSteamError != eSteamErrorNone) { g_pLastErrorFile = fp; g_tLastError = steamError; } } else { // write to the NULL error checker if (steamError.eSteamError != eSteamErrorNone || g_tLastErrorNoFile.eSteamError != eSteamErrorNone) { g_tLastErrorNoFile = steamError; } } } #ifdef POSIX class CSteamFile { public: explicit CSteamFile( SteamHandle_t file, bool bWriteable, const char *pchName ) : m_File( file ), m_bWriteable( bWriteable ), m_FileName(pchName) {} ~CSteamFile() {} SteamHandle_t Handle() { return m_File; } bool BWriteable() { return m_bWriteable; } CUtlSymbol GetFileName() { return m_FileName; } private: SteamHandle_t m_File; bool m_bWriteable; CUtlSymbol m_FileName; }; #endif class CFileSystem_Steam : public CBaseFileSystem { public: CFileSystem_Steam(); ~CFileSystem_Steam(); // Methods of IAppSystem virtual InitReturnVal_t Init(); virtual void Shutdown(); virtual void * QueryInterface( const char *pInterfaceName ); // Higher level filesystem methods requiring specific behavior virtual void GetLocalCopy( const char *pFileName ); virtual int HintResourceNeed( const char *hintlist, int forgetEverything ); virtual CSysModule * LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ); virtual bool IsFileImmediatelyAvailable(const char *pFileName); // resource waiting virtual WaitForResourcesHandle_t WaitForResources( const char *resourcelist ); virtual bool GetWaitForResourcesProgress( WaitForResourcesHandle_t handle, float *progress /* out */ , bool *complete /* out */ ); virtual void CancelWaitForResources( WaitForResourcesHandle_t handle ); virtual bool IsSteam() const { return true; } virtual FilesystemMountRetval_t MountSteamContent( int nExtraAppId = -1 ); protected: // implementation of CBaseFileSystem virtual functions virtual FILE *FS_fopen( const char *filename, const char *options, unsigned flags, int64 *size, CFileLoadInfo *pInfo ); virtual void FS_setbufsize( FILE *fp, unsigned nBytes ); virtual void FS_fclose( FILE *fp ); virtual void FS_fseek( FILE *fp, int64 pos, int seekType ); virtual long FS_ftell( FILE *fp ); virtual int FS_feof( FILE *fp ); virtual size_t FS_fread( void *dest, size_t destSize, size_t size, FILE *fp ); virtual size_t FS_fwrite( const void *src, size_t size, FILE *fp ); virtual size_t FS_vfprintf( FILE *fp, const char *fmt, va_list list ); virtual int FS_ferror( FILE *fp ); virtual int FS_fflush( FILE *fp ); virtual char *FS_fgets( char *dest, int destSize, FILE *fp ); virtual int FS_stat( const char *path, struct _stat *buf, bool *pbLoadedFromSteamCache=NULL ); virtual int FS_chmod( const char *path, int pmode ); virtual HANDLE FS_FindFirstFile(const char *findname, WIN32_FIND_DATA *dat); virtual bool FS_FindNextFile(HANDLE handle, WIN32_FIND_DATA *dat); virtual bool FS_FindClose(HANDLE handle); private: bool IsFileInSteamCache( const char *file ); bool IsFileInSteamCache2( const char *file ); void ViewSteamCache( const char* szDir, bool bRecurse ); bool m_bSteamInitialized; bool m_bCurrentlyLoading; bool m_bAssertFilesImmediatelyAvailable; bool m_bCanAsync; bool m_bSelfMounted; bool m_bContentLoaded; bool m_bSDKToolMode; SteamCallHandle_t m_hWaitForResourcesCallHandle; int m_iCurrentReturnedCallHandle; HMODULE m_hSteamDLL; void LoadAndStartSteam(); #ifdef POSIX static CUtlMap< int, CInterlockedInt > m_LockedFDMap; #endif }; #ifdef POSIX CUtlMap< int, CInterlockedInt> CFileSystem_Steam::m_LockedFDMap; #endif //----------------------------------------------------------------------------- // singleton //----------------------------------------------------------------------------- static CFileSystem_Steam g_FileSystem_Steam; #if defined(DEDICATED) CBaseFileSystem *BaseFileSystem_Steam( void ) { return &g_FileSystem_Steam; } #endif #ifdef DEDICATED // "hack" to allow us to not export a stdio version of the FILESYSTEM_INTERFACE_VERSION anywhere IFileSystem *g_pFileSystemSteam = &g_FileSystem_Steam; IBaseFileSystem *g_pBaseFileSystemSteam = &g_FileSystem_Steam; #else EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CFileSystem_Steam, IFileSystem, FILESYSTEM_INTERFACE_VERSION, g_FileSystem_Steam ); EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CFileSystem_Steam, IBaseFileSystem, BASEFILESYSTEM_INTERFACE_VERSION, g_FileSystem_Steam ); #endif //----------------------------------------------------------------------------- // constructor //----------------------------------------------------------------------------- CFileSystem_Steam::CFileSystem_Steam() { m_bSteamInitialized = false; m_bCurrentlyLoading = false; m_bAssertFilesImmediatelyAvailable = false; m_bCanAsync = true; m_bContentLoaded = false; m_hWaitForResourcesCallHandle = STEAM_INVALID_CALL_HANDLE; m_iCurrentReturnedCallHandle = 1; m_hSteamDLL = NULL; m_bSDKToolMode = false; #ifdef POSIX SetDefLessFunc( m_LockedFDMap ); #endif } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CFileSystem_Steam::~CFileSystem_Steam() { m_bSteamInitialized = false; } bool CFileSystem_Steam::IsFileInSteamCache2( const char *file ) { if ( !m_bContentLoaded || m_bSDKToolMode) { return true; } // see if the file exists TSteamElemInfo info; TSteamError error; SteamHandle_t h = steam->FindFirst( file, eSteamFindRemoteOnly, &info, &error ); if ( h == STEAM_INVALID_HANDLE ) { return false; } else { steam->FindClose( h, &error ); } return true; } void MountDependencies( int iAppId, CUtlVector &depList ) { TSteamError steamError; // Setup the buffers for the TSteamApp structure. char buffers[4][2048]; TSteamApp steamApp; steamApp.szName = buffers[0]; steamApp.uMaxNameChars = sizeof( buffers[0] ); steamApp.szLatestVersionLabel = buffers[1]; steamApp.uMaxLatestVersionLabelChars = sizeof( buffers[1] ); steamApp.szCurrentVersionLabel = buffers[2]; steamApp.uMaxCurrentVersionLabelChars = sizeof( buffers[2] ); steamApp.szInstallDirName = buffers[3]; steamApp.uMaxInstallDirNameChars = sizeof( buffers[3] ); // Ask how many caches depend on this app ID. steam->EnumerateApp( iAppId, &steamApp, &steamError ); if ( steamError.eSteamError != eSteamErrorNone ) Error( "EnumerateApp( %d ) failed: %s", iAppId, steamError.szDesc ); // Mount each cache. for ( int i=0; i < (int)steamApp.uNumDependencies; i++ ) { TSteamAppDependencyInfo appDependencyInfo; steam->EnumerateAppDependency( iAppId, i, &appDependencyInfo, &steamError ); if ( steamError.eSteamError != eSteamErrorNone ) Error( "EnumerateAppDependency( %d, %d ) failed: %s", iAppId, i, steamError.szDesc ); if ( depList.Find( appDependencyInfo.uAppId ) == -1 ) { depList.AddToTail( appDependencyInfo.uAppId ); // Make sure that the user owns the app before attempting to mount it int isSubscribed = false, isPending = false; steam->IsAppSubscribed( appDependencyInfo.uAppId, &isSubscribed, &isPending, &steamError ); if ( isSubscribed ) { steam->MountFilesystem( appDependencyInfo.uAppId, "", &steamError ); if ( steamError.eSteamError != eSteamErrorNone && steamError.eSteamError != eSteamErrorNotSubscribed ) { Error( "MountFilesystem( %d ) failed: %s", appDependencyInfo.uAppId, steamError.szDesc ); } } } } } //----------------------------------------------------------------------------- // QueryInterface: //----------------------------------------------------------------------------- void *CFileSystem_Steam::QueryInterface( const char *pInterfaceName ) { // We also implement the IMatSystemSurface interface if (!Q_strncmp( pInterfaceName, FILESYSTEM_INTERFACE_VERSION, Q_strlen(FILESYSTEM_INTERFACE_VERSION) + 1)) return (IFileSystem*)this; return CBaseFileSystem::QueryInterface( pInterfaceName ); } //----------------------------------------------------------------------------- // Methods of IAppSystem //----------------------------------------------------------------------------- InitReturnVal_t CFileSystem_Steam::Init() { m_bSteamInitialized = true; m_bSelfMounted = false; LoadAndStartSteam(); return CBaseFileSystem::Init(); } void CFileSystem_Steam::Shutdown() { Assert( m_bSteamInitialized ); if ( !steam ) return; TSteamError steamError; // If we're not running Steam in local mode, remove all mount points from the STEAM VFS. if ( !CommandLine()->CheckParm("-steamlocal") && !m_bSelfMounted && !steam->UnmountAppFilesystem(&steamError) ) { #ifdef WIN32 OutputDebugString(steamError.szDesc); #endif Assert(!("STEAM VFS failed to unmount")); // just continue on as if nothing happened // ::MessageBox(NULL, szErrorMsg, "Half-Life FileSystem_Steam Error", MB_OK); // exit( -1 ); } steam->Cleanup(&steamError); if ( m_hSteamDLL ) { Sys_UnloadModule( (CSysModule *)m_hSteamDLL ); m_hSteamDLL = NULL; } m_bSteamInitialized = false; } void CFileSystem_Steam::LoadAndStartSteam() { if ( !m_hSteamDLL ) { const char *pchSteamInstallPath = SteamAPI_GetSteamInstallPath(); if ( pchSteamInstallPath ) { char szSteamDLLPath[ MAX_PATH ]; #ifdef WIN32 V_ComposeFileName( pchSteamInstallPath, "steam" DLL_EXT_STRING, szSteamDLLPath, Q_ARRAYSIZE(szSteamDLLPath) ); #elif defined(POSIX) V_ComposeFileName( pchSteamInstallPath, "libsteam" DLL_EXT_STRING, szSteamDLLPath, Q_ARRAYSIZE(szSteamDLLPath) ); #else #error #endif // try to load the steam.dll from the running steam process first m_hSteamDLL = (HMODULE)Sys_LoadModule( szSteamDLLPath ); } if ( !m_hSteamDLL ) #ifdef WIN32 m_hSteamDLL = (HMODULE)Sys_LoadModule( "steam" DLL_EXT_STRING ); #elif defined(POSIX) m_hSteamDLL = (HMODULE)Sys_LoadModule( "libsteam" DLL_EXT_STRING ); #else #error #endif } if ( m_hSteamDLL ) { typedef void *(*PFSteamCreateInterface)( const char *pchSteam ); #ifdef WIN32 PFSteamCreateInterface pfnSteamCreateInterface = (PFSteamCreateInterface)GetProcAddress( m_hSteamDLL, "_f" ); #else PFSteamCreateInterface pfnSteamCreateInterface = (PFSteamCreateInterface)dlsym( (void *)m_hSteamDLL, "_f" ); #endif if ( pfnSteamCreateInterface ) steam = (ISteamInterface *)pfnSteamCreateInterface( STEAM_INTERFACE_VERSION ); } if ( !steam ) { Error("CFileSystem_Steam::Init() failed: failed to find steam interface\n"); #ifdef WIN32 ::DestroyWindow( GetForegroundWindow() ); ::MessageBox(NULL, "CFileSystem_Steam::Init() failed: failed to find steam interface", "Half-Life FileSystem_Steam Error", MB_OK); #endif _exit( -1 ); } TSteamError steamError; if (!steam->Startup(STEAM_USING_FILESYSTEM | STEAM_USING_LOGGING | STEAM_USING_USERID | STEAM_USING_ACCOUNT, &steamError)) { Error("SteamStartup() failed: %s\n", steamError.szDesc); #ifdef WIN32 ::DestroyWindow( GetForegroundWindow() ); ::MessageBox(NULL, steamError.szDesc, "Half-Life FileSystem_Steam Error", MB_OK); #endif _exit( -1 ); } } //----------------------------------------------------------------------------- // Methods of IAppSystem //----------------------------------------------------------------------------- FilesystemMountRetval_t CFileSystem_Steam::MountSteamContent( int nExtraAppId ) { m_bContentLoaded = true; FilesystemMountRetval_t retval = FILESYSTEM_MOUNT_OK; // MWD: This is here because of Hammer's funky startup sequence that requires MountSteamContent() be called in CHammerApp::PreInit(). Once that root problem is addressed this will be removed; if ( NULL == steam ) { LoadAndStartSteam(); } // only mount if we're already logged in // if we're not logged in, assume the app will login & mount the cache itself // this enables both the game and the platform to use this same code, even though they mount caches at different times int loggedIn = 0; TSteamError steamError; int result = steam->IsLoggedIn(&loggedIn, &steamError); if (!result || loggedIn) { if ( nExtraAppId != -1 ) { m_bSDKToolMode = true; CUtlVector depList; if ( nExtraAppId < -1 ) { // Special way to tell them to mount a specific App ID's depots. MountDependencies( -nExtraAppId, depList ); return FILESYSTEM_MOUNT_OK; } else { const char *pMainAppId = NULL; // If they specified extra app IDs they want to mount after the main one, then we mount // the caches manually here. #ifdef _WIN32 // Use GetEnvironmentVariable instead of getenv because getenv doesn't pick up changes // to the process environment after the DLL was loaded. char szMainAppId[128]; if ( GetEnvironmentVariable( "steamappid", szMainAppId, sizeof( szMainAppId ) ) != 0 ) { pMainAppId = szMainAppId; } #else // LINUX BUG: see above pMainAppId = getenv( "SteamAppId" ); #endif // _WIN32 if ( !pMainAppId ) Error( "Extra App ID set to %d, but no SteamAppId.", nExtraAppId ); //swapping this mount order ensures the most current engine binaries are used by tools MountDependencies( nExtraAppId, depList ); MountDependencies( atoi( pMainAppId ), depList ); return FILESYSTEM_MOUNT_OK; } } else if (!steam->MountAppFilesystem(&steamError)) { Error("MountAppFilesystem() failed: %s\n", steamError.szDesc); #ifdef WIN32 ::DestroyWindow( GetForegroundWindow() ); ::MessageBox(NULL, steamError.szDesc, "Half-Life FileSystem_Steam Error", MB_OK); #endif _exit( -1 ); } } else { m_bSelfMounted = true; } return retval; } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- FILE *CFileSystem_Steam::FS_fopen( const char *filenameT, const char *options, unsigned flags, int64 *size, CFileLoadInfo *pInfo ) { char filename[MAX_PATH]; FixUpPath ( filenameT, filename, sizeof( filename ) ); // make sure the file is immediately available if (m_bAssertFilesImmediatelyAvailable && !m_bCurrentlyLoading) { if (!IsFileImmediatelyAvailable(filename)) { Msg("Steam FS: '%s' not immediately available when not in loading dialog", filename); } } if ( !steam ) { AssertMsg( 0, "CFileSystem_Steam::FS_fopen used with null steam interface!" ); return NULL; } CFileLoadInfo dummyInfo; if ( !pInfo ) { dummyInfo.m_bSteamCacheOnly = false; pInfo = &dummyInfo; } SteamHandle_t f = 0; #ifdef POSIX FILE *pFile = NULL; bool bWriteable = false; if ( strchr(options,'w') || strchr(options,'a') ) bWriteable = true; if ( bWriteable ) { pFile = fopen( filename, options ); if (pFile && size) { // todo: replace with filelength()? struct _stat buf; int rt = _stat( filename, &buf ); if (rt == 0) { *size = buf.st_size; } } if ( pFile ) { // Win32 has an undocumented feature that is serialized ALL writes to a file across threads (i.e only 1 thread can open a file at a time) // so use flock here to mimic that behavior ThreadId_t curThread = ThreadGetCurrentId(); { CThreadFastMutex Locklock; AUTO_LOCK( Locklock ); int fd = fileno_unlocked( pFile ); int iLockID = m_LockedFDMap.Find( fd ); int ret = flock( fd, LOCK_EX | LOCK_NB ); if ( ret < 0 ) { if ( errno == EWOULDBLOCK ) { if ( iLockID != m_LockedFDMap.InvalidIndex() && m_LockedFDMap[iLockID] != -1 && curThread != m_LockedFDMap[iLockID] ) { ret = flock( fd, LOCK_EX ); if ( ret < 0 ) { fclose( pFile ); return NULL; } } } else { fclose( pFile ); return NULL; } } if ( iLockID != m_LockedFDMap.InvalidIndex() ) m_LockedFDMap[iLockID] = curThread; else m_LockedFDMap.Insert( fd, curThread ); } rewind( pFile ); } } else { #endif TSteamError steamError; unsigned int fileSize; int bLocal = 0; f = steam->OpenFileEx(filename, options, pInfo->m_bSteamCacheOnly, &fileSize, &bLocal, &steamError); pInfo->m_bLoadedFromSteamCache = (bLocal == 0); if (size) { *size = fileSize; } CheckError( f, steamError ); #ifdef POSIX } if ( f || pFile ) { CSteamFile *steamFile = new CSteamFile( pFile ? (SteamHandle_t)pFile : f, bWriteable, filename ); f = (SteamHandle_t)steamFile; } #endif return (FILE *)f; } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- void CFileSystem_Steam::FS_setbufsize( FILE *fp, unsigned nBytes ) { } //----------------------------------------------------------------------------- // Purpose: steam call, unnecessary in stdio //----------------------------------------------------------------------------- WaitForResourcesHandle_t CFileSystem_Steam::WaitForResources( const char *resourcelist ) { char szResourceList[MAX_PATH]; Q_strncpy( szResourceList, resourcelist, sizeof(szResourceList) ); Q_DefaultExtension( szResourceList, ".lst", sizeof(szResourceList) ); // cancel any old call TSteamError steamError; m_hWaitForResourcesCallHandle = steam->WaitForResources(szResourceList, &steamError); if (steamError.eSteamError == eSteamErrorNone) { // return a new call handle return (WaitForResourcesHandle_t)(++m_iCurrentReturnedCallHandle); } Msg("SteamWaitForResources() failed: %s\n", steamError.szDesc); return (WaitForResourcesHandle_t)FILESYSTEM_INVALID_HANDLE; } //----------------------------------------------------------------------------- // Purpose: steam call, unnecessary in stdio //----------------------------------------------------------------------------- bool CFileSystem_Steam::GetWaitForResourcesProgress( WaitForResourcesHandle_t handle, float *progress /* out */ , bool *complete /* out */ ) { // clear the input *progress = 0.0f; *complete = true; // check to see if they're using an old handle if (m_iCurrentReturnedCallHandle != handle) return false; if (m_hWaitForResourcesCallHandle == STEAM_INVALID_CALL_HANDLE) return false; // get the progress TSteamError steamError; TSteamProgress steamProgress; int result = steam->ProcessCall(m_hWaitForResourcesCallHandle, &steamProgress, &steamError); if (result && steamError.eSteamError == eSteamErrorNone) { // we've finished successfully m_hWaitForResourcesCallHandle = STEAM_INVALID_CALL_HANDLE; *complete = true; *progress = 1.0f; return true; } else if (steamError.eSteamError != eSteamErrorNotFinishedProcessing) { // we have an error, just call it done m_hWaitForResourcesCallHandle = STEAM_INVALID_CALL_HANDLE; Msg("SteamProcessCall(SteamWaitForResources()) failed: %s\n", steamError.szDesc); return false; } // return the progress if (steamProgress.bValid) { *progress = (float)steamProgress.uPercentDone / (100.0f * STEAM_PROGRESS_PERCENT_SCALE); } else { *progress = 0; } *complete = false; return (steamProgress.bValid != false); } //----------------------------------------------------------------------------- // Purpose: steam call, unnecessary in stdio //----------------------------------------------------------------------------- void CFileSystem_Steam::CancelWaitForResources( WaitForResourcesHandle_t handle ) { // check to see if they're using an old handle if (m_iCurrentReturnedCallHandle != handle) return; if (m_hWaitForResourcesCallHandle == STEAM_INVALID_CALL_HANDLE) return; TSteamError steamError; steam->AbortCall(m_hWaitForResourcesCallHandle, &steamError); m_hWaitForResourcesCallHandle = STEAM_INVALID_CALL_HANDLE; } //----------------------------------------------------------------------------- // Purpose: helper for posix file handle wrapper //----------------------------------------------------------------------------- #ifdef POSIX FILE *GetFileHandle( CSteamFile *steamFile ) { if ( !steamFile ) return NULL; return (FILE *)steamFile->Handle(); } bool BWriteable( CSteamFile *steamFile ) { return steamFile && steamFile->BWriteable(); } #endif //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- void CFileSystem_Steam::FS_fclose( FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { int fd = fileno_unlocked( fp ); fflush( fp ); flock( fd, LOCK_UN ); int iLockID = m_LockedFDMap.Find( fd ); if ( iLockID != m_LockedFDMap.InvalidIndex() ) m_LockedFDMap[ iLockID ] = -1; fclose( fp ); } else { #endif TSteamError steamError; steam->CloseFile((SteamHandle_t)fp, &steamError); CheckError( (SteamHandle_t)fp, steamError ); #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- void CFileSystem_Steam::FS_fseek( FILE *fp, int64 pos, int seekType ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { fseek( fp, pos, seekType ); } else { #endif TSteamError steamError; int result; result = steam->SeekFile((SteamHandle_t)fp, (int32)pos, (ESteamSeekMethod)seekType, &steamError); CheckError((SteamHandle_t)fp, steamError); #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- long CFileSystem_Steam::FS_ftell( FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return ftell(fp); } else { #endif long steam_offset; TSteamError steamError; steam_offset = steam->TellFile((SteamHandle_t)fp, &steamError); if ( steamError.eSteamError != eSteamErrorNone ) { CheckError((SteamHandle_t)fp, steamError); return -1L; } return steam_offset; #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- int CFileSystem_Steam::FS_feof( FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return feof(fp); } else { #endif long orig_pos; // Figure out where in the file we currently are... orig_pos = FS_ftell(fp); if ( (SteamHandle_t)fp == g_pLastErrorFile && g_tLastError.eSteamError == eSteamErrorEOF ) return 1; if ( g_tLastError.eSteamError != eSteamErrorNone ) return 0; // Jump to the end... FS_fseek(fp, 0L, SEEK_END); // If we were already at the end, return true if ( orig_pos == FS_ftell(fp) ) return 1; // Otherwise, go back to the original spot and return false. FS_fseek(fp, orig_pos, SEEK_SET); return 0; #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- size_t CFileSystem_Steam::FS_fread( void *dest, size_t destSize, size_t size, FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return fread( dest, 1, size, fp ); } else { #endif TSteamError steamError; int blocksRead = steam->ReadFile(dest, 1, size, (SteamHandle_t)fp, &steamError); CheckError((SteamHandle_t)fp, steamError); return blocksRead; // steam reads in atomic blocks of "size" bytes #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- size_t CFileSystem_Steam::FS_fwrite( const void *src, size_t size, FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { #define WRITE_CHUNK (256 * 1024) if ( size > WRITE_CHUNK ) { size_t remaining = size; const byte* current = (const byte *) src; size_t total = 0; while ( remaining > 0 ) { size_t bytesToCopy = min(remaining, WRITE_CHUNK); total += fwrite(current, 1, bytesToCopy, fp); remaining -= bytesToCopy; current += bytesToCopy; } Assert( total == size ); return total; } return fwrite(src, 1, size, fp);// return number of bytes written (because we have size = 1, count = bytes, so it return bytes) } else { #endif TSteamError steamError; int result = steam->WriteFile(src, 1, size, (SteamHandle_t)fp, &steamError); CheckError((SteamHandle_t)fp, steamError); return result; #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- size_t CFileSystem_Steam::FS_vfprintf( FILE *fp, const char *fmt, va_list list ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return vfprintf(fp, fmt, list); } else { #endif int blen, plen; char *buf; if ( !fp || !fmt ) return 0; // Open the null device...used by vfprintf to determine the length of // the formatted string. FILE *nullDeviceFP = fopen("nul:", "w"); if ( !nullDeviceFP ) return 0; // Figure out how long the formatted string will be...dump formatted // string to the bit bucket. blen = vfprintf(nullDeviceFP, fmt, list); fclose(nullDeviceFP); if ( !blen ) { return 0; } // Get buffer in which to build the formatted string. buf = (char *)malloc(blen+1); if ( !buf ) { return 0; } // Build the formatted string. plen = _vsnprintf(buf, blen, fmt, list); va_end(list); if ( plen != blen ) { free(buf); return 0; } buf[ blen ] = 0; // Write out the formatted string. if ( plen != (int)FS_fwrite(buf, plen, fp) ) { free(buf); return 0; } free(buf); return plen; #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- int CFileSystem_Steam::FS_ferror( FILE *fp ) { if (fp) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return ferror(fp); } else { #endif if ((SteamHandle_t)fp != g_pLastErrorFile) { // it's asking for an error for a previous file, return no error return 0; } return ( g_tLastError.eSteamError != eSteamErrorNone ); #ifdef POSIX } #endif } return g_tLastErrorNoFile.eSteamError != eSteamErrorNone; } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- int CFileSystem_Steam::FS_fflush( FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return fflush(fp); } else { #endif TSteamError steamError; int result = steam->FlushFile((SteamHandle_t)fp, &steamError); CheckError((SteamHandle_t)fp, steamError); return result; #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- char *CFileSystem_Steam::FS_fgets( char *dest, int destSize, FILE *fp ) { #ifdef POSIX CSteamFile *steamFile = (CSteamFile *)fp; fp = GetFileHandle( steamFile ); if ( BWriteable( steamFile ) ) { return fgets(dest, destSize, fp); } else { #endif unsigned char c; int numCharRead = 0; // Read at most n chars from the file or until a newline *dest = c = '\0'; while ( (numCharRead < destSize-1) && (c != '\n') ) { // Read in the next char... if ( FS_fread(&c, 1, 1, fp) != 1 ) { if ( g_tLastError.eSteamError != eSteamErrorEOF || numCharRead == 0 ) { return NULL; // If we hit an error, return NULL. } numCharRead = destSize; // Hit EOF, no more to read, all done... } else { *dest++ = c; // add the char to the string and point to the next pos *dest = '\0'; // append NULL numCharRead++; // count the char read } } return dest; // Has a NULL termination... #ifdef POSIX } #endif } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- int CFileSystem_Steam::FS_stat( const char *path, struct _stat *buf, bool *pbLoadedFromSteamCache ) { TSteamElemInfo Info; TSteamError steamError; if ( pbLoadedFromSteamCache ) *pbLoadedFromSteamCache = false; if ( !steam ) { // The dedicated server gets here once at startup. When setting up the executable path before loading // base modules like engine.dll, the filesystem looks for zipX.zip but we haven't mounted steam content // yet so steam is null. #if !defined( DEDICATED ) AssertMsg( 0, "CFileSystem_Steam::FS_stat used with null steam interface!" ); #endif return -1; } memset(buf, 0, sizeof(struct _stat)); int returnVal= steam->Stat(path, &Info, &steamError); if ( returnVal == 0 ) { if (Info.bIsDir ) { buf->st_mode |= _S_IFDIR; buf->st_size = 0; } else { if ( pbLoadedFromSteamCache ) *pbLoadedFromSteamCache = ( Info.bIsLocal == 0 ); // Now we want to know if it's writable or not. First see if there is a local copy. struct _stat testBuf; int rt = _stat( path, &testBuf ); if ( rt == 0 ) { // Ok, there's a local copy. Now check if the copy on our HD is writable. if ( testBuf.st_mode & _S_IWRITE ) buf->st_mode |= _S_IWRITE; } buf->st_mode |= _S_IFREG; buf->st_size = Info.uSizeOrCount; } buf->st_atime = Info.lLastAccessTime; buf->st_mtime = Info.lLastModificationTime; buf->st_ctime = Info.lCreationTime; } CheckError(NULL, steamError); return returnVal; } #ifdef _WIN32 #include #endif //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- int CFileSystem_Steam::FS_chmod( const char *path, int pmode ) { return _chmod( path, pmode ); } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- HANDLE CFileSystem_Steam::FS_FindFirstFile(const char *findname, WIN32_FIND_DATA *dat) { TSteamElemInfo steamFindInfo; HANDLE hResult = INVALID_HANDLE_VALUE; SteamHandle_t steamResult; TSteamError steamError; steamResult = steam->FindFirst(findname, eSteamFindAll, &steamFindInfo, &steamError); CheckError(NULL, steamError); if ( steamResult == STEAM_INVALID_HANDLE ) { hResult = INVALID_HANDLE_VALUE; } else { hResult = (HANDLE)steamResult; strcpy(dat->cFileName, steamFindInfo.cszName); // NEED TO DEAL WITH THIS STUFF!!! FORTUNATELY HALF-LIFE DOESN'T USE ANY OF IT // AND ARCANUM USES _findfirst() etc. // // findInfo->ftLastWriteTime = steamFindInfo.lLastModificationTime; // findInfo->ftCreationTime = steamFindInfo.lCreationTime; // findInfo->ftLastAccessTime = steamFindInfo.lLastAccessTime; // findInfo->nFileSizeHigh = ; // findInfo->nFileSizeLow = ; // Determine if the found object is a directory... if ( steamFindInfo.bIsDir ) dat->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY; else dat->dwFileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY; // Determine if the found object was local or remote. // ***NOTE*** we are hijacking the FILE_ATTRIBUTE_OFFLINE bit and using it in a different // (but similar) manner than the WIN32 documentation indicates ***NOTE*** if ( steamFindInfo.bIsLocal ) dat->dwFileAttributes &= ~FILE_ATTRIBUTE_OFFLINE; else dat->dwFileAttributes |= FILE_ATTRIBUTE_OFFLINE; } return hResult; } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- bool CFileSystem_Steam::FS_FindNextFile(HANDLE handle, WIN32_FIND_DATA *dat) { TSteamElemInfo steamFindInfo; bool result; TSteamError steamError; result = (steam->FindNext((SteamHandle_t)handle, &steamFindInfo, &steamError) == 0); CheckError(NULL, steamError); if ( result ) { strcpy(dat->cFileName, steamFindInfo.cszName); if ( steamFindInfo.bIsDir ) dat->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY; else dat->dwFileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY; } return result; } //----------------------------------------------------------------------------- // Purpose: low-level filesystem wrapper //----------------------------------------------------------------------------- bool CFileSystem_Steam::FS_FindClose(HANDLE handle) { TSteamError steamError; int result = (steam->FindClose((SteamHandle_t)handle, &steamError) == 0); CheckError(NULL, steamError); return result != 0; } //----------------------------------------------------------------------------- // Purpose: files are always immediately available on disk //----------------------------------------------------------------------------- bool CFileSystem_Steam::IsFileImmediatelyAvailable(const char *pFileName) { TSteamError steamError; return (steam->IsFileImmediatelyAvailable(pFileName, &steamError) != 0); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CFileSystem_Steam::GetLocalCopy( const char *pFileName ) { // Now try to find the dll under Steam so we can do a GetLocalCopy() on it TSteamError steamError; /* #ifdef WIN32 struct _stat StatBuf; if ( FS_stat(pFileName, &StatBuf) == -1 ) { // Use the environment search path to try and find it char* pPath = getenv("PATH"); // Use the .EXE name to determine the root directory char srchPath[ MAX_PATH ]; #ifdef WIN32 HINSTANCE hInstance = ( HINSTANCE )GetModuleHandle( 0 ); if ( !GetModuleFileName( hInstance, srchPath, MAX_PATH ) ) { ::MessageBox( 0, "Failed calling GetModuleFileName", "Half-Life Steam Filesystem Error", MB_OK ); return; } #else srchPath[0] = '.'; srchPath[1] = '\0'; #endif // Get the length of the root directory the .exe is in char* pSeperator = strrchr( srchPath, CORRECT_PATH_SEPARATOR ); int nBaseLen = 0; if ( pSeperator ) { nBaseLen = pSeperator - srchPath; } // Extract each section of the path char* pStart = pPath; char* pEnd = 0; bool bSearch = true; while ( bSearch ) { #ifdef WIN32 #define PATH_SEP ";" #else #define PATH_SEP ":" #endif pEnd = strstr( pStart, PATH_SEP ); int nSize = pEnd - pStart; if ( !pEnd ) { bSearch = false; // If pEnd is NULL then nSize will be rubbish, so calculate // it sensibly. nSize = strlen( pStart ); } // Is this path even potentially in the base directory? if ( nSize > nBaseLen ) { // Create a new path (relative to the base directory) by stripping off // nBaseLen characters and therefore doing FS_stat relative to the current // directory, which should be the base directory. Assert( sizeof(srchPath) > nBaseLen + strlen(pFileName) + 2 ); nSize -= nBaseLen+1; memcpy( srchPath, pStart+nBaseLen+1, nSize ); memcpy( srchPath+nSize, pFileName, strlen(pFileName)+1 ); // If the path starts with a directory separator then we won't get a // relative path, so skip the check. if ( srchPath[0] != CORRECT_PATH_SEPARATOR ) { if ( FS_stat(srchPath, &StatBuf) == 0 ) { steam->GetLocalFileCopy(srchPath, &steamError); break; } } } pStart = pEnd+1; } } else #endif */ { // Convert _srv.so to .so... const char *pDllStringExtension = V_GetFileExtension( DLL_EXT_STRING ); const char *pModuleExtension = pDllStringExtension ? ( pDllStringExtension - 1 ) : DLL_EXT_STRING; // If we got an extension, and this filename has it, then check if it's loaded. if( pModuleExtension && V_stristr( pFileName, pModuleExtension ) ) { // We can't be copying files over the top of .so files if they're already loaded // in memory. mmap2( ... MAP_PRIVATE ... ) says "it is unspecified whether changes // made to the file after the mmap() call are visible in the mapped region." Testing // and lots of debugging (thanks Pierre-Loup!) has shown that they are, in fact, // blasted right over your nicely loaded and fixed up object. CSysModule *module = Sys_LoadModule( pFileName, SYS_NOLOAD ); if( module ) { // Sys_LoadModule( SYS_NOLOAD ) increments the refcount, so bump that back down. Sys_UnloadModule( module ); return; } } steam->GetLocalFileCopy(pFileName, &steamError); } } //----------------------------------------------------------------------------- // Purpose: Load a DLL // Input : *path //----------------------------------------------------------------------------- CSysModule * CFileSystem_Steam::LoadModule( const char *pFileName, const char *pPathID, bool bValidatedDllOnly ) { char szNewPath[ MAX_PATH ]; CBaseFileSystem::ParsePathID( pFileName, pPathID, szNewPath ); // File must end in .dll char szExtension[] = DLL_EXT_STRING; Assert( Q_strlen(pFileName) < sizeof(szNewPath) ); Q_strncpy( szNewPath, pFileName, sizeof( szNewPath ) ); if ( !Q_stristr(szNewPath, szExtension) ) { Assert( strlen(pFileName) + sizeof(szExtension) < sizeof(szNewPath) ); Q_strncat( szNewPath, szExtension, sizeof( szNewPath ), COPY_ALL_CHARACTERS ); } LogFileAccess( szNewPath ); if ( !pPathID ) { pPathID = "EXECUTABLE_PATH"; // default to the bin dir } CUtlSymbol lookup = g_PathIDTable.AddString( pPathID ); // a pathID has been specified, find the first match in the path list int c = m_SearchPaths.Count(); for (int i = 0; i < c; i++) { // pak files are not allowed to be written to... if (m_SearchPaths[i].GetPackFile()) continue; if ( m_SearchPaths[i].GetPathID() == lookup ) { char newPathName[MAX_PATH]; Q_snprintf( newPathName, sizeof(newPathName), "%s%s", m_SearchPaths[i].GetPathString(), szNewPath ); // append the path to this dir. // make sure the file exists, and is in the Steam cache if ( bValidatedDllOnly && !IsFileInSteamCache(newPathName) ) continue; // Get a local copy from Steam bool bGetLocalCopy = true; if ( m_bSDKToolMode ) bGetLocalCopy = false; #ifdef _WIN32 if ( IsDebuggerPresent() ) bGetLocalCopy = false; #endif if ( bGetLocalCopy ) GetLocalCopy( newPathName ); CSysModule *module = Sys_LoadModule( newPathName ); if ( module ) // we found the binary in one of our search paths { if ( bValidatedDllOnly && !IsFileInSteamCache2(newPathName) ) { return NULL; } else { return module; } } } } if ( bValidatedDllOnly && IsFileInSteamCache(szNewPath) ) { // couldn't load it from any of the search paths, let LoadLibrary try return Sys_LoadModule( szNewPath ); } return NULL; } void CFileSystem_Steam::ViewSteamCache(const char* szDir, bool bRecurse) { TSteamElemInfo info; TSteamError error; char szPath[MAX_PATH]; V_snprintf( szPath, sizeof(szPath),"%s%c*.*", szDir, CORRECT_PATH_SEPARATOR ); SteamHandle_t h = steam->FindFirst( szPath, eSteamFindRemoteOnly, &info, &error ); int ret = 0; if ( h != STEAM_INVALID_HANDLE ) { do { Msg( "View Steam Cache: '%s%c%s' \n", szDir, CORRECT_PATH_SEPARATOR, info.cszName ); if ( bRecurse && info.bIsDir && (0 == V_stristr( info.cszName, "." ) ) ) { V_snprintf( szPath, sizeof(szPath),"%s%c%s", szDir, CORRECT_PATH_SEPARATOR, info.cszName ); ViewSteamCache( szPath, true ); } ret = steam->FindNext( h, &info, &error ); } while( 0 == ret ); steam->FindClose( h, &error ); } } // HACK HACK - to allow IsFileInSteamCache() to use the old C exported interface extern "C" SteamHandle_t SteamFindFirst( const char *cszPattern, ESteamFindFilter eFilter, TSteamElemInfo *pFindInfo, TSteamError *pError ); extern "C" int SteamFindClose( SteamHandle_t hDirectory, TSteamError *pError ); //----------------------------------------------------------------------------- // Purpose: returns true if the file exists and is in a mounted Steam cache //----------------------------------------------------------------------------- bool CFileSystem_Steam::IsFileInSteamCache( const char *file ) { if ( !m_bContentLoaded || m_bSDKToolMode ) { return true; } // see if the file exists TSteamElemInfo info; TSteamError error; SteamHandle_t h = steam->FindFirst( file, eSteamFindRemoteOnly, &info, &error ); if ( h == STEAM_INVALID_HANDLE ) { return false; } else { steam->FindClose( h, &error ); } return true; } int CFileSystem_Steam::HintResourceNeed( const char *hintlist, int forgetEverything ) { TSteamError steamError; int result = steam->HintResourceNeed( hintlist, forgetEverything, &steamError ); CheckError(NULL, steamError); return result; }