static bool HashFile( RageFileBasic &f, unsigned char buf_hash[20], int iHash )
{
hash_state hash;
int iRet = hash_descriptor[iHash].init( &hash );
ASSERT_M( iRet == CRYPT_OK, error_to_string(iRet) );
RString s;
while( !f.AtEOF() )
{
s.erase();
if( f.Read(s, 1024*4) == -1 )
{
LOG->Warn( "Error reading %s: %s", f.GetDisplayPath().c_str(), f.GetError().c_str() );
hash_descriptor[iHash].done( &hash, buf_hash );
return false;
}
iRet = hash_descriptor[iHash].process( &hash, (const unsigned char *) s.data(), s.size() );
ASSERT_M( iRet == CRYPT_OK, error_to_string(iRet) );
}
iRet = hash_descriptor[iHash].done( &hash, buf_hash );
ASSERT_M( iRet == CRYPT_OK, error_to_string(iRet) );
return true;
}
bool GunzipString( const RString &sIn, RString &sOut, RString &sError )
{
RageFileObjMem *mem = new RageFileObjMem;
mem->PutString( sIn );
uint32_t iCRC32;
RageFileBasic *pFile = GunzipFile( mem, sError, &iCRC32 );
if( pFile == NULL )
return false;
pFile->Read( sOut );
/* Check the CRC. */
unsigned iRet;
ASSERT( pFile->GetCRC32( &iRet ) );
SAFE_DELETE( pFile );
if( iRet != iCRC32 )
{
sError = "CRC error";
return false;
}
return true;
}
void FileReading::ReadBytes( RageFileBasic &f, void *buf, int size, RString &sError )
{
if( sError.size() != 0 )
return;
int ret = f.Read( buf, size );
if( ret == -1 )
sError = f.GetError();
else if( ret < size )
sError = "Unexpected end of file";
}
RString FileReading::ReadString( RageFileBasic &f, int size, RString &sError )
{
if( sError.size() != 0 )
return RString();
RString sBuf;
int ret = f.Read( sBuf, size );
if( ret == -1 )
sError = f.GetError();
else if( ret < size )
sError = "Unexpected end of file";
return sBuf;
}
static bool GetSha1ForFile( RageFileBasic &f, unsigned char *szHash )
{
hash_state sha1e;
sha1_init(&sha1e);
int origpos = f.Tell();
f.Seek(0);
unsigned char buf[4096];
int got = f.Read(buf, 4096);
if ( got == -1 )
return false;
while (got > 0)
{
sha1_process(&sha1e, buf, got);
got = f.Read(buf, 4096);
if ( got == -1 )
return false;
}
sha1_done(&sha1e, szHash);
f.Seek(origpos);
return true;
}
bool XmlFileUtil::LoadFromFileShowErrors( XNode &xml, RageFileBasic &f )
{
RString sError;
RString s;
if( f.Read( s ) == -1 )
sError = f.GetError();
else
Load( &xml, s, sError );
if( sError.empty() )
return true;
RString sWarning = ssprintf( "XML: LoadFromFile failed: %s", sError.c_str() );
LuaHelpers::ReportScriptError(sWarning, "XML_PARSE_ERROR");
return false;
}
bool XNode::LoadFromFile( RageFileBasic &f )
{
PARSEINFO pi;
CString s;
if( f.Read( s ) == -1 )
{
pi.error_occur = true;
pi.error_pointer = NULL;
pi.error_code = PIE_READ_ERROR;
pi.error_string = f.GetError();
goto error;
}
this->Load( s, &pi );
if( pi.error_occur )
goto error;
return true;
error:
CString sWarning = ssprintf( "XML: LoadFromFile failed: %s", pi.error_string.c_str() );
LOG->Warn( sWarning );
Dialog::OK( sWarning, "XML_PARSE_ERROR" );
return false;
}
static size_t OggRageFile_read_func( void *ptr, size_t size, size_t nmemb, void *datasource )
{
RageFileBasic *f = (RageFileBasic *) datasource;
return f->Read( ptr, size, nmemb );
}
bool ScreenArcadePatch::VerifyPatch( RageFileBasic *pFile, const CStringArray &vsKeyPaths )
{
/* get the 128-byte patch signature from the end of the file */
unsigned iFileSize = pFile->GetFileSize() - 128;
/* fZip contains the ZIP data, fSig contains the RSA signature */
RageFileBasic *fZip = new RageFileDriverSlice( pFile, 0, iFileSize );
RageFileBasic *fSig = new RageFileDriverSlice( pFile, iFileSize, 128 );
CString sPatchSig;
if( fSig->Read(sPatchSig, 128) < 128 )
{
STATE_TEXT( "Patch signature verification failed:\nunexpected end of file." );
SAFE_DELETE( fSig );
SAFE_DELETE( fZip );
return false;
}
// attempt to check the signature against all given RSA keys
bool bVerified = false;
// if no key paths worked, use this error message
CString sError = "no signature keys available";
for( unsigned i = 0; i < vsKeyPaths.size(); i++ )
{
if( !IsAFile(vsKeyPaths[i]) )
{
LOG->Warn( "RSA key \"%s\" missing.", vsKeyPaths[i].c_str() );
continue;
}
CString sRSAData;
GetFileContents( vsKeyPaths[i], sRSAData );
LOG->Trace( "Attempting to verify with %s.", vsKeyPaths[i].c_str() );
// attempt to verify, early abort if we have a match.
if( CryptHelpers::VerifyFile(*fZip, sPatchSig, sRSAData, sError) )
bVerified = true;
// ignore signature mismatches
else if( !sError.CompareNoCase("Signature mismatch") )
continue;
// if we encountered anything besides a mismatch, continue processing
break;
}
CString sMessage;
if( bVerified )
sMessage = "Patch signature verified.";
else
sMessage = ssprintf( "Patch signature verification failed:\n"
"%s\n\n" "The patch file may be corrupt.", sError.c_str() );
LOG->Trace( sMessage );
STATE_TEXT( sMessage );
SAFE_DELETE( fSig );
SAFE_DELETE( fZip );
return bVerified;
}
void ThreadedFileWorker::HandleRequest( int iRequest )
{
{
m_DeletedFilesLock.Lock();
vector<RageFileBasic *> apDeletedFiles = m_apDeletedFiles;
m_apDeletedFiles.clear();
m_DeletedFilesLock.Unlock();
for( unsigned i = 0; i < apDeletedFiles.size(); ++i )
delete apDeletedFiles[i];
}
/* We have a request. */
switch( iRequest )
{
case REQ_OPEN:
ASSERT( m_pResultFile == NULL );
ASSERT( !m_sRequestPath.empty() );
m_iResultRequest = 0;
m_pResultFile = m_pChildDriver->Open( m_sRequestPath, m_iRequestMode, m_iResultRequest );
break;
case REQ_CLOSE:
ASSERT( m_pRequestFile != NULL );
delete m_pRequestFile;
/* Clear m_pRequestFile, so RequestTimedOut doesn't double-delete. */
m_pRequestFile = NULL;
break;
case REQ_GET_FILE_SIZE:
ASSERT( m_pRequestFile != NULL );
m_iResultRequest = m_pRequestFile->GetFileSize();
break;
case REQ_SEEK:
ASSERT( m_pRequestFile != NULL );
m_iResultRequest = m_pRequestFile->Seek( m_iRequestPos );
m_sResultError = m_pRequestFile->GetError();
break;
case REQ_READ:
ASSERT( m_pRequestFile != NULL );
ASSERT( m_pResultBuffer != NULL );
m_iResultRequest = m_pRequestFile->Read( m_pResultBuffer, m_iRequestSize );
m_sResultError = m_pRequestFile->GetError();
break;
case REQ_WRITE:
ASSERT( m_pRequestFile != NULL );
ASSERT( m_pRequestBuffer != NULL );
m_iResultRequest = m_pRequestFile->Write( m_pRequestBuffer, m_iRequestSize );
m_sResultError = m_pRequestFile->GetError();
break;
case REQ_FLUSH:
ASSERT( m_pRequestFile != NULL );
m_iResultRequest = m_pRequestFile->Flush();
m_sResultError = m_pRequestFile->GetError();
break;
case REQ_COPY:
ASSERT( m_pRequestFile != NULL );
m_pResultFile = m_pRequestFile->Copy();
break;
case REQ_POPULATE_FILE_SET:
ASSERT( !m_sRequestPath.empty() );
m_ResultFileSet = FileSet();
m_pChildDriver->FDB->GetFileSetCopy( m_sRequestPath, m_ResultFileSet );
break;
case REQ_FLUSH_DIR_CACHE:
m_pChildDriver->FlushDirCache( m_sRequestPath );
break;
case REQ_REMOVE:
ASSERT( !m_sRequestPath.empty() );
m_iResultRequest = m_pChildDriver->Remove( m_sRequestPath )? 0:-1;
break;
case REQ_MOVE:
ASSERT( !m_sRequestPath.empty() );
ASSERT( !m_sRequestPath2.empty() );
m_iResultRequest = m_pChildDriver->Move( m_sRequestPath, m_sRequestPath2 ) ? 0 : -1;
break;
default:
FAIL_M( ssprintf("%i", iRequest) );
}
}
int URLRageFile_read( avcodec::URLContext *h, unsigned char *buf, int size )
{
RageFileBasic *f = (RageFileBasic *) h->priv_data;
return f->Read( buf, size );
}
