H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
53bd92f7a8
source-engine/filesystem/filesystem_steam.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1537 lines
42 KiB
C++
Raw Blame History

//========= 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 <fcntl.h>
#ifdef LINUX
#include <sys/file.h>
#endif
#include <dlfcn.h>
#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<unsigned int> &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<unsigned int> 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 <io.h>
#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;
}
Reference in New Issue View Git Blame Copy Permalink