//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
// Let's make sure aserts, etc are enabled for this tool
#define RELEASEASSERTS
#include "tier0/platform.h"
#include "tier0/progressbar.h"
#include "vpklib/packedstore.h"
#include "mathlib/mathlib.h"
#include "tier1/KeyValues.h"
#include "tier2/tier2.h"
#include "tier0/memdbgon.h"
#include "tier2/fileutils.h"
#include "tier1/utldict.h"
#include "tier1/utlbuffer.h"
#ifdef VPK_ENABLE_SIGNING
#include "crypto.h"
#endif
static bool s_bBeVerbose = false;
static bool s_bMakeMultiChunk = false;
static bool s_bUseSteamPipeFriendlyBuilder = false;
static int s_iMultichunkSize = k_nVPKDefaultChunkSize / ( 1024 * 1024 );
const int k_nVPKDefaultChunkAlign = 1;
static int s_iChunkAlign = k_nVPKDefaultChunkAlign;
static CUtlString s_sPrivateKeyFile;
static CUtlString s_sPublicKeyFile;
static void PrintArgSummaryAndExit( int iReturnCode = 1 )
{
fflush(stderr);
printf(
"Usage: vpk [options] <command> <command arguments ...>\n"
" vpk [options] <directory>\n"
" vpk [options] <vpkfile>\n"
"\n"
"CREATE VPK / ADD FILES:\n"
" vpk <dirname>\n"
" Creates a pack file named <dirname>.vpk located\n"
" in the parent of the specified directory.\n"
" vpk a <vpkfile> <filename1> <filename2> ...\n"
" Add file(s).\n"
" vpk a <vpkfile> @<filename>\n"
" Add files listed in a response file.\n"
" vpk k <vpkfile> <keyvalues_filename>\n"
" Add files listed in a keyvalues control file.\n"
" vpk <directory>\n"
" Create VPK from directory structure. (This is invoked when\n"
" a directory is dragged onto the VPK tool.)\n"
"\n"
"EXTRACT FILES:\n"
" vpk x <vpkfile> <filename1> <filename2> ...\n"
" Extract file(s).\n"
" vpk <vpkfile>\n"
" Extract all files from VPK. (This is invoked when\n"
" a .VPK file is dragged onto the VPK tool.)\n"
"\n"
"DISPLAY VPK INFO:\n"
" vpk l <vpkfile>\n"
" List contents of VPK.\n"
" vpk L <vpkfile>\n"
" List contents (detailed) of VPK.\n"
#ifdef VPK_ENABLE_SIGNING
" vpk dumpsig <vpkfile>\n"
" Display signature information of VPK file\n"
"\n"
"VPK INTEGRITY / SECURITY:\n"
" vpk checkhash <vpkfile>\n"
" Check all VPK chunk MD5's and file CRC's.\n"
" vpk checksig <vpkfile>\n"
" Verify signature of specified VPK file.\n"
" Requires -k to specify key file to use.\n"
// " vpk rehash <vpkfile>\n"
// " Recalculate chunk MD5's. (Does not recalculate file CRC's)\n"
// " Can be used with -k to sign an existing unsigned VPK.\n"
"\n"
"MISC:\n"
" vpk generate_keypair <keybasename>\n"
" Generate public/private key file. Output files\n"
" will be named <keybasemame>.publickey.vdf\n"
" and <keybasemame>.privatekey.vdf\n"
" Remember: your private key should be kept private.\n"
#endif
"\n"
"\n"
"Options:\n"
" -v Verbose.\n"
" -M Produce a multi-chunk pack file\n"
" -P Use SteamPipe-friendly incremental build algorithm.\n"
" Use with 'k' command.\n"
" For optimal incremental build performance, the control file used\n"
" for the previous build should exist and be named the same as the\n"
" input control file, with '.bak' appended, and each file entry\n"
" should have an 'md5' value. The 'md5' field need not be the\n"
" actual MD5 of the file contents, it is just a unique identifier\n"
" that will be compared to determine if the file contents has changed\n"
" between builds.\n"
" This option implies -M\n" );
printf(
" -c <size>\n"
" Use specified chunk size (in MB). Default is %d.\n", k_nVPKDefaultChunkSize / ( 1024 * 1024 ) );
printf(
" -a <align>\n"
" Align files within chunk on n-byte boundary. Default is %d.\n", k_nVPKDefaultChunkAlign );
#ifdef VPK_ENABLE_SIGNING
printf(
" -K <private keyfile>\n"
" With commands 'a' or 'k': Sign VPK with specified private key.\n"
" -k <public keyfile>\n"
" With commands 'a' or 'k': Public key that will be distributed\n"
" and used by third parties to verify signatures.\n"
" With command 'checksig': Check signature using specified key file.\n" );
#endif
exit( iReturnCode );
}
bool IsRestrictedFileType( const char *pcFileName )
{
return ( V_stristr( pcFileName, ".bat" ) || V_stristr( pcFileName, ".cmd" ) || V_stristr( pcFileName, ".com" ) || V_stristr( pcFileName, ".dll" ) ||
V_stristr( pcFileName, ".exe" ) || V_stristr( pcFileName, ".msi" ) || V_stristr( pcFileName, ".rar" ) || V_stristr( pcFileName, ".reg" ) ||
V_stristr( pcFileName, ".zip" ) );
}
void ReadFile( char const *pName )
{
FileHandle_t f = g_pFullFileSystem->Open( pName, "rb" );
if ( f )
{
int fileSize = g_pFullFileSystem->Size( f );
unsigned bufSize = ((IFileSystem *)g_pFullFileSystem)->GetOptimalReadSize( f, fileSize );
void *buffer = ((IFileSystem *)g_pFullFileSystem)->AllocOptimalReadBuffer( f, bufSize );
// read into local buffer
( ((IFileSystem *)g_pFullFileSystem)->ReadEx( buffer, bufSize, fileSize, f ) != 0 );
g_pFullFileSystem->Close( f ); // close file after reading
((IFileSystem *)g_pFullFileSystem)->FreeOptimalReadBuffer( buffer );
}
}
void BenchMark( CUtlVector<char *> &names )
{
for( int i = 0; i < names.Count(); i++ )
ReadFile( names[i] );
}
static void AddFileToPack( CPackedStore &mypack, char const *pSrcName, int nPreloadSize = 0, char const *pDestName = NULL )
{
// Check to make sure that no restricted file types are being added to the VPK
if ( IsRestrictedFileType( pSrcName ) )
{
printf( "Ignoring %s: unsupported file type.\n", pSrcName );
return;
}
// !FIXME! Make sure they didn't request alignment, because we aren't doing it.
if ( s_iChunkAlign != 1 )
Error( "-a is only supported with -P" );
if ( (! pDestName ) || ( pDestName[0] == 0 ) )
{
pDestName = pSrcName;
}
CRequiredInputFile f( pSrcName );
int fileSize = f.Size();
uint8 *pData = new uint8[fileSize];
f.MustRead( pData, fileSize );
ePackedStoreAddResultCode rslt = mypack.AddFile( pDestName, Min( fileSize, nPreloadSize ), pData, fileSize, s_bMakeMultiChunk );
if ( rslt == EPADD_ERROR )
{
Error( "Error adding %s\n", pSrcName );
}
if ( s_bBeVerbose )
{
switch( rslt )
{
case EPADD_ADDSAMEFILE:
{
if ( s_bBeVerbose )
{
printf( "File %s is already in the archive with the same contents\n", pSrcName );
}
}
break;
case EPADD_UPDATEFILE:
{
if ( s_bBeVerbose )
{
printf( "File %s is already in the archive and has been updated\n", pSrcName );
}
}
break;
case EPADD_NEWFILE:
{
if ( s_bBeVerbose )
{
printf( "Add new file %s\n", pSrcName );
}
}
break;
}
}
delete[] pData;
}
#ifdef VPK_ENABLE_SIGNING
static void LoadKeyFile( const char *pszFilename, const char *pszTag, CUtlVector<uint8> &outBytes )
{
KeyValuesAD kv("key");
if ( !kv->LoadFromFile( g_pFullFileSystem, pszFilename ) )
Error( "Failed to load key file %s", pszFilename );
const char *pszType = kv->GetString( "type", NULL );
if ( pszType == NULL )
Error( "Key file %s is missing 'type'", pszFilename );
if ( V_stricmp( pszType, "rsa" ) != 0 )
Error( "Key type '%s' is not supported", pszType );
const char *pszEncodedBytes = kv->GetString( pszTag, NULL );
if ( pszEncodedBytes == NULL )
Error( "Key file is missing '%s'", pszTag );
uint8 rgubDecodedData[k_nRSAKeyLenMax*2];
uint cubDecodedData = Q_ARRAYSIZE( rgubDecodedData );
if( !CCrypto::HexDecode( pszEncodedBytes, rgubDecodedData, &cubDecodedData ) || cubDecodedData <= 0 )
Error( "Key file contains invalid '%s' value", pszTag );
outBytes.SetSize( cubDecodedData );
V_memcpy( outBytes.Base(), rgubDecodedData, cubDecodedData );
}
#endif
static void CheckLoadKeyFilesForSigning( CPackedStore &mypack )
{
// Not signing?
if ( s_sPrivateKeyFile.IsEmpty() && s_sPublicKeyFile.IsEmpty() )
return;
// Signatures only supported if creating multi-chunk file
if ( !s_bMakeMultiChunk )
{
Error( "Multichunk not specified. Only multi-chunk VPK's support signatures.\n" );
}
// If they specified one, they must specify both
if ( s_sPrivateKeyFile.IsEmpty() || s_sPublicKeyFile.IsEmpty() )
Error( "Must specify both public and private key files in order to sign VPK" );
#ifdef VPK_ENABLE_SIGNING
CUtlVector<uint8> bytesPrivateKey;
LoadKeyFile( s_sPrivateKeyFile, "rsa_private_key", bytesPrivateKey );
printf( "Loaded private key file %s\n", s_sPrivateKeyFile.String() );
CUtlVector<uint8> bytesPublicKey;
LoadKeyFile( s_sPublicKeyFile, "rsa_public_key", bytesPublicKey );
printf( "Loaded public key file %s\n", s_sPublicKeyFile.String() );
mypack.SetKeysForSigning( bytesPrivateKey.Count(), bytesPrivateKey.Base(), bytesPublicKey.Count(), bytesPublicKey.Base() );
#else
Error( "VPK signing not implemented" );
#endif
}
class VPKBuilder
{
public:
VPKBuilder( CPackedStore &packfile );
~VPKBuilder();
void BuildFromInputKeys()
{
if ( s_bUseSteamPipeFriendlyBuilder )
BuildSteamPipeFriendlyFromInputKeys();
else
BuildOldSchoolFromInputKeys();
}
void SetInputKeys( KeyValues *pInputKeys, const char *pszControlFilename );
void LoadInputKeys( const char *pszControlFilename );
private:
CPackedStore &m_packfile;
struct VPKBuildFile_t
{
VPKBuildFile_t()
{
m_pOld = NULL;
m_pNew = NULL;
m_iOldSortIndex = -1;
m_iNewSortIndex = -1;
m_md5Old.Zero();
m_md5New.Zero();
m_pOldKey = NULL;
m_pNewKey = NULL;
}
VPKContentFileInfo_t *m_pOld;
VPKContentFileInfo_t *m_pNew;
int m_iOldSortIndex;
int m_iNewSortIndex;
KeyValues *m_pOldKey;
KeyValues *m_pNewKey;
MD5Value_t m_md5Old;
MD5Value_t m_md5New;
CUtlString m_sNameOnDisk;
};
static int CompareBuildFileByOldPhysicalPosition( VPKBuildFile_t* const *pa, VPKBuildFile_t* const *pb )
{
const VPKContentFileInfo_t *a = (*pa)->m_pOld;
const VPKContentFileInfo_t *b = (*pb)->m_pOld;
if ( a->m_idxChunk < b->m_idxChunk ) return -1;
if ( a->m_idxChunk > b->m_idxChunk ) return +1;
if ( a->m_iOffsetInChunk < b->m_iOffsetInChunk ) return -1;
if ( a->m_iOffsetInChunk > b->m_iOffsetInChunk ) return +1;
return 0;
}
CUtlString m_sControlFilename;
/// List of all files, past and present, keyed by the name in the VPK.
CUtlDict<VPKBuildFile_t> m_dictFiles;
/// All files as they existed in the old VPK. (Empty if we are building from scratch.)
CUtlVector<VPKContentFileInfo_t> m_vecOldFiles;
/// List of all new files.
CUtlVector<VPKContentFileInfo_t *> m_vecNewFiles;
/// List of new files, in the requested order, only counting those
/// that will actually go into a chunk
CUtlVector<VPKContentFileInfo_t *> m_vecNewFilesInChunkOrder;
/// List of old files that have some content in a chunk file,
/// in the order they currently appear
CUtlVector<VPKBuildFile_t *> m_vecOldFilesInChunkOrder;
int64 m_iNewTotalFileSize;
int64 m_iNewTotalFileSizeInChunkFiles;
/// A group of files that are contiguous in the logical linear
/// file list.
struct VPKInputFileRange_t
{
int m_iFirstInputFile; // index of first input file in the chunk
int m_iLastInputFile; // index of last input file in the chunk
int m_iChunkFilenameIndex;
bool m_bKeepExistingFile;
int64 m_nTotalSizeInChunkFile;
int FileCount() const
{
int iResult = m_iLastInputFile - m_iFirstInputFile + 1;
Assert( iResult > 0 );
return iResult;
}
};
KeyValues *m_pInputKeys;
KeyValues *m_pOldInputKeys;
CUtlLinkedList<VPKInputFileRange_t,int> m_llFileRanges;
CUtlVector<int> m_vecRangeForChunk;
CUtlString m_sReasonToForceWriteDirFile;
void BuildOldSchoolFromInputKeys();
void BuildSteamPipeFriendlyFromInputKeys();
void SanityCheckRanges();
void SplitRangeAt( int iFirstInputFile );
void AddRange( VPKInputFileRange_t range );
void MapRangeToChunk( int idxRange, int iChunkFilenameIndex, bool bKeepExistingFile );
void CalculateRangeTotalSizeInChunkFile( VPKInputFileRange_t &range ) const;
void UnmapAllRangesForChangedChunks();
void CoaleseAllUnmappedRanges();
void PrintRangeDebug();
void MapAllRangesToChunks();
};
VPKBuilder::VPKBuilder( CPackedStore &packfile )
: m_packfile( packfile )
{
CUtlVector<uint8> savePublicKey;
savePublicKey = m_packfile.GetSignaturePublicKey();
CheckLoadKeyFilesForSigning( m_packfile );
if ( savePublicKey.Count() != m_packfile.GetSignaturePublicKey().Count()
|| V_memcmp( savePublicKey.Base(), m_packfile.GetSignaturePublicKey().Base(), savePublicKey.Count() ) != 0 )
{
if ( m_packfile.GetSignaturePublicKey().Count() == 0 )
{
m_sReasonToForceWriteDirFile = "Signature removed.";
}
else if ( savePublicKey.Count() == 0 )
{
m_sReasonToForceWriteDirFile = "Signature added.";
}
else
{
m_sReasonToForceWriteDirFile = "Public key used for signing changed.";
}
}
m_pInputKeys = NULL;
m_pOldInputKeys = NULL;
// !FIXME! Check if public key is changing so we know if we need to re-sign!
}
VPKBuilder::~VPKBuilder()
{
if ( m_pInputKeys )
m_pInputKeys->deleteThis();
if ( m_pOldInputKeys )
m_pOldInputKeys->deleteThis();
}
void VPKBuilder::BuildOldSchoolFromInputKeys()
{
// Just add them in order
FOR_EACH_VEC( m_vecNewFiles, i )
{
VPKContentFileInfo_t *f = m_vecNewFiles[ i ];
int idxInDict = m_dictFiles.Find( f->m_sName.String() );
Assert( idxInDict >= 0 );
VPKBuildFile_t *bf = &m_dictFiles[ idxInDict ];
Assert( bf->m_pNew == f );
AddFileToPack( m_packfile, bf->m_sNameOnDisk, f->m_iPreloadSize, f->m_sName );
}
if ( s_bBeVerbose )
printf( "Hashing metadata.\n" );
m_packfile.HashMetadata();
if ( s_bBeVerbose )
printf( "Writing directory file.\n" );
m_packfile.Write();
}
void VPKBuilder::BuildSteamPipeFriendlyFromInputKeys()
{
// Get list of all files already in the VPK
m_packfile.GetFileList( NULL, m_vecOldFiles );
FOR_EACH_VEC( m_vecOldFiles, i )
{
VPKContentFileInfo_t *f = &m_vecOldFiles[i];
char szNameInVPK[ MAX_PATH ];
V_strcpy_safe( szNameInVPK, f->m_sName );
V_FixSlashes( szNameInVPK, '\\' ); // always use Windows slashes in VPK
f->m_sName = szNameInVPK;
// Add it to the dictionary
int idxInDict = m_dictFiles.Find( szNameInVPK );
if ( idxInDict == m_dictFiles.InvalidIndex() )
idxInDict = m_dictFiles.Insert( szNameInVPK );
// Each logical file should only be in a VPK file once
if ( m_dictFiles[ idxInDict ].m_pOld )
Error( "File '%s' is listed in VPK directory multiple times?! Cannot build incrementally.\n", szNameInVPK );
m_dictFiles[ idxInDict ].m_pOld = f;
}
// See if we should build incrementally
bool bIncremental = ( m_vecOldFiles.Count() > 0 ) && !m_sControlFilename.IsEmpty();
if ( bIncremental )
{
printf( "Building incrementally in SteamPipe-friendly manner.\n" );
printf( "Existing pack file contains %d files\n", m_vecOldFiles.Count() );
CUtlString sControlFilenameBak = m_sControlFilename;
sControlFilenameBak += ".bak";
m_pOldInputKeys = new KeyValues( "oldkeys" );
if ( m_pOldInputKeys->LoadFromFile( g_pFullFileSystem, sControlFilenameBak ) )
{
printf( "Loaded %s OK\n", sControlFilenameBak.String() );
printf( "Fetching MD5's and checking that it matches the pack file\n" );
for ( KeyValues *i = m_pOldInputKeys; i; i = i->GetNextKey() )
{
const char *pszNameOnDisk = i->GetString( "srcpath", i->GetName() );
char szNameInVPK[ MAX_PATH ];
V_strcpy_safe( szNameInVPK, i->GetString( "destpath", "" ) );
if ( szNameInVPK[0] == '\0' )
Error( "File '%s' is missing 'destpath' in old KeyValues control file", pszNameOnDisk );
V_FixSlashes( szNameInVPK, '\\' ); // always use Windows slashes in VPK
// Locate file build entry. We should have one in the VPK
int idxInDict = m_dictFiles.Find( szNameInVPK );
if ( idxInDict == m_dictFiles.InvalidIndex() || m_dictFiles[ idxInDict ].m_pOld == NULL )
Error( "File '%s' in old KeyValues control file not found in pack file.\nThat control file was probably not used to build the pack file\n", szNameInVPK );
VPKBuildFile_t &bf = m_dictFiles[ idxInDict ];
if ( bf.m_pOldKey )
Error( "File '%s' appears multiple times in old KeyValues control file.\nThat control file was probably not used to build the pack file\n", szNameInVPK );
bf.m_pOldKey = i;
// Fetch preload size from old KV, clamp to actual file size.
int iPreloadSizeFromControlFile = i->GetInt( "preloadsize", 0 );
iPreloadSizeFromControlFile = Min( iPreloadSizeFromControlFile, (int)bf.m_pOld->m_iTotalSize );
if ( iPreloadSizeFromControlFile != (int)bf.m_pOld->m_iPreloadSize )
Error( "File '%s' preload size mismatch in old KeyValues control file and pack file.\nThat control file was probably not used to build the pack file\n", szNameInVPK );
const char *pszMD5 = i->GetString( "md5", "" );
if ( *pszMD5 )
{
if ( V_strlen( pszMD5 ) != MD5_DIGEST_LENGTH*2 )
Error( "File '%s' has invalid MD5 '%s'", pszNameOnDisk, pszMD5 );
V_hextobinary( pszMD5, MD5_DIGEST_LENGTH*2, bf.m_md5Old.bits, MD5_DIGEST_LENGTH );
}
else
{
printf( "WARNING: Old control file entry '%s' does not have an MD5; we will have to compare file contents for this file.\n", pszNameOnDisk );
}
}
// Now many sure every file in the pack was found in the control file. If not, then
// they probably don't match and we should not trust the MD5's.
FOR_EACH_DICT_FAST( m_dictFiles, idxInDict )
{
VPKBuildFile_t &bf = m_dictFiles[ idxInDict ];
if ( bf.m_pOld && bf.m_pOldKey == NULL )
Error( "File '%s' is in pack but not in old control file %s.\n"
"That control file was probably not used to build the pack file", bf.m_pOld->m_sName.String(), sControlFilenameBak.String() );
}
printf( "%s appears to match VPK file.\nUsing MD5s for incremental building\n", sControlFilenameBak.String() );
}
else
{
printf( "WARNING: %s not present; incremental building will be slow.\n", sControlFilenameBak.String() );
printf( " For best results, provide the control file previously used for building.\n" );
m_pOldInputKeys->deleteThis();
m_pOldInputKeys = NULL;
}
}
else
{
printf( "Building pack file from scratch.\n" );
}
// Dictionary is now complete. Gather up list of files in order
// sorted by where they were in the old pack set
FOR_EACH_DICT_FAST( m_dictFiles, i )
{
VPKBuildFile_t *f = &m_dictFiles[i];
if ( f->m_pOld && f->m_pOld->GetSizeInChunkFile() > 0 )
m_vecOldFilesInChunkOrder.AddToTail( f );
}
m_vecOldFilesInChunkOrder.Sort( CompareBuildFileByOldPhysicalPosition );
FOR_EACH_VEC( m_vecOldFilesInChunkOrder, i )
{
m_vecOldFilesInChunkOrder[i]->m_iOldSortIndex = i;
}
// How many chunks are currently in the VPK. (Might be zero)
int nOldChunkCount = 0;
if ( m_vecOldFilesInChunkOrder.Count() > 0 )
nOldChunkCount = m_vecOldFilesInChunkOrder[ m_vecOldFilesInChunkOrder.Count()-1 ]->m_pOld->m_idxChunk + 1;
// For each chunk filename (_nnn.vpk), remember which block
// of files maps will be used to create it.
// None of the chunks have been assigned a block of files yet
for ( int i = 0 ; i < nOldChunkCount ; ++i )
m_vecRangeForChunk.AddToTail( m_llFileRanges.InvalidIndex() );
// Start by putting all the files into a single range
// with no corresponding chunk
VPKInputFileRange_t rangeAllFiles;
rangeAllFiles.m_iChunkFilenameIndex = -1;
rangeAllFiles.m_iFirstInputFile = 0;
rangeAllFiles.m_iLastInputFile = m_vecNewFilesInChunkOrder.Count()-1;
rangeAllFiles.m_bKeepExistingFile = false;
CalculateRangeTotalSizeInChunkFile( rangeAllFiles );
m_llFileRanges.AddToTail( rangeAllFiles );
SanityCheckRanges();
// Building incrementally?
if ( bIncremental && nOldChunkCount > 0 )
{
printf( "Scanning for unchanged chunk files...\n" );
// For each existing chunk, see if it's totally modified or not.
// In our case, since SteamPipe rewrites an entire file from scratch
// anytime a single byte changes, we don't care how much a chunk
// file changes, we only need to detect if we can carry it forward
// exactly as is or not.
int idxOldFile = 0;
while ( idxOldFile < m_vecOldFilesInChunkOrder.Count() )
{
// What chunk are we in?
VPKBuildFile_t const &firstFile = *m_vecOldFilesInChunkOrder[ idxOldFile ];
int idxChunk = firstFile.m_pOld->m_idxChunk;
char szDataFilename[ MAX_PATH ];
m_packfile.GetDataFileName( szDataFilename, sizeof(szDataFilename), idxChunk );
const char *pszShortDataFilename = V_GetFileName( szDataFilename );
int idxInChunk = 0;
CUtlVector<int> vecFilesToCompareContents;
// Scan to the end of files in this chunk.
CUtlString sReasonCannotReuse;
while ( idxOldFile < m_vecOldFilesInChunkOrder.Count() )
{
VPKBuildFile_t const &f = *m_vecOldFilesInChunkOrder[ idxOldFile ];
Assert( f.m_iOldSortIndex == idxOldFile );
// End of this old chunk?
VPKContentFileInfo_t const *pOld = f.m_pOld;
Assert( pOld );
if ( idxChunk != pOld->m_idxChunk )
break;
Assert( f.m_iOldSortIndex == firstFile.m_iOldSortIndex + idxInChunk );
if ( sReasonCannotReuse.IsEmpty() )
{
VPKContentFileInfo_t const *pNew = f.m_pNew;
int iExpectedSortIndex = firstFile.m_iNewSortIndex + idxInChunk;
const char *pszFilename = pOld->m_sName.String();
if ( pNew == NULL )
{
sReasonCannotReuse.Format( "File '%s' was removed.", pszFilename );
}
else if ( pOld->m_iTotalSize != pNew->m_iTotalSize )
{
sReasonCannotReuse.Format( "File '%s' changed size.", pszFilename );
}
else if ( pOld->m_iPreloadSize != pNew->m_iPreloadSize )
{
sReasonCannotReuse.Format( "File '%s' changed preload size.", pszFilename );
}
else if ( f.m_iNewSortIndex != iExpectedSortIndex )
{
// Files reordered in some way. Try to give an appropriate message
if ( f.m_iNewSortIndex > iExpectedSortIndex && iExpectedSortIndex < m_vecNewFilesInChunkOrder.Count() )
{
VPKContentFileInfo_t const *pInsertedFile = m_vecNewFilesInChunkOrder[ iExpectedSortIndex ];
const char *pszInsertedFilename = pInsertedFile->m_sName.String();
int idxDictInserted = m_dictFiles.Find( pszInsertedFilename );
Assert( idxDictInserted != m_dictFiles.InvalidIndex() );
if ( m_dictFiles[idxDictInserted].m_pOld == NULL )
sReasonCannotReuse.Format( "File '%s' was inserted\n", pszInsertedFilename );
else
sReasonCannotReuse.Format( "Chunk reordered. '%s' listed where '%s' used to be.", pszInsertedFilename, pszFilename );
}
else
{
sReasonCannotReuse.Format( "Chunk was reordered. File '%s' was moved.", pszFilename );
}
}
else if ( f.m_md5Old.IsZero() || f.m_md5New.IsZero() )
{
vecFilesToCompareContents.AddToTail( idxOldFile );
}
else if ( f.m_md5Old != f.m_md5New )
{
sReasonCannotReuse.Format( "File '%s' changed. (Based on MD5s in control file.)", pszFilename );
}
}
++idxOldFile;
++idxInChunk;
}
// Check if we need to actually compare any file contents
if ( sReasonCannotReuse.IsEmpty() && vecFilesToCompareContents.Count() > 0 )
{
// We'll have to actually load the source file
// and compare the CRC
printf( "%s: Checking for differences using file CRCs...\n", pszShortDataFilename );
FOR_EACH_VEC( vecFilesToCompareContents, i )
{
VPKBuildFile_t const &f = *m_vecOldFilesInChunkOrder[ vecFilesToCompareContents[i] ];
Assert( f.m_pOld );
// Load the input file
CUtlBuffer buf;
if ( !g_pFullFileSystem->ReadFile( f.m_sNameOnDisk, NULL, buf )
|| buf.TellPut() != (int)f.m_pOld->m_iTotalSize )
{
Error( "Error reading %s", f.m_sNameOnDisk.String() );
}
// Calculate the CRC
uint32 crc = CRC32_ProcessSingleBuffer( buf.Base(), f.m_pOld->m_iTotalSize );
// Mismatch?
if ( crc != f.m_pOld->m_crc )
{
sReasonCannotReuse.Format( "File '%s' changed. (CRCs differs from %s.)", f.m_pOld->m_sName.String(), f.m_sNameOnDisk.String() );
break;
}
}
}
// Can we take this file as is?
if ( sReasonCannotReuse.IsEmpty() )
{
printf( "%s could be reused.\n", pszShortDataFilename );
// Map the chunk
VPKInputFileRange_t chunkRange;
chunkRange.m_iChunkFilenameIndex = idxChunk;
chunkRange.m_iFirstInputFile = firstFile.m_iNewSortIndex;
chunkRange.m_iLastInputFile = firstFile.m_iNewSortIndex + idxInChunk - 1;
chunkRange.m_bKeepExistingFile = true;
AddRange( chunkRange );
}
else
{
printf( "%s cannot be reused. %s\n", pszShortDataFilename, sReasonCannotReuse.String() );
}
}
}
// Take file ranges that are not mapped to a chunk, and map them.
MapAllRangesToChunks();
int nNewChunkCount = m_llFileRanges.Count();
printf( "Pack file will contain %d chunk files\n", nNewChunkCount );
// Remove files from directory that have been deleted
int iFilesRemoved = 0;
FOR_EACH_DICT_FAST( m_dictFiles, i )
{
const VPKBuildFile_t &bf = m_dictFiles[i];
if ( bf.m_pOld && !bf.m_pNew )
m_packfile.RemoveFileFromDirectory( bf.m_pOld->m_sName.String() );
}
printf( "Removing %d files from the directory\n", iFilesRemoved );
// Make sure ranges are cool
SanityCheckRanges();
// Grow chunk -> range table as necessary
while ( m_vecRangeForChunk.Count() < nNewChunkCount )
m_vecRangeForChunk.AddToTail( m_llFileRanges.InvalidIndex() );
// OK, at this point, we're ready to assign any ranges that have
// not yet been assigned a range an appropriate range index
int idxChunk = 0;
int iChunksToKeep = 0;
int iFilesToKeep = 0;
int64 iChunkSizeToKeep = 0;
int iChunksToWrite = 0;
int iFilesToWrite = 0;
int64 iChunkSizeToWrite = 0;
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
if ( r.m_iChunkFilenameIndex >= 0 )
{
Assert( r.m_bKeepExistingFile );
iChunksToKeep += 1;
iChunkSizeToKeep += r.m_nTotalSizeInChunkFile;
iFilesToKeep += r.FileCount();
continue;
}
// Range has not been assigned a chunk.
// Locate the next chunk index
// that has not been assigned to a range
while ( m_vecRangeForChunk[idxChunk] != m_llFileRanges.InvalidIndex() )
{
++idxChunk;
Assert( idxChunk < nNewChunkCount );
}
// Map the range
MapRangeToChunk( idxRange, idxChunk, false );
++idxChunk;
Assert( idxChunk <= nNewChunkCount );
iChunksToWrite += 1;
iChunkSizeToWrite += r.m_nTotalSizeInChunkFile;
iFilesToWrite += r.FileCount();
}
// Now scan chunks in order, and write and chunks that changed.
bool bNeedToWriteDir = false;
for ( int idxChunk = 0 ; idxChunk < nNewChunkCount ; ++idxChunk )
{
int idxRange = m_vecRangeForChunk[ idxChunk ];
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
char szDataFilename[ MAX_PATH ];
m_packfile.GetDataFileName( szDataFilename, sizeof(szDataFilename), idxChunk );
const char *pszShortDataFilename = V_GetFileName( szDataFilename );
// Dump info about the chunk and what we're doing with it
printf(
"%s %s (%d files, %lld bytes)\n",
r.m_bKeepExistingFile ? "Keeping" : "Writing",
pszShortDataFilename,
r.FileCount(),
(long long)r.m_nTotalSizeInChunkFile
);
if ( s_bBeVerbose )
{
printf( " First file: %s\n", m_vecNewFilesInChunkOrder[ r.m_iFirstInputFile ]->m_sName.String() );
printf( " Last file : %s\n", m_vecNewFilesInChunkOrder[ r.m_iLastInputFile ]->m_sName.String() );
}
// Retaining the existing file?
if ( r.m_bKeepExistingFile )
{
// Mark the input files in this chunk as having been assigned to this chunk.
for ( int idxFile = r.m_iFirstInputFile ; idxFile <= r.m_iLastInputFile ; ++idxFile )
{
VPKContentFileInfo_t *f = m_vecNewFilesInChunkOrder[ idxFile ];
f->m_idxChunk = idxChunk;
}
continue;
}
// Create the output file.
FileHandle_t fChunkWrite = g_pFullFileSystem->Open( szDataFilename, "wb" );
if ( !fChunkWrite )
Error( "Can't create %s\n", szDataFilename );
// Scan input files in order.
uint32 iOffsetInChunk = 0;
for ( int idxFile = r.m_iFirstInputFile ; idxFile <= r.m_iLastInputFile ; ++idxFile )
{
VPKContentFileInfo_t *f = m_vecNewFilesInChunkOrder[ idxFile ];
int idxInDict = m_dictFiles.Find( f->m_sName.String() );
Assert( idxInDict >= 0 );
VPKBuildFile_t *bf = &m_dictFiles[ idxInDict ];
Assert( bf->m_pNew == f );
// Load the input file
CUtlBuffer buf;
if ( !g_pFullFileSystem->ReadFile( bf->m_sNameOnDisk, NULL, buf )
|| buf.TellPut() != (int)f->m_iTotalSize )
{
Error( "Error reading %s", bf->m_sNameOnDisk.String() );
}
Assert( iOffsetInChunk == g_pFullFileSystem->Tell( fChunkWrite ) );
// Calculate the CRC
f->m_crc = CRC32_ProcessSingleBuffer( buf.Base(), f->m_iTotalSize );
// Finish filling in all of the header
f->m_iOffsetInChunk = iOffsetInChunk;
f->m_idxChunk = idxChunk;
f->m_pPreloadData = buf.Base();
// Update the directory
m_packfile.AddFileToDirectory( *f );
// Write the data
int nBytesToWrite = f->GetSizeInChunkFile();
int nBytesWritten = g_pFullFileSystem->Write( (byte*)buf.Base() + f->m_iPreloadSize, nBytesToWrite, fChunkWrite );
if ( nBytesWritten != nBytesToWrite )
Error( "Error writing %s", szDataFilename );
iOffsetInChunk += nBytesToWrite;
Assert( iOffsetInChunk == g_pFullFileSystem->Tell( fChunkWrite ) );
// Align
Assert( s_iChunkAlign > 0 );
while ( iOffsetInChunk % s_iChunkAlign )
{
unsigned char zero = 0;
g_pFullFileSystem->Write( &zero, 1, fChunkWrite );
++iOffsetInChunk;
}
// Let's clear this pointer just for grins
f->m_pPreloadData = NULL;
}
g_pFullFileSystem->Close( fChunkWrite );
// While we know the data is sitting in the OS file cache,
// let's immediately re-calc the chunk hashes
m_packfile.HashChunkFile( idxChunk );
// We'll need to re-save the directory
bNeedToWriteDir = true;
}
// Delete any extra chunks that aren't needed anymore
for ( int iChunkToDelete = nNewChunkCount ; iChunkToDelete < nOldChunkCount ; ++iChunkToDelete )
{
char szDataFilename[ MAX_PATH ];
m_packfile.GetDataFileName( szDataFilename, sizeof(szDataFilename), iChunkToDelete );
printf( "Deleting %s.\n", szDataFilename );
g_pFullFileSystem->RemoveFile( szDataFilename );
if ( g_pFullFileSystem->FileExists( szDataFilename ) )
Error( "Failed to delete %s\n", szDataFilename );
m_packfile.DiscardChunkHashes( iChunkToDelete );
// We'll need to re-save the directory
bNeedToWriteDir = true;
}
if ( s_bBeVerbose )
{
printf( "Chunk files: %12s%12s\n", "Retained", "Written" );
printf( " Pack file chunks: %12d%12d\n", iChunksToKeep, iChunksToWrite );
printf( " Data files: %12d%12d\n", iFilesToKeep, iFilesToWrite );
printf( " Bytes in chunk: %12lld%12lld\n", (long long)iChunkSizeToKeep, (long long)iChunkSizeToWrite );
}
// Finally, scan for any files that need to go in the directory,
// but don't have any data in a chunk. (Zero byte files, or all
// data is in the preload area.)
FOR_EACH_DICT( m_dictFiles, idxInDict )
{
VPKBuildFile_t *bf = &m_dictFiles[ idxInDict ];
VPKContentFileInfo_t *pNew = bf->m_pNew;
if ( pNew == NULL || pNew->m_idxChunk >= 0 )
continue;
Assert( pNew->GetSizeInChunkFile() == 0 );
// Check if the file has changed and we need to update the directory
VPKContentFileInfo_t *pOld = bf->m_pOld;
int iNeedToUpdateFile = 1;
if ( pOld )
{
if ( pOld->m_iTotalSize != pNew->m_iTotalSize
|| pOld->m_iPreloadSize != pNew->m_iPreloadSize )
{
iNeedToUpdateFile = 1;
}
else if ( !bf->m_md5Old.IsZero() && !bf->m_md5New.IsZero() )
{
// We have hashes and can make the determination purely from the hashes
if ( bf->m_md5Old == bf->m_md5New )
iNeedToUpdateFile = 0;
else
iNeedToUpdateFile = 1;
}
else
{
// Not able to make a determination without loading the file
iNeedToUpdateFile = -1;
}
}
// Might we need to update the file?
if ( iNeedToUpdateFile == 0 )
{
// We were able to determine that the files match, and
// we know that there's no need to load the input file or
// check CRC's
continue;
}
// If we get here, we might need to update the header.
// Load the file
CUtlBuffer buf;
if ( !g_pFullFileSystem->ReadFile( bf->m_sNameOnDisk, NULL, buf )
|| buf.TellPut() != (int)pNew->m_iTotalSize )
{
Error( "Error reading %s", bf->m_sNameOnDisk.String() );
}
// Calculate the CRC
pNew->m_crc = CRC32_ProcessSingleBuffer( buf.Base(), pNew->m_iTotalSize );
// Compare CRC's
if ( iNeedToUpdateFile < 0 )
{
Assert( pOld );
if ( pOld->m_crc == pNew->m_crc )
continue;
}
// We need to add the file to the header
if ( pNew->m_iPreloadSize > 0 )
pNew->m_pPreloadData = buf.Base();
else
Assert( pNew->m_iTotalSize == 0 );
// Write the directory entry. This will make a copy of any preload data
m_packfile.AddFileToDirectory( *pNew );
// Let's clear this pointer just for grins
pNew->m_pPreloadData = NULL;
// We'll need to re-save the directory
bNeedToWriteDir = true;
}
// Nothing changed?
if ( !bNeedToWriteDir )
{
if ( m_sReasonToForceWriteDirFile.IsEmpty() )
{
printf( "Nothing changed; not writing directory file.\n" );
return;
}
printf( "VPK contents not changed, but directory needs to be resaved. %s.\n", m_sReasonToForceWriteDirFile.String() );
}
if ( s_bBeVerbose )
printf( "Hashing metadata.\n" );
m_packfile.HashMetadata();
if ( s_bBeVerbose )
printf( "Writing directory file.\n" );
m_packfile.Write();
}
void VPKBuilder::LoadInputKeys( const char *pszControlFilename )
{
KeyValues *pInputKeys = new KeyValues( "packkeys" );
if ( !pInputKeys->LoadFromFile( g_pFullFileSystem, pszControlFilename ) )
Error( "Failed to load %s", pszControlFilename );
SetInputKeys( pInputKeys, pszControlFilename );
}
void VPKBuilder::SetInputKeys( KeyValues *pInputKeys, const char *pszControlFilename )
{
m_pInputKeys = pInputKeys;
m_sControlFilename = pszControlFilename;
m_iNewTotalFileSize = 0;
m_iNewTotalFileSizeInChunkFiles = 0;
int iSortIndex = 0;
for ( KeyValues *i = m_pInputKeys; i; i = i->GetNextKey() )
{
const char *pszNameOnDisk = i->GetString( "srcpath", i->GetName() );
char szNameInVPK[ MAX_PATH ];
V_strcpy_safe( szNameInVPK, i->GetString( "destpath", "" ) );
if ( szNameInVPK[0] == '\0' )
Error( "File '%s' is missing 'destpath' in KeyValues control file", pszNameOnDisk );
V_FixSlashes( szNameInVPK, '\\' ); // always use Windows slashes in VPK
// Fail if passed an absolute path.
if ( szNameInVPK[0] == '\\' )
Error( "destpath '%s' is an absolute path; only relative paths should be used", szNameInVPK );
// Check to make sure that no restricted file types are being added to the VPK.
if ( IsRestrictedFileType( szNameInVPK ) )
{
printf( "WARNING: Control file lists '%s'. We cannot put that type of file in the pack.\n", szNameInVPK );
continue;
}
// Make sure we have a dictionary entry
int idxInDict = m_dictFiles.Find( szNameInVPK );
if ( idxInDict == m_dictFiles.InvalidIndex() )
idxInDict = m_dictFiles.Insert( szNameInVPK );
VPKBuildFile_t &bf = m_dictFiles[ idxInDict ];
if ( !bf.m_sNameOnDisk.IsEmpty() || bf.m_pNew || bf.m_iNewSortIndex >= 0 )
Error( "destpath '%s' in VPK appears multiple times in the KV control file.\n (Source files '%s' and '%s')", szNameInVPK, bf.m_sNameOnDisk.String(), pszNameOnDisk );
bf.m_sNameOnDisk = pszNameOnDisk;
VPKContentFileInfo_t *f = new VPKContentFileInfo_t;
f->m_sName = szNameInVPK;
f->m_iTotalSize = g_pFullFileSystem->Size( pszNameOnDisk );
f->m_iPreloadSize = Min( (uint32)i->GetInt( "preloadsize", 0 ), f->m_iTotalSize );
const char *pszMD5 = i->GetString( "md5", "" );
if ( *pszMD5 )
{
if ( V_strlen( pszMD5 ) != MD5_DIGEST_LENGTH*2 )
Error( "File '%s' has invalid MD5 '%s'", pszNameOnDisk, pszMD5 );
V_hextobinary( pszMD5, MD5_DIGEST_LENGTH*2, bf.m_md5New.bits, MD5_DIGEST_LENGTH );
}
m_vecNewFiles.AddToTail( f );
bf.m_pNew = f;
if ( f->GetSizeInChunkFile() > 0 )
{
bf.m_iNewSortIndex = iSortIndex++;
m_vecNewFilesInChunkOrder.AddToTail( f );
}
m_iNewTotalFileSize += f->m_iTotalSize;
m_iNewTotalFileSizeInChunkFiles += f->GetSizeInChunkFile();
}
printf( "Control file lists %d files\n", m_vecNewFiles.Count() );
printf( " Total file size . . . . : %12lld bytes\n", (long long)m_iNewTotalFileSize );
printf( " Size in preload area . : %12lld bytes\n", (long long)(m_iNewTotalFileSize - m_iNewTotalFileSizeInChunkFiles ) );
printf( " Size in data area . . . : %12lld bytes\n", (long long)m_iNewTotalFileSizeInChunkFiles );
}
void VPKBuilder::MapAllRangesToChunks()
{
//PrintRangeDebug();
// If a range is NOT at least as big as one chunk file, then we will have to merge it
// with an adjacent range --- that is, we will need to unmap an adjacent range.
// So the first step will be to identify which of the currently mapped ranges
// to unmap in order to get rid of any ranges that cannot get mapped to a chunk.
// We might have a choice in the matter, and each range that we unmap means
// another file that will have to be rewritten. So the goal here is to minimize
// the number/size of chunks that we unmap and force to rewrite.
//
// The current state of affairs should be that all mapped regions correspond to chunk
// files that do not need to be rewritten, and there are no two unmapped chunk files in a row.
int64 iSizeTooSmallForAChunk = (int64)m_packfile.GetWriteChunkSize() * 95 / 100;
for (;;)
{
for (;;)
{
// Make sure the problem of small chunks can be solved by unmapping
// a mapped chunk
UnmapAllRangesForChangedChunks();
CoaleseAllUnmappedRanges();
// Find a mapped region next to a region that's too
// small to get its own chunk. If there are multiple,
// we'll choose the "best" one to coalesce according to
// a greedy algorithm.
int idxBestRangeToUnmap = m_llFileRanges.InvalidIndex();
int iBestScore = -1;
int64 iBestSize = -1;
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
if ( r.m_iChunkFilenameIndex < 0 )
continue;
// Check if neighbors exist and are too small
// for their own chunk. Calculate score heuristic
// based on how good of a candidate we are to
// be the one to get combined with our neighbors
int iScore = 0;
int idxPrev = m_llFileRanges.Previous( idxRange );
if ( idxPrev != m_llFileRanges.InvalidIndex() )
{
VPKInputFileRange_t &p = m_llFileRanges[ idxPrev ];
if ( p.m_iChunkFilenameIndex < 0 && p.m_nTotalSizeInChunkFile < iSizeTooSmallForAChunk )
{
++iScore;
if ( idxPrev == m_llFileRanges.Head() )
iScore += 3; // Nobody else could fix this, so we need to do it
}
}
int idxNext = m_llFileRanges.Next( idxRange );
if ( idxNext != m_llFileRanges.InvalidIndex() )
{
VPKInputFileRange_t &n = m_llFileRanges[ idxNext ];
if ( n.m_iChunkFilenameIndex < 0 && n.m_nTotalSizeInChunkFile < iSizeTooSmallForAChunk )
{
++iScore;
if ( idxNext == m_llFileRanges.Tail() )
iScore += 3; // Nobody else could fix this, so we need to do it
}
}
// Do we have any reason at all to absorb our neighbors?
if ( iScore == 0 )
continue;
// Check if we're the best one so far to absorb our neighbor
if ( iScore < iBestScore )
continue;
// When choosing which of two neighbors should absorb a new gap, add it to the smaller one.
// (That will be less to rewrite and also keep the chunk size at a more desirable level.)
if ( iScore == iBestScore && r.m_nTotalSizeInChunkFile > iBestSize )
continue;
// We're the new best
iBestScore = iScore;
idxBestRangeToUnmap = idxRange;
iBestSize = r.m_nTotalSizeInChunkFile;
}
// Did we find a range that needed to absorb its neighbor?
if ( idxBestRangeToUnmap == m_llFileRanges.InvalidIndex() )
break;
// Unmap it
MapRangeToChunk( idxBestRangeToUnmap, -1, false );
// We'll coalesce the unmapped region with its neighbor(s) and
// start the whole process over
}
// OK, at this point, if there were any ranges that were too small to hold their
// own chunks, then we should have merged them. (Unless there is exactly one range.)
// The next step is to split up ranges that are too large for a single chunk.
SanityCheckRanges();
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t *r = &m_llFileRanges[ idxRange ];
// Check how many chunks this
int iChunks = r->m_nTotalSizeInChunkFile / m_packfile.GetWriteChunkSize();
if ( iChunks <= 1 )
continue;
// If they consistently build with the same chunk size, then
// we should only hit this for ranges that are going to be rewritten.
// However, if this chunk is already fine as it, let's leave it alone.
// There's no reason to split it.
if ( r->m_iChunkFilenameIndex >= 0 )
{
Assert( r->m_bKeepExistingFile );
printf( "Chunk %d is currently bigger than desired chunk size of %d bytes, but we're not splitting it because the contents have not changed.\n", r->m_iChunkFilenameIndex, m_packfile.GetWriteChunkSize() );
continue;
}
// Try to split off approximately 1 N/th of the data into this chunk.
// Note that if we have big files inside, we might not have enough granularity to
// do exactly what they desire and could get caught in a bad state
int64 iDesiredSize = r->m_nTotalSizeInChunkFile / iChunks;
Assert( iDesiredSize >= m_packfile.GetWriteChunkSize() );
int iNewLastInputFile = r->m_iFirstInputFile;
int64 iNewSize = m_vecNewFilesInChunkOrder[ iNewLastInputFile ]->GetSizeInChunkFile();
while ( iNewSize < iDesiredSize && iNewLastInputFile < r->m_iLastInputFile )
{
++iNewLastInputFile;
iNewSize += m_vecNewFilesInChunkOrder[ iNewLastInputFile ]->GetSizeInChunkFile();
}
// Do the split
int iSaveFirstInputFile = r->m_iFirstInputFile;
SplitRangeAt( iNewLastInputFile+1 );
r = &m_llFileRanges[ idxRange ]; // ranges may have moved in memory!
// Here we make an assumption that SplitRangeAt will keep range idxRange
// modified and link the new range AFTER this range. Verify that assumption.
Assert( r->m_iFirstInputFile == iSaveFirstInputFile );
Assert( r->m_iLastInputFile == iNewLastInputFile );
Assert( r->m_nTotalSizeInChunkFile == iNewSize );
// We've got this range approximately to the desired size.
// The next range should be approximately (N-1)/N as big as the original
// size of this range, and if N>2, then it wil need to be split, too
}
// OK, all ranges should now be the appropriate size, and should
// map to exactly one chunk. We just haven't assigned the chunk
// numbers yet. The important thing to realize is that the numbers
// are essentially arbitrary, and if we're going to rewrite a file,
// it doesn't matter if data moves from one chunk to another with
// a totally different number. However....leaving a gap is probably
// a bad idea. We don't know what assumptions existing tools make,
// and this could be confusing and look like a missing file. So
// if we have N chunks, we will always number them 0...N-1.
int nNewChunkCount = m_llFileRanges.Count();
// Check if the number of chunks has been reduced, and a chunk file
// that we previously thought we would be able to retain has
// a file index that won't exist any more, then let's unmap those ranges
// and start over.
bool bNeedToStartOver = false;
for ( int i = m_vecRangeForChunk.Count()-1 ; i >= nNewChunkCount ; --i )
{
int idxRange = m_vecRangeForChunk[i];
if ( idxRange == m_llFileRanges.InvalidIndex() )
continue;
Assert( m_llFileRanges[ idxRange ].m_iChunkFilenameIndex == i );
Assert( m_llFileRanges[ idxRange ].m_bKeepExistingFile );
MapRangeToChunk( idxRange, -1, false );
bNeedToStartOver = true;
}
if ( !bNeedToStartOver )
break;
// We unmapped a chunk because the chunk file is going to
// get deleted. Start all over!
}
}
void VPKBuilder::UnmapAllRangesForChangedChunks()
{
SanityCheckRanges();
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
// If range was assigned a chunk, but the chunk file will have to be rewitten,
// then unmap it
if ( r.m_iChunkFilenameIndex >= 0 && !r.m_bKeepExistingFile )
MapRangeToChunk( idxRange, -1, false );
}
SanityCheckRanges();
}
void VPKBuilder::CoaleseAllUnmappedRanges()
{
SanityCheckRanges();
int idxRange = m_llFileRanges.Head();
for (;;)
{
int idxNext = m_llFileRanges.Next( idxRange );
if ( idxNext == m_llFileRanges.InvalidIndex() )
break;
// Grab shortcuts
VPKInputFileRange_t &ri = m_llFileRanges[ idxRange ];
VPKInputFileRange_t &rn = m_llFileRanges[ idxNext ];
// Both chunks unassigned?
if ( ri.m_iChunkFilenameIndex < 0 && rn.m_iChunkFilenameIndex < 0 )
{
// Merge current with next
ri.m_iLastInputFile = rn.m_iLastInputFile;
CalculateRangeTotalSizeInChunkFile( ri );
m_llFileRanges.Remove( idxNext );
// List should be valid at this point
SanityCheckRanges();
}
else
{
// Keep it, advance to the next one
idxRange = idxNext;
}
}
}
void VPKBuilder::CalculateRangeTotalSizeInChunkFile( VPKInputFileRange_t &range ) const
{
range.m_nTotalSizeInChunkFile = 0;
for ( int i = range.m_iFirstInputFile ; i <= range.m_iLastInputFile ; ++i )
{
range.m_nTotalSizeInChunkFile += m_vecNewFilesInChunkOrder[ i ]->GetSizeInChunkFile();
}
}
void VPKBuilder::SanityCheckRanges()
{
int iFileIndex = 0;
int64 iTotalSizeInChunks = 0;
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
Assert( r.m_iFirstInputFile == iFileIndex );
Assert( r.m_iLastInputFile >= r.m_iFirstInputFile );
iFileIndex = r.m_iLastInputFile + 1;
iTotalSizeInChunks += r.m_nTotalSizeInChunkFile;
}
Assert( iFileIndex == m_vecNewFilesInChunkOrder.Count() );
Assert( iTotalSizeInChunks == m_iNewTotalFileSizeInChunkFiles );
}
void VPKBuilder::PrintRangeDebug()
{
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t &r = m_llFileRanges[ idxRange ];
printf( "Range handle %d:\n", idxRange );
printf( " File range %d .. %d\n", r.m_iFirstInputFile, r.m_iLastInputFile );
printf( " Chunk %d%s\n", r.m_iChunkFilenameIndex, r.m_bKeepExistingFile ? " (keep existing file)" : "" );
printf( " Size %lld\n", (long long)r.m_nTotalSizeInChunkFile );
}
}
void VPKBuilder::AddRange( VPKInputFileRange_t range )
{
// Sanity check that ranges are in a valid order
SanityCheckRanges();
// Split up the range(s) we overlap so that we will match exactly one range
SplitRangeAt( range.m_iFirstInputFile );
SplitRangeAt( range.m_iLastInputFile+1 );
// Locate the range
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t *p = &m_llFileRanges[ idxRange ];
if ( p->m_iLastInputFile < range.m_iFirstInputFile )
continue;
// Range should now match exactly
Assert( p->m_iFirstInputFile == range.m_iFirstInputFile );
Assert( p->m_iLastInputFile == range.m_iLastInputFile );
// Assign it to the proper chunk
MapRangeToChunk( idxRange, range.m_iChunkFilenameIndex, range.m_bKeepExistingFile );
return;
}
// We should have found it
Assert( false );
}
void VPKBuilder::SplitRangeAt( int iFirstInputFile )
{
// Sanity check that ranges are in a valid order
SanityCheckRanges();
// Now Locate any ranges that we overlap, and split them as appropriate
FOR_EACH_LL( m_llFileRanges, idxRange )
{
VPKInputFileRange_t *p = &m_llFileRanges[ idxRange ];
// No need to make any changes if split already exists at requested location
if ( p->m_iFirstInputFile == iFirstInputFile || p->m_iLastInputFile+1 == iFirstInputFile)
return;
// Found the range to split?
Assert( p->m_iFirstInputFile < iFirstInputFile );
if ( p->m_iLastInputFile >= iFirstInputFile )
{
// We should only be spliting up unallocated space
Assert( p->m_iChunkFilenameIndex < 0 );
VPKInputFileRange_t newRange = *p;
p->m_iLastInputFile = iFirstInputFile-1;
newRange.m_iFirstInputFile = iFirstInputFile;
CalculateRangeTotalSizeInChunkFile( newRange );
CalculateRangeTotalSizeInChunkFile( *p );
m_llFileRanges.InsertAfter( idxRange, newRange );
// Make sure we didn't screw anything up
SanityCheckRanges();
return;
}
}
// We should have found something
Assert( false );
}
void VPKBuilder::MapRangeToChunk( int idxRange, int iChunkFilenameIndex, bool bKeepExistingFile )
{
VPKInputFileRange_t *p = &m_llFileRanges[ idxRange ];
// If range was already mapped to a chunk, unmap it.
if ( p->m_iChunkFilenameIndex >= 0 )
{
Assert( m_vecRangeForChunk[ p->m_iChunkFilenameIndex ] == idxRange );
m_vecRangeForChunk[ p->m_iChunkFilenameIndex ] = m_llFileRanges.InvalidIndex();
p->m_iChunkFilenameIndex = -1;
p->m_bKeepExistingFile = false;
}
// Map range to a chunk?
if ( iChunkFilenameIndex >= 0 )
{
Assert( m_vecRangeForChunk[ iChunkFilenameIndex ] == m_llFileRanges.InvalidIndex() );
p->m_iChunkFilenameIndex = iChunkFilenameIndex;
p->m_bKeepExistingFile = bKeepExistingFile;
m_vecRangeForChunk[ iChunkFilenameIndex ] = idxRange;
}
else
{
Assert( !bKeepExistingFile );
}
}
#ifdef VPK_ENABLE_SIGNING
void GenerateKeyPair( const char *pszBaseKeyName )
{
printf( "Generating RSA public/private keypair...\n" );
//
// This code pretty much copied from vsign.cpp
//
uint8 rgubPublicKey[k_nRSAKeyLenMax]={0};
uint cubPublicKey = Q_ARRAYSIZE( rgubPublicKey );
uint8 rgubPrivateKey[k_nRSAKeyLenMax]={0};
uint cubPrivateKey = Q_ARRAYSIZE( rgubPrivateKey );
if( !CCrypto::RSAGenerateKeys( rgubPublicKey, &cubPublicKey, rgubPrivateKey, &cubPrivateKey ) )
{
Error( "Failed to generate RSA keypair.\n" );
}
char rgchEncodedPublicKey[k_nRSAKeyLenMax*4];
uint cubEncodedPublicKey = Q_ARRAYSIZE( rgchEncodedPublicKey );
if( !CCrypto::HexEncode( rgubPublicKey, cubPublicKey, rgchEncodedPublicKey, cubEncodedPublicKey ) )
{
Error( "Failed to encode public key.\n" );
}
// Don't encrypt
// uint8 rgubEncryptedPrivateKey[Q_ARRAYSIZE( rgubPrivateKey )*2];
// uint cubEncryptedPrivateKey = Q_ARRAYSIZE( rgubEncryptedPrivateKey );
//
// if( !CCrypto::SymmetricEncrypt( rgubPrivateKey, cubPrivateKey, rgubEncryptedPrivateKey, &cubEncryptedPrivateKey, (uint8 *)rgchPassphrase, k_nSymmetricKeyLen ) )
// {
// printf( "ERROR! Failed to encrypt private key.\n" );
// return false;
// }
char rgchEncodedEncryptedPrivateKey[Q_ARRAYSIZE( rgubPrivateKey )*8];
if( !CCrypto::HexEncode( rgubPrivateKey, cubPrivateKey, rgchEncodedEncryptedPrivateKey, Q_ARRAYSIZE(rgchEncodedEncryptedPrivateKey) ) )
{
Error( "Failed to encode private key.\n" );
}
// Good Lord. Use fopen, because it will work without any surprising crap or hidden limitations.
// I just wasted an hour trying to get CUtlBuffer and our filesystem to print a block of text to a file.
// Save public keyfile
{
CUtlString sPubFilename( pszBaseKeyName );
sPubFilename += ".publickey.vdf";
FILE *f = fopen( sPubFilename, "wt" );
if ( f == NULL )
Error( "Cannot create %s.", sPubFilename.String() );
// Write public keyfile
fprintf( f,
"// Public key file. You can publish this key file and share it with the world.\n"
"// It can be used by third parties to verify any signatures made with the corresponding private key.\n"
"public_key\n"
"{\n"
"\ttype \"rsa\"\n"
"\trsa_public_key \"%s\"\n"
"}\n",
rgchEncodedPublicKey );
fclose(f);
printf( " Saved %s\n", sPubFilename.String() );
}
// Save private keyfile
{
CUtlString sPrivFilename( pszBaseKeyName );
sPrivFilename += ".privatekey.vdf";
FILE *f = fopen( sPrivFilename, "wt" );
if ( f == NULL )
Error( "Cannot create %s.", sPrivFilename.String() );
fprintf( f,
"// Private key file.\n"
"// This key can be used to sign files. Third parties can verify your signature by using your public key.\n"
"//\n"
"// THIS KEY SHOULD BE KEPT SECRET\n"
"//\n"
"// You should share your public key freely, but anyone who has your private key will be able to impersonate you.\n"
"private_key\n"
"{\n"
"\ttype \"rsa\"\n"
"\trsa_private_key \"%s\"\n"
"\n"
"\t// Note: the private key is stored in plaintext. It is not encrypted or protected by a password.\n"
"\t// Anyone who obtains this key can use it to sign files.\n"
"\tprivate_key_encrypted 0\n"
"\n"
"\t// The public key that corresponds to this private key. The public keyfile you can share with others is\n"
"\t// saved in another file, but the key data is duplicated here to help you confirm which public key matches\n"
"\t// with this private key.\n"
"\tpublic_key\n"
"\t{\n"
"\t\ttype \"rsa\"\n"
"\t\trsa_public_key \"%s\"\n"
"\t}\n"
"}\n",
rgchEncodedEncryptedPrivateKey, rgchEncodedPublicKey );
fclose(f);
printf( " Saved %s\n", sPrivFilename.String() );
}
printf( "\n" );
printf( "REMEMBER: Your private key should be kept secret. Don't share it!\n" );
}
static void CheckSignature( const char *pszFilename )
{
char szActualFileName[MAX_PATH];
CPackedStore pack( pszFilename, szActualFileName, g_pFullFileSystem );
// Make sure they didn't make a mistake
CUtlVector<uint8> bytesPublicKey;
if ( s_sPublicKeyFile.IsEmpty() )
{
if ( !s_sPrivateKeyFile.IsEmpty() )
Error( "Private keys are not used to verify signatures. Did you mean to use -k instead?" );
printf(
"Checking signature using public key in VPK.\n"
"\n"
"NOTE: This just confirms that the VPK has a valid signature,\n"
" not that signature was made by any particular party. Use -k\n"
" and provide a public key in order to verify that a file was\n"
" signed by a particular trusted party.\n" );
}
else
{
LoadKeyFile( s_sPublicKeyFile, "rsa_public_key", bytesPublicKey );
printf( "Loaded public key file %s\n", s_sPublicKeyFile.String() );
}
printf( "\n" );
fflush( stdout );
CPackedStore::ESignatureCheckResult result = pack.CheckSignature( bytesPublicKey.Count(), bytesPublicKey.Base() );
switch (result )
{
default:
case CPackedStore::eSignatureCheckResult_Failed:
fprintf( stderr, "ERROR: FAILED\n" );
fflush( stderr );
printf( "IO error or other generic failure." );
exit(-1);
case CPackedStore::eSignatureCheckResult_NotSigned:
fprintf( stderr, "ERROR: NOT SIGNED\n" );
fflush( stderr );
printf( "The VPK does not contain a signature." );
exit(1);
case CPackedStore::eSignatureCheckResult_WrongKey:
fprintf( stderr, "ERROR: KEY MISMATCH\n" );
fflush( stderr );
printf(
"The public key provided does not match the public\n"
"key contained in the VPK file. The VPK was not\n"
"signed using the private key corresponding to your\n"
"public key.\n" );
exit(2);
case CPackedStore::eSignatureCheckResult_InvalidSignature:
fprintf( stderr, "ERROR: INVALID SIGNATURE\n" );
fflush( stderr );
printf( "The VPK contains a signature, but it isn't valid." );
exit(3);
case CPackedStore::eSignatureCheckResult_ValidSignature:
printf( "SUCCESS\n" );
if ( s_sPublicKeyFile.IsEmpty() )
{
printf( "VPK contains a valid signature." );
}
else
{
printf( "VPK signature validated using the specified public key." );
}
exit(0);
}
}
static void CheckHashes( const char *pszFilename )
{
char szActualFileName[MAX_PATH];
CPackedStore pack( pszFilename, szActualFileName, g_pFullFileSystem );
char szChunkFilename[ 256 ];
printf( "Checking cache line hashes:\n" );
CUtlSortVector<ChunkHashFraction_t, ChunkHashFractionLess_t > &vecHashes = pack.AccessPackFileHashes();
CPackedStoreFileHandle handle = pack.GetHandleForHashingFiles();
handle.m_nFileNumber = -1;
int nCheckedFractionsOK = 0;
int nTotalCheckedCacheLines = 0;
int nTotalErrorCacheLines = 0;
FOR_EACH_VEC( vecHashes, idx )
{
ChunkHashFraction_t frac = vecHashes[idx];
if ( idx == 0 || frac.m_nPackFileNumber != handle.m_nFileNumber )
{
if ( nCheckedFractionsOK > 0 )
printf( "OK. (%d caches lines)\n", nCheckedFractionsOK );
handle.m_nFileNumber = frac.m_nPackFileNumber;
pack.GetPackFileName( handle, szChunkFilename, sizeof(szChunkFilename) );
printf(" %s: ", szChunkFilename );
fflush( stdout );
nCheckedFractionsOK = 0;
}
FileHash_t filehash;
// VPKHandle.m_nFileNumber;
// nFileFraction;
int64 fileSize = 0;
// if we have never hashed this before - do it now
pack.HashEntirePackFile( handle, fileSize, frac.m_nFileFraction, frac.m_cbChunkLen, filehash );
++nTotalCheckedCacheLines;
if ( filehash.m_cbFileLen != frac.m_cbChunkLen )
{
if ( nCheckedFractionsOK >= 0 )
{
printf( "\n" );
fflush( stdout );
nCheckedFractionsOK = -1;
}
fprintf( stderr, " @%d: size mismatch. Stored: %d Computed: %d\n", frac.m_nFileFraction, frac.m_cbChunkLen, filehash.m_cbFileLen );
fflush( stderr );
++nTotalErrorCacheLines;
}
else if ( filehash.m_md5contents != frac.m_md5contents )
{
if ( nCheckedFractionsOK >= 0 )
{
printf( "\n" );
fflush( stdout );
nCheckedFractionsOK = -1;
}
char szCalculated[ MD5_DIGEST_LENGTH*2 + 4 ];
char szExpected[ MD5_DIGEST_LENGTH*2 + 4 ];
V_binarytohex( filehash.m_md5contents.bits, MD5_DIGEST_LENGTH, szCalculated, sizeof(szCalculated) );
V_binarytohex( frac.m_md5contents.bits, MD5_DIGEST_LENGTH, szExpected, sizeof(szExpected) );
fprintf( stderr, " @%d: hash mismatch: Got %s, expected %s.\n", frac.m_nFileFraction, szCalculated, szExpected );
fflush( stderr );
++nTotalErrorCacheLines;
}
else
{
if ( nCheckedFractionsOK >= 0 )
++nCheckedFractionsOK;
}
}
if ( nCheckedFractionsOK > 0 )
printf( "OK. (%d caches lines)\n", nCheckedFractionsOK );
if ( nTotalErrorCacheLines == 0 )
{
printf( "All %d cache lines hashes matched OK\n", nTotalCheckedCacheLines );
exit(0);
}
fprintf( stderr, "%d cache lines failed validation out of %d checked \n", nTotalErrorCacheLines, nTotalCheckedCacheLines );
exit(1);
}
static void PrintBinaryBlob( const CUtlVector<uint8> &blob )
{
const int kRowLen = 32;
for ( int i = 0 ; i < blob.Count() ; i += kRowLen )
{
int iEnd = Min( i+kRowLen, blob.Count() );
const char *pszSep = " ";
for ( int j = i ; j < iEnd ; ++j )
{
printf( "%s%02X", pszSep, blob[j] );
pszSep = "";
}
printf( "\n" );
}
}
static void DumpSignatureInfo( const char *pszFilename )
{
char szActualFileName[MAX_PATH];
CPackedStore pack( pszFilename, szActualFileName, g_pFullFileSystem );
if ( pack.GetSignature().Count() == 0 )
{
printf( "VPK is not signed\n" );
return;
}
printf( "Public key:\n" );
PrintBinaryBlob( pack.GetSignaturePublicKey() );
printf( "Signature:\n" );
PrintBinaryBlob( pack.GetSignature() );
}
#endif
void BuildRecursiveFileList( const char *pcDirName, CUtlStringList &fileList )
{
char szDirWildcard[MAX_PATH];
FileFindHandle_t findHandle;
V_snprintf( szDirWildcard, sizeof( szDirWildcard ), "%s%c%s", pcDirName, CORRECT_PATH_SEPARATOR, "*.*" );
char const *pcResult = g_pFullFileSystem->FindFirst( szDirWildcard, &findHandle );
if ( pcResult )
{
do
{
char szFullResultPath[MAX_PATH];
if ( '.' == pcResult[0] )
{
pcResult = g_pFullFileSystem->FindNext( findHandle );
continue;
}
// Make a full path to the result
V_snprintf( szFullResultPath, sizeof( szFullResultPath ), "%s%c%s", pcDirName, CORRECT_PATH_SEPARATOR, pcResult );
if ( g_pFullFileSystem->IsDirectory( szFullResultPath ) )
{
// Recurse
BuildRecursiveFileList( szFullResultPath, fileList );
}
else
{
// Add file to the file list
fileList.CopyAndAddToTail( szFullResultPath );
}
pcResult = g_pFullFileSystem->FindNext( findHandle );
} while ( pcResult );
g_pFullFileSystem->FindClose( findHandle );
}
}
static void DroppedVpk( const char *pszVpkFilename )
{
char szActualFileName[MAX_PATH];
CPackedStore mypack( pszVpkFilename, szActualFileName, g_pFullFileSystem );
CUtlStringList fileNames;
char szVPKParentDir[MAX_PATH];
V_strncpy( szVPKParentDir, pszVpkFilename, sizeof( szVPKParentDir ) );
V_SetExtension( szVPKParentDir, "", sizeof( szVPKParentDir ) );
mypack.GetFileList( fileNames, false, true );
for( int i = 0 ; i < fileNames.Count(); i++ )
{
char szDestFilePath[MAX_PATH];
CPackedStoreFileHandle pData = mypack.OpenFile( fileNames[i] );
V_snprintf( szDestFilePath, sizeof( szDestFilePath ), "%s%c%s", szVPKParentDir, CORRECT_PATH_SEPARATOR, fileNames[i] );
if ( pData )
{
char szParentDirectory[MAX_PATH];
V_ExtractFilePath( szDestFilePath, szParentDirectory, sizeof( szParentDirectory ) );
V_FixSlashes( szParentDirectory );
if ( !g_pFullFileSystem->IsDirectory( szParentDirectory ) )
{
g_pFullFileSystem->CreateDirHierarchy( szParentDirectory );
}
printf( "extracting %s\n", fileNames[i] );
COutputFile outF( szDestFilePath );
if ( outF.IsOk() )
{
int nBytes = pData.m_nFileSize;
while( nBytes )
{
char cpBuf[65535];
int nReadSize = MIN( sizeof( cpBuf ), nBytes );
mypack.ReadData( pData, cpBuf, nReadSize );
outF.Write( cpBuf, nReadSize );
nBytes -= nReadSize;
}
outF.Close();
}
}
}
}
static void DroppedDirectory( const char *pszDirectoryArg )
{
// Strip trailing slash, if any
char szDirectory[MAX_PATH];
V_strcpy_safe( szDirectory, pszDirectoryArg );
V_StripTrailingSlash( szDirectory );
char szVPKPath[MAX_PATH];
// Construct path to VPK
V_snprintf( szVPKPath, sizeof( szVPKPath ), "%s.vpk", szDirectory );
// Delete any existing one at that location
if ( g_pFullFileSystem->FileExists( szVPKPath ) )
{
if ( g_pFullFileSystem->IsFileWritable( szVPKPath ) )
{
g_pFullFileSystem->RemoveFile( szVPKPath );
}
else
{
fprintf( stderr, "Cannot delete file: %s\n", szVPKPath );
exit(1);
}
}
// Make the VPK
char szActualFileName[MAX_PATH];
CPackedStore mypack( szVPKPath, szActualFileName, g_pFullFileSystem, true );
mypack.SetWriteChunkSize( s_iMultichunkSize * 1024*1024 );
// !KLUDGE! Create keyvalues object, since that's what the builder uses
printf( "Finding files and creating temporary control file...\n" );
CUtlStringList fileList;
BuildRecursiveFileList( szDirectory, fileList );
KeyValues *pInputKeys = new KeyValues("packkeys");
const int nBaseDirLength = V_strlen( szDirectory );
for( int i = 0 ; i < fileList.Count(); i++ )
{
// .... Ug O(n^2)
KeyValues *pFileKey = pInputKeys->CreateNewKey();
const char *pszFilename = fileList[i];
pFileKey->SetString( "srcpath", pszFilename );
const char *pszDestPath = pszFilename + nBaseDirLength;
if ( *pszDestPath == '/' || *pszDestPath == '\\' )
++pszDestPath;
pFileKey->SetString( "destpath", pszDestPath );
}
VPKBuilder builder( mypack );
builder.SetInputKeys( pInputKeys->GetFirstSubKey(), "" );
builder.BuildFromInputKeys();
}
int main(int argc, char **argv)
{
InitCommandLineProgram( argc, argv );
int nCurArg = 1;
//
// Check for standard usage syntax
//
while ( ( nCurArg < argc ) && ( argv[nCurArg][0] == '-' ) )
{
switch( argv[nCurArg][1] )
{
case '?': // args
{
PrintArgSummaryAndExit( 0 ); // return success in this case.
}
break;
case 'M':
{
s_bMakeMultiChunk = true;
}
break;
case 'P':
{
s_bUseSteamPipeFriendlyBuilder = true;
s_bMakeMultiChunk = true;
}
break;
case 'v': // verbose
{
s_bBeVerbose = true;
}
break;
case 'a':
{
nCurArg++;
if ( nCurArg >= argc )
{
fprintf( stderr, "Expected argument after %s\n", argv[nCurArg-1] );
exit( 1 );
}
s_iChunkAlign = V_atoi( argv[nCurArg] );
if ( s_iChunkAlign <= 0 || s_iChunkAlign > 32*1024 )
{
fprintf( stderr, "Invalid alignment value %s\n", argv[nCurArg] );
exit( 1 );
}
}
break;
case 'c':
{
nCurArg++;
if ( nCurArg >= argc )
{
fprintf( stderr, "Expected argument after %s\n", argv[nCurArg-1] );
exit( 1 );
}
s_iMultichunkSize = V_atoi( argv[nCurArg] );
if ( s_iMultichunkSize <= 0 || s_iMultichunkSize > 1*1024 )
{
fprintf( stderr, "Invalid chunk size %s\n", argv[nCurArg] );
exit( 1 );
}
}
break;
case 'K':
nCurArg++;
if ( nCurArg >= argc )
{
fprintf( stderr, "Expected argument after %s\n", argv[nCurArg-1] );
exit( 1 );
}
s_sPrivateKeyFile = argv[nCurArg];
break;
case 'k':
nCurArg++;
if ( nCurArg >= argc )
{
fprintf( stderr, "Expected argument after %s\n", argv[nCurArg-1] );
exit( 1 );
}
s_sPublicKeyFile = argv[nCurArg];
break;
default:
Error( "Unrecognized option '%s'\n", argv[nCurArg] );
}
nCurArg++;
}
argc -= ( nCurArg - 1 );
argv += ( nCurArg - 1 );
if ( argc < 2 )
{
Error( "No command specified. Try 'vpk -?' for info.\n" );
}
const char *pszCommand = argv[1];
if ( V_stricmp( pszCommand, "l" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
// list a file
char szActualFileName[MAX_PATH];
CPackedStore mypack( argv[2], szActualFileName, g_pFullFileSystem );
CUtlStringList fileNames;
mypack.GetFileList( fileNames, pszCommand[0] == 'L', true );
for( int i = 0 ; i < fileNames.Count(); i++ )
{
printf( "%s\n", fileNames[i] );
}
}
else if ( V_strcmp( pszCommand, "a" ) == 0 )
{
if ( argc < 3 )
{
fprintf( stderr, "Not enough arguments for '%s' command.\n", pszCommand );
exit(1);
}
char szActualFileName[MAX_PATH];
CPackedStore mypack( argv[2], szActualFileName, g_pFullFileSystem, true );
CheckLoadKeyFilesForSigning( mypack );
for( int i = 3; i < argc; i++ )
{
if ( argv[i][0] == '@' )
{
// response file?
CRequiredInputTextFile hResponseFile( argv[i] + 1 );
CUtlStringList fileList;
hResponseFile.ReadLines( fileList );
for( int i = 0 ; i < fileList.Count(); i++ )
{
AddFileToPack( mypack, fileList[i] );
}
}
else
{
AddFileToPack( mypack, argv[i] );
}
}
mypack.HashEverything();
mypack.Write();
}
else if ( V_strcmp( pszCommand, "k" ) == 0 )
{
if ( argc != 4 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
char szActualFileName[MAX_PATH];
CPackedStore mypack( argv[2], szActualFileName, g_pFullFileSystem, true );
mypack.SetWriteChunkSize( s_iMultichunkSize * 1024*1024 );
VPKBuilder builder( mypack );
builder.LoadInputKeys( argv[3] );
builder.BuildFromInputKeys();
}
else if ( V_strcmp( pszCommand, "x" ) == 0 )
{
if ( argc < 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
// extract a file
char szActualFileName[MAX_PATH];
CPackedStore mypack( argv[2], szActualFileName, g_pFullFileSystem );
for( int i = 3; i < argc; i++ )
{
CPackedStoreFileHandle pData = mypack.OpenFile( argv[i] );
if ( pData )
{
printf( "extracting %s\n", argv[i] );
COutputFile outF( argv[i] );
if ( !outF.IsOk() )
{
fprintf( stderr, "Unable to create '%s'.\n", argv[i] );
exit(1);
}
int nBytes = pData.m_nFileSize;
while( nBytes )
{
char cpBuf[65535];
int nReadSize = MIN( sizeof( cpBuf ), nBytes );
mypack.ReadData( pData, cpBuf, nReadSize );
outF.Write( cpBuf, nReadSize );
nBytes -= nReadSize;
}
outF.Close();
}
else
{
printf( "couldn't find file %s\n", argv[i] );
break;
}
}
}
else if ( V_strcmp( pszCommand, "B" ) == 0 )
{
if ( argc != 4 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
// benchmark
CRequiredInputTextFile hResponseFile( argv[3] );
CUtlStringList files;
hResponseFile.ReadLines( files );
printf("%d files\n", files.Count() );
float stime = Plat_FloatTime();
BenchMark( files );
printf( " time no pack = %f\n", Plat_FloatTime() - stime );
//g_pFullFileSystem->AddVPKFile( argv[2] );
//stime = Plat_FloatTime();
//BenchMark( files );
//printf( " time pack = %f\n", Plat_FloatTime() - stime );
}
else if ( V_strcmp( pszCommand, "rehash" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
char szActualFileName[MAX_PATH];
CPackedStore mypack( argv[2], szActualFileName, g_pFullFileSystem, true );
CheckLoadKeyFilesForSigning( mypack );
mypack.HashEverything();
mypack.Write();
}
else if ( V_strcmp( pszCommand, "checkhash" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
CheckHashes( argv[2] );
}
#ifdef VPK_ENABLE_SIGNING
else if ( V_strcmp( pszCommand, "generate_keypair" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
GenerateKeyPair( argv[2] );
}
else if ( V_strcmp( pszCommand, "checksig" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
CheckSignature( argv[2] );
}
else if ( V_strcmp( pszCommand, "dumpsig" ) == 0 )
{
if ( argc != 3 )
{
fprintf( stderr, "Incorrect number of arguments for '%s' command.\n", pszCommand );
exit(1);
}
DumpSignatureInfo( argv[2] );
}
#endif
else if ( argc == 2 && g_pFullFileSystem->IsDirectory( argv[1] ) )
{
DroppedDirectory( argv[1] );
}
else if ( argc == 2 && V_GetFileExtension( argv[1] ) && V_stristr( V_GetFileExtension( argv[1] ), "vpk") )
{
DroppedVpk( argv[1] );
}
else
{
Error( "Unknown command '%s'. Try 'vpk -?' for info.\n", pszCommand );
}
return 0;
}