943 lines
26 KiB
C++
943 lines
26 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// SYNC_FILES.CPP
|
|
//
|
|
// Sync Files Routines.
|
|
//=====================================================================================//
|
|
#include "vxconsole.h"
|
|
|
|
char g_syncfiles_localPath[MAX_PATH];
|
|
char g_syncfiles_targetPath[MAX_PATH];
|
|
fileNode_t *g_syncfiles_targetFiles;
|
|
int g_syncfiles_numTargetFiles;
|
|
CProgress *g_syncFiles_progress;
|
|
BOOL g_syncFiles_noWrite;
|
|
BOOL g_syncFiles_force;
|
|
BOOL g_syncFiles_verbose;
|
|
|
|
struct dvdimage_t
|
|
{
|
|
char szString[MAX_PATH];
|
|
CUtlString installPath;
|
|
CUtlString versionDetailString;
|
|
};
|
|
CUtlVector< dvdimage_t> g_install_dvdImages;
|
|
int g_install_Selection;
|
|
bool g_install_bForceSync;
|
|
bool g_install_bCleanTarget;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_Validate
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool SyncFilesDlg_Validate()
|
|
{
|
|
if ( !g_connectedToXBox )
|
|
{
|
|
Sys_MessageBox( "Sync Error", "Cannot sync until connected to XBox." );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_Setup
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SyncFilesDlg_Setup( HWND hWnd )
|
|
{
|
|
SetDlgItemText( hWnd, IDC_SYNCFILES_LOCALPATH, g_syncfiles_localPath );
|
|
SetDlgItemText( hWnd, IDC_SYNCFILES_TARGETPATH, g_syncfiles_targetPath );
|
|
|
|
CheckDlgButton( hWnd, IDC_SYNCFILES_FORCESYNC, g_syncFiles_force ? BST_CHECKED : BST_UNCHECKED );
|
|
CheckDlgButton( hWnd, IDC_SYNCFILES_NOWRITE, g_syncFiles_noWrite ? BST_CHECKED : BST_UNCHECKED );
|
|
CheckDlgButton( hWnd, IDC_SYNCFILES_VERBOSE, g_syncFiles_verbose ? BST_CHECKED : BST_UNCHECKED );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_GetChanges
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool SyncFilesDlg_GetChanges( HWND hwnd )
|
|
{
|
|
char localPath[MAX_PATH];
|
|
char targetPath[MAX_PATH];
|
|
|
|
localPath[0] = '\0';
|
|
targetPath[0] = '\0';
|
|
|
|
GetDlgItemText( hwnd, IDC_SYNCFILES_LOCALPATH, localPath, MAX_PATH );
|
|
GetDlgItemText( hwnd, IDC_SYNCFILES_TARGETPATH, targetPath, MAX_PATH );
|
|
|
|
strcpy( g_syncfiles_localPath, localPath );
|
|
Sys_NormalizePath( g_syncfiles_localPath, true );
|
|
|
|
strcpy( g_syncfiles_targetPath, targetPath );
|
|
Sys_NormalizePath( g_syncfiles_targetPath, true );
|
|
|
|
g_syncFiles_force = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_FORCESYNC ) != 0;
|
|
g_syncFiles_noWrite = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_NOWRITE ) != 0;
|
|
g_syncFiles_verbose = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_VERBOSE ) != 0;
|
|
|
|
// success
|
|
return ( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_Proc
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CALLBACK SyncFilesDlg_Proc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
switch ( message )
|
|
{
|
|
case WM_INITDIALOG:
|
|
SyncFilesDlg_Setup( hwnd );
|
|
return ( TRUE );
|
|
|
|
case WM_COMMAND:
|
|
switch ( LOWORD( wParam ) )
|
|
{
|
|
case IDC_OK:
|
|
if ( !SyncFilesDlg_GetChanges( hwnd ) )
|
|
break;
|
|
EndDialog( hwnd, wParam );
|
|
return ( TRUE );
|
|
|
|
case IDCANCEL:
|
|
case IDC_CANCEL:
|
|
EndDialog( hwnd, wParam );
|
|
return ( TRUE );
|
|
}
|
|
break;
|
|
}
|
|
return ( FALSE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFiles_FreeTargetList
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SyncFiles_FreeTargetList()
|
|
{
|
|
g_syncfiles_numTargetFiles = 0;
|
|
|
|
FreeTargetFileList( g_syncfiles_targetFiles );
|
|
g_syncfiles_targetFiles = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFiles_DoUpdates
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool SyncFiles_DoUpdates()
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA localAttributes;
|
|
fileNode_t *nodePtr;
|
|
char sourceFilename[MAX_PATH];
|
|
char statusBuff1[MAX_PATH];
|
|
char statusBuff2[MAX_PATH];
|
|
int targetPathLen;
|
|
char *ptr;
|
|
int progress;
|
|
int fileSyncMode;
|
|
int numSynced;
|
|
int retVal;
|
|
|
|
g_syncFiles_progress->SetStatus( "Syncing Target Files...", "", "" );
|
|
g_syncFiles_progress->SetMeter( 0, g_syncfiles_numTargetFiles );
|
|
|
|
fileSyncMode = FSYNC_ANDEXISTSONTARGET;
|
|
if ( g_syncFiles_force )
|
|
fileSyncMode |= FSYNC_ALWAYS;
|
|
else
|
|
fileSyncMode |= FSYNC_IFNEWER;
|
|
|
|
targetPathLen = strlen( g_syncfiles_targetPath );
|
|
|
|
numSynced = 0;
|
|
progress = 0;
|
|
nodePtr = g_syncfiles_targetFiles;
|
|
while ( nodePtr )
|
|
{
|
|
ptr = nodePtr->filename+targetPathLen;
|
|
if ( *ptr == '\\' )
|
|
ptr++;
|
|
|
|
// replace with source path head
|
|
strcpy( sourceFilename, g_syncfiles_localPath );
|
|
Sys_AddFileSeperator( sourceFilename, sizeof( sourceFilename ) );
|
|
strcat( sourceFilename, ptr );
|
|
|
|
float sourceFileSize = 0;
|
|
if ( GetFileAttributesEx( sourceFilename, GetFileExInfoStandard, &localAttributes ) )
|
|
{
|
|
sourceFileSize = (float)localAttributes.nFileSizeLow / (1024.0f * 1024.0f);
|
|
}
|
|
|
|
_snprintf( statusBuff1, sizeof( statusBuff1 ), "Local File: %s (%.2f MB)", sourceFilename, sourceFileSize );
|
|
statusBuff1[sizeof( statusBuff1 ) - 1] = '\0';
|
|
_snprintf( statusBuff2, sizeof( statusBuff2 ), "Target File: %s", nodePtr->filename );
|
|
statusBuff1[sizeof( statusBuff2 ) - 1] = '\0';
|
|
g_syncFiles_progress->SetStatus( NULL, statusBuff1, statusBuff2 );
|
|
|
|
retVal = FileSyncEx( sourceFilename, nodePtr->filename, fileSyncMode, g_syncFiles_verbose != FALSE, g_syncFiles_noWrite != FALSE);
|
|
if ( retVal == 1 )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Sync: %s -> %s\n", sourceFilename, nodePtr->filename );
|
|
numSynced++;
|
|
}
|
|
|
|
progress++;
|
|
g_syncFiles_progress->SetMeter( progress, -1 );
|
|
if ( g_syncFiles_progress->IsCancel() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
nodePtr = nodePtr->nextPtr;
|
|
}
|
|
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Synced %d/%d Files.\n", numSynced, g_syncfiles_numTargetFiles );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFiles_GetTargetList
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool SyncFiles_GetTargetList( char* pTargetPath )
|
|
{
|
|
g_syncFiles_progress->SetStatus( "Getting Target Files...", "", "" );
|
|
g_syncFiles_progress->SetMeter( 0, 100 );
|
|
|
|
if ( !GetTargetFileList_r( pTargetPath, true, FA_NORMAL|FA_READONLY, 0, &g_syncfiles_targetFiles ) )
|
|
{
|
|
ConsoleWindowPrintf( RGB( 255,0,0 ), "Bad Target Path '%s'\n", pTargetPath );
|
|
return false;
|
|
}
|
|
|
|
fileNode_t* pFileNode;
|
|
for ( pFileNode = g_syncfiles_targetFiles; pFileNode; pFileNode = pFileNode->nextPtr )
|
|
{
|
|
g_syncfiles_numTargetFiles++;
|
|
}
|
|
|
|
// success
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_SaveConfig
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SyncFilesDlg_SaveConfig()
|
|
{
|
|
Sys_SetRegistryString( "syncfiles_localPath", g_syncfiles_localPath );
|
|
Sys_SetRegistryString( "syncfiles_targetPath", g_syncfiles_targetPath );
|
|
Sys_SetRegistryInteger( "syncfiles_force", g_syncFiles_force );
|
|
Sys_SetRegistryInteger( "syncfiles_noWrite", g_syncFiles_noWrite );
|
|
Sys_SetRegistryInteger( "syncfiles_verbose", g_syncFiles_verbose );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_Open
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SyncFilesDlg_Open( void )
|
|
{
|
|
int result;
|
|
bool bError;
|
|
bool bValid;
|
|
|
|
result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_SYNCFILES ), g_hDlgMain, ( DLGPROC )SyncFilesDlg_Proc );
|
|
if ( LOWORD( result ) != IDC_OK )
|
|
return;
|
|
|
|
SyncFilesDlg_SaveConfig();
|
|
|
|
if ( !SyncFilesDlg_Validate() )
|
|
return;
|
|
|
|
g_syncFiles_progress = new CProgress;
|
|
g_syncFiles_progress->Open( "Sync Files...", true, true );
|
|
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nSyncing Files From '%s' to '%s'\n", g_syncfiles_localPath, g_syncfiles_targetPath );
|
|
|
|
bError = true;
|
|
|
|
// get a file listing from target
|
|
bValid = SyncFiles_GetTargetList( g_syncfiles_targetPath );
|
|
if ( !bValid )
|
|
goto cleanUp;
|
|
|
|
// mark all files needing update
|
|
bValid = SyncFiles_DoUpdates();
|
|
if ( !bValid )
|
|
goto cleanUp;
|
|
|
|
bError = false;
|
|
|
|
cleanUp:
|
|
delete g_syncFiles_progress;
|
|
g_syncFiles_progress = NULL;
|
|
|
|
if ( bError )
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Aborted.\n" );
|
|
else
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Finished.\n" );
|
|
|
|
SyncFiles_FreeTargetList();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_LoadConfig
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SyncFilesDlg_LoadConfig()
|
|
{
|
|
// get our config
|
|
Sys_GetRegistryString( "syncfiles_localPath", g_syncfiles_localPath, g_localPath, sizeof( g_syncfiles_localPath ) );
|
|
Sys_GetRegistryString( "syncfiles_targetPath", g_syncfiles_targetPath, g_targetPath, sizeof( g_syncfiles_targetPath ) );
|
|
Sys_GetRegistryInteger( "syncfiles_force", false, g_syncFiles_force );
|
|
Sys_GetRegistryInteger( "syncfiles_noWrite", false, g_syncFiles_noWrite );
|
|
Sys_GetRegistryInteger( "syncfiles_verbose", false, g_syncFiles_verbose );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SyncFilesDlg_Init
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool SyncFilesDlg_Init()
|
|
{
|
|
SyncFilesDlg_LoadConfig();
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_InstallImage
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void InstallDlg_InstallImage( const char *pInstallPath, bool bForce, bool bCleanTarget )
|
|
{
|
|
int errCode;
|
|
char *pToken;
|
|
char arg1[MAXTOKEN];
|
|
char arg2[MAXTOKEN];
|
|
char sourceFilename[MAX_PATH];
|
|
char sourcePath[MAX_PATH];
|
|
char targetFilename[MAX_PATH];
|
|
char filename[MAX_PATH];
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE h;
|
|
|
|
if ( !pInstallPath[0] )
|
|
{
|
|
return;
|
|
}
|
|
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nSyncing From Install Depot: %s\n", pInstallPath );
|
|
|
|
// get the install script
|
|
char szScriptPath[MAX_PATH];
|
|
V_ComposeFileName( pInstallPath, "../dvd_install.txt", szScriptPath, sizeof( szScriptPath ) );
|
|
if ( !Sys_Exists( szScriptPath ) )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Failed to open: %s\n", szScriptPath );
|
|
return;
|
|
}
|
|
|
|
// sanity check
|
|
// DVD image auto-build failure prevents the presence of the default.xex
|
|
char szTempFilename[MAX_PATH];
|
|
V_ComposeFileName( pInstallPath, "default.xex", szTempFilename, sizeof( szTempFilename ) );
|
|
if ( !Sys_Exists( szTempFilename ) )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation! DVD Image Auto-Build Process Failed - Missing default.xex!\n" );
|
|
return;
|
|
}
|
|
|
|
// get the version detail
|
|
char szVersionPath[MAX_PATH];
|
|
char *pVersionDetailString = NULL;
|
|
V_ComposeFileName( pInstallPath, "version.txt", szVersionPath, sizeof( szVersionPath ) );
|
|
if ( Sys_LoadFile( szVersionPath, (void**)&pVersionDetailString ) <= 0 )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation! DVD Image Auto-Build Process Failed! - Missing version.txt\n" );
|
|
return;
|
|
}
|
|
|
|
Sys_LoadScriptFile( szScriptPath );
|
|
|
|
CProgress* pProgress = new CProgress;
|
|
pProgress->Open( "Installing DVD Image...", true, false );
|
|
|
|
int numFailed = 0;
|
|
int numSkipped = 0;
|
|
int numUpdated = 0;
|
|
int version = 0;
|
|
|
|
bool bFailed = true;
|
|
bool bSyntaxError = false;
|
|
bool bCancelled = false;
|
|
while ( 1 )
|
|
{
|
|
pToken = Sys_GetToken( true );
|
|
if ( !pToken || !pToken[0] )
|
|
break;
|
|
|
|
if ( pProgress->IsCancel() )
|
|
{
|
|
bCancelled = true;
|
|
break;
|
|
}
|
|
|
|
if ( !stricmp( pToken, "$version" ) )
|
|
{
|
|
// version <num> <targetroot>
|
|
pToken = Sys_GetToken( false );
|
|
if ( !pToken || !pToken[0] )
|
|
{
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
version = atoi( pToken );
|
|
if ( version < 0 )
|
|
{
|
|
version = 0;
|
|
}
|
|
|
|
pToken = Sys_GetToken( false );
|
|
if ( !pToken || !pToken[0] )
|
|
{
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
Sys_StripQuotesFromToken( pToken );
|
|
V_FixSlashes( pToken );
|
|
if ( pToken[0] == CORRECT_PATH_SEPARATOR )
|
|
{
|
|
// remove initial slash
|
|
memcpy( pToken, pToken+1, strlen( pToken ) );
|
|
}
|
|
|
|
char szRootPath[MAX_PATH];
|
|
V_ComposeFileName( g_targetPath, pToken, szRootPath, sizeof( szRootPath ) );
|
|
|
|
if ( bCleanTarget )
|
|
{
|
|
// delete any exisiting files at target
|
|
DM_FILE_ATTRIBUTES fileAttributes;
|
|
HRESULT hr = DmGetFileAttributes( szRootPath, &fileAttributes );
|
|
if ( hr == XBDM_NOERR )
|
|
{
|
|
// delete all files at valid target
|
|
V_ComposeFileName( szRootPath, "*.*", szTempFilename, sizeof( szTempFilename ) );
|
|
char *pArgs[3];
|
|
pArgs[0] = "*del";
|
|
pArgs[1] = szTempFilename;
|
|
pArgs[2] = "/s";
|
|
if ( !lc_del( 3, pArgs ) )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Failed To Delete Files At '%s'.\n", szRootPath );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
char szTargetVersionPath[MAX_PATH];
|
|
V_ComposeFileName( szRootPath, "version.txt", szTargetVersionPath, sizeof( szTargetVersionPath ) );
|
|
|
|
if ( !bForce )
|
|
{
|
|
int fileSize;
|
|
char *pTargetVersionDetailString;
|
|
if ( !LoadTargetFile( szTargetVersionPath, &fileSize, (void**)&pTargetVersionDetailString ) )
|
|
{
|
|
// expected version does not exist
|
|
// force full install
|
|
bForce = true;
|
|
}
|
|
else if ( strcmp( pVersionDetailString, pTargetVersionDetailString ) != 0 )
|
|
{
|
|
// different versions
|
|
bForce = true;
|
|
}
|
|
Sys_Free( pTargetVersionDetailString );
|
|
}
|
|
|
|
if ( bForce && !FileSyncEx( szVersionPath, szTargetVersionPath, FSYNC_ALWAYS, true, false ) )
|
|
{
|
|
numFailed++;
|
|
break;
|
|
}
|
|
}
|
|
else if ( !stricmp( pToken, "$print" ) )
|
|
{
|
|
// print <string>
|
|
pToken = Sys_GetToken( false );
|
|
if ( !pToken || !pToken[0] )
|
|
{
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
Sys_StripQuotesFromToken( pToken );
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", pToken );
|
|
}
|
|
else if ( !stricmp( pToken, "$copy" ) )
|
|
{
|
|
// copy <source> <target>
|
|
pToken = Sys_GetToken( false );
|
|
if ( !pToken || !pToken[0] )
|
|
{
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
Sys_StripQuotesFromToken( pToken );
|
|
V_FixSlashes( pToken );
|
|
if ( !V_strnicmp( pToken, "DVD\\", 4 ) )
|
|
{
|
|
// skip past DVD, used as a placeholder
|
|
pToken += 4;
|
|
}
|
|
V_ComposeFileName( pInstallPath, pToken, arg1, sizeof( arg1 ) );
|
|
|
|
pToken = Sys_GetToken( false );
|
|
if ( !pToken || !pToken[0] )
|
|
{
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
Sys_StripQuotesFromToken( pToken );
|
|
V_FixSlashes( pToken );
|
|
if ( pToken[0] == CORRECT_PATH_SEPARATOR )
|
|
{
|
|
// remove initial slash
|
|
memcpy( pToken, pToken+1, strlen( pToken ) );
|
|
}
|
|
V_ComposeFileName( g_targetPath, pToken, arg2, sizeof( arg2 ) );
|
|
|
|
Sys_StripFilename( arg1, sourcePath, sizeof( sourcePath ) );
|
|
|
|
h = FindFirstFile( arg1, &findData );
|
|
if ( h != INVALID_HANDLE_VALUE )
|
|
{
|
|
do
|
|
{
|
|
if ( pProgress->IsCancel() )
|
|
{
|
|
bCancelled = true;
|
|
break;
|
|
}
|
|
|
|
if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) )
|
|
{
|
|
continue;
|
|
}
|
|
if ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
strcpy( sourceFilename, sourcePath );
|
|
Sys_AddFileSeperator( sourceFilename, sizeof( sourceFilename ) );
|
|
strcat( sourceFilename, findData.cFileName );
|
|
Sys_NormalizePath( sourceFilename, false );
|
|
|
|
Sys_StripPath( arg2, filename, sizeof( filename ) );
|
|
if ( filename[0] )
|
|
{
|
|
// target filename is specified
|
|
strcpy( targetFilename, arg2 );
|
|
}
|
|
else
|
|
{
|
|
// target filename is path
|
|
strcpy( targetFilename, arg2 );
|
|
Sys_AddFileSeperator( targetFilename, sizeof( targetFilename ) );
|
|
strcat( targetFilename, findData.cFileName );
|
|
Sys_NormalizePath( targetFilename, false );
|
|
}
|
|
|
|
ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nCopying: %s -> %s\n", sourceFilename, targetFilename );
|
|
|
|
WIN32_FILE_ATTRIBUTE_DATA localAttributes;
|
|
float sourceFileSize = 0;
|
|
if ( GetFileAttributesEx( sourceFilename, GetFileExInfoStandard, &localAttributes ) )
|
|
{
|
|
sourceFileSize = (float)localAttributes.nFileSizeLow / (1024.0f * 1024.0f);
|
|
}
|
|
|
|
char statusBuff1[MAX_PATH];
|
|
V_snprintf( statusBuff1, sizeof( statusBuff1 ), "Copying (%.2f MB) ... Please Wait", sourceFileSize );
|
|
pProgress->SetStatus( statusBuff1, sourceFilename, targetFilename );
|
|
|
|
int fileSyncMode = bForce ? FSYNC_ALWAYS : FSYNC_IFNEWER;
|
|
errCode = FileSyncEx( sourceFilename, targetFilename, fileSyncMode, true, false );
|
|
if ( errCode < 0 )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Sync Failure!\n" );
|
|
numFailed++;
|
|
}
|
|
else if ( errCode == 0 )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_BLUE, "Sync Skipped!\n" );
|
|
numSkipped++;
|
|
}
|
|
else if ( errCode == 1 )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_GREEN, "Sync Completed!\n" );
|
|
numUpdated++;
|
|
}
|
|
}
|
|
while ( FindNextFile( h, &findData ) );
|
|
|
|
FindClose( h );
|
|
}
|
|
}
|
|
else if ( !stricmp( pToken, "$end" ) )
|
|
{
|
|
bFailed = false;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Unknown token: '%s' in '%s'\n", pToken, szScriptPath );
|
|
bSyntaxError = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bSyntaxError )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Syntax Error in '%s'.\n", szScriptPath );
|
|
}
|
|
|
|
if ( bCancelled )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation!\n" );
|
|
}
|
|
else if ( bFailed )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "Failed Installation!\n" );
|
|
}
|
|
else
|
|
{
|
|
char *pCRLF = V_stristr( pVersionDetailString, "\r\n" );
|
|
if ( pCRLF )
|
|
{
|
|
*pCRLF = '\0';
|
|
}
|
|
|
|
// spew stats
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "\n" );
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "Installation Completed.\n" );
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "-----------------------\n" );
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "Version: %s\n", pVersionDetailString ? pVersionDetailString : "???" );
|
|
|
|
if ( numFailed )
|
|
{
|
|
ConsoleWindowPrintf( XBX_CLR_RED, "%d Failures.\n", numFailed );
|
|
}
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "%d Files In Sync.\n", numSkipped );
|
|
ConsoleWindowPrintf( XBX_CLR_BLACK, "%d Files Updated.\n", numUpdated );
|
|
}
|
|
|
|
delete pProgress;
|
|
Sys_Free( pVersionDetailString );
|
|
Sys_FreeScriptFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_GetChanges
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
bool InstallDlg_GetChanges( HWND hWnd )
|
|
{
|
|
g_install_bForceSync = IsDlgButtonChecked( hWnd, IDC_INSTALL_FORCESYNC ) != 0;
|
|
g_install_bCleanTarget = IsDlgButtonChecked( hWnd, IDC_INSTALL_CLEANTARGET ) != 0;
|
|
|
|
g_install_Selection = -1;
|
|
for ( int i = 0; i < g_install_dvdImages.Count(); i++ )
|
|
{
|
|
int state = ListView_GetItemState( GetDlgItem( hWnd, IDC_INSTALL_LIST ), i, LVIS_FOCUSED|LVIS_SELECTED );
|
|
if ( state == ( LVIS_FOCUSED|LVIS_SELECTED ) )
|
|
{
|
|
g_install_Selection = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SortDVDImages
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
int SortDVDImages( const dvdimage_t *pA, const dvdimage_t *pB )
|
|
{
|
|
char szStringA[256];
|
|
char szStringB[256];
|
|
|
|
V_strncpy( szStringA, pA->szString, sizeof( szStringA ) );
|
|
V_strncpy( szStringB, pB->szString, sizeof( szStringB ) );
|
|
|
|
// sort staging first
|
|
char *pCommentA = V_stristr( szStringA, " (" );
|
|
char *pCommentB = V_stristr( szStringB, " (" );
|
|
if ( pCommentA )
|
|
{
|
|
*pCommentA = '\0';
|
|
}
|
|
if ( pCommentB )
|
|
{
|
|
*pCommentB = '\0';
|
|
}
|
|
|
|
return stricmp( szStringB, szStringA );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_Populate
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void InstallDlg_Populate( HWND hWnd )
|
|
{
|
|
HWND hWndListView = GetDlgItem( hWnd, IDC_INSTALL_LIST );
|
|
|
|
ListView_DeleteAllItems( hWndListView );
|
|
g_install_dvdImages.Purge();
|
|
|
|
// get list of DVD images
|
|
char szPath[MAX_PATH];
|
|
V_ComposeFileName( g_installPath, "DVD_*", szPath, sizeof( szPath ) );
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE h = FindFirstFile( szPath, &findData );
|
|
if ( h != INVALID_HANDLE_VALUE )
|
|
{
|
|
do
|
|
{
|
|
if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) )
|
|
{
|
|
continue;
|
|
}
|
|
if ( !( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
|
|
{
|
|
// skip files
|
|
continue;
|
|
}
|
|
|
|
char szInstallPath[MAX_PATH];
|
|
V_strncpy( szInstallPath, g_installPath, sizeof( szInstallPath ) );
|
|
V_AppendSlash( szInstallPath, sizeof( szInstallPath ) );
|
|
V_strncat( szInstallPath, findData.cFileName, sizeof( szInstallPath ) );
|
|
|
|
// qualify dvd dirs that are images
|
|
char szBooterPath[MAX_PATH];
|
|
V_ComposeFileName( szInstallPath, "default.xex", szBooterPath, sizeof( szBooterPath ) );
|
|
if ( !Sys_Exists( szBooterPath ) )
|
|
{
|
|
continue;
|
|
}
|
|
char szVersionPath[MAX_PATH];
|
|
V_ComposeFileName( szInstallPath, "version.txt", szVersionPath, sizeof( szVersionPath ) );
|
|
char *pVersionDetailString = NULL;
|
|
if ( Sys_LoadFile( szVersionPath, (void**)&pVersionDetailString ) == -1 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
char *pCRLF = V_stristr( pVersionDetailString, "\r\n" );
|
|
if ( pCRLF )
|
|
{
|
|
*pCRLF = '\0';
|
|
}
|
|
|
|
dvdimage_t image;
|
|
|
|
int year = 0;
|
|
int month = 0;
|
|
int day = 0;
|
|
int hour = 0;
|
|
int minute = 0;
|
|
char timeOfDay[256];
|
|
sscanf( findData.cFileName, "DVD_%d_%d_%d_%d_%d_%s", &year, &month, &day, &hour, &minute, timeOfDay );
|
|
|
|
const char *pInfoString = timeOfDay;
|
|
if ( !V_strnicmp( timeOfDay, "PM", 2 ) )
|
|
{
|
|
if ( hour != 12 )
|
|
{
|
|
// 24 hour time for correct sorting
|
|
hour += 12;
|
|
}
|
|
pInfoString += 2;
|
|
}
|
|
else if ( !V_strnicmp( timeOfDay, "AM", 2 ) )
|
|
{
|
|
if ( hour == 12 )
|
|
{
|
|
// 24 hour time for correct sorting
|
|
hour = 0;
|
|
}
|
|
pInfoString += 2;
|
|
}
|
|
|
|
char szCommentBuff[128];
|
|
if ( pInfoString[0] == '_' )
|
|
{
|
|
// optional info after AM/PM
|
|
pInfoString++;
|
|
V_snprintf( szCommentBuff, sizeof( szCommentBuff ), " (%s)", pInfoString );
|
|
}
|
|
else
|
|
{
|
|
szCommentBuff[0] = '\0';
|
|
}
|
|
|
|
V_snprintf( image.szString, sizeof( image.szString ), "%2.2d/%2.2d/%4.4d %2.2d:%2.2d%s", month, day, year, hour, minute, szCommentBuff );
|
|
|
|
image.installPath = szInstallPath;
|
|
image.versionDetailString = pVersionDetailString;
|
|
g_install_dvdImages.AddToTail( image );
|
|
Sys_Free( pVersionDetailString );
|
|
}
|
|
while ( FindNextFile( h, &findData ) );
|
|
FindClose( h );
|
|
}
|
|
|
|
// current image will be at head
|
|
g_install_dvdImages.Sort( SortDVDImages );
|
|
|
|
for ( int i = 0; i < g_install_dvdImages.Count(); i++ )
|
|
{
|
|
// setup and insert at end of list
|
|
LVITEM lvi;
|
|
memset( &lvi, 0, sizeof( lvi ) );
|
|
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE;
|
|
lvi.iItem = i;
|
|
lvi.iSubItem = 0;
|
|
lvi.state = 0;
|
|
lvi.stateMask = 0;
|
|
lvi.pszText = LPSTR_TEXTCALLBACK;
|
|
lvi.lParam = (LPARAM)i;
|
|
|
|
ListView_InsertItem( hWndListView, &lvi );
|
|
}
|
|
|
|
if ( g_install_dvdImages.Count() )
|
|
{
|
|
ListView_SetItemState( hWndListView, 0, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_Setup
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void InstallDlg_Setup( HWND hWnd )
|
|
{
|
|
g_install_Selection = -1;
|
|
g_install_bForceSync = false;
|
|
g_install_bCleanTarget = false;
|
|
|
|
HWND hWndListView = GetDlgItem( hWnd, IDC_INSTALL_LIST );
|
|
|
|
// initialize columns
|
|
LVCOLUMN lvc;
|
|
memset( &lvc, 0, sizeof( lvc ) );
|
|
lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM;
|
|
lvc.iSubItem = 0;
|
|
lvc.fmt = LVCFMT_LEFT;
|
|
lvc.cx = 200;
|
|
lvc.pszText = ( LPSTR )"Date Built:";
|
|
ListView_InsertColumn( hWndListView, 0, &lvc );
|
|
lvc.iSubItem = 0;
|
|
lvc.fmt = LVCFMT_LEFT;
|
|
lvc.cx = 500;
|
|
lvc.pszText = ( LPSTR )"Perforce Changelist:";
|
|
ListView_InsertColumn( hWndListView, 1, &lvc );
|
|
|
|
ListView_SetBkColor( hWndListView, g_backgroundColor );
|
|
ListView_SetTextBkColor( hWndListView, g_backgroundColor );
|
|
|
|
DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES;
|
|
ListView_SetExtendedListViewStyleEx( hWndListView, style, style );
|
|
|
|
InstallDlg_Populate( hWnd );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_Proc
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CALLBACK InstallDlg_Proc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
switch ( message )
|
|
{
|
|
case WM_INITDIALOG:
|
|
InstallDlg_Setup( hWnd );
|
|
return ( TRUE );
|
|
|
|
case WM_NOTIFY:
|
|
switch ( ( ( LPNMHDR )lParam )->code )
|
|
{
|
|
case LVN_GETDISPINFO:
|
|
NMLVDISPINFO* plvdi;
|
|
plvdi = (NMLVDISPINFO*)lParam;
|
|
int item = (int)plvdi->item.lParam;
|
|
switch ( plvdi->item.iSubItem )
|
|
{
|
|
case 0:
|
|
plvdi->item.pszText = g_install_dvdImages[item].szString;
|
|
return TRUE;
|
|
case 1:
|
|
plvdi->item.pszText = (LPSTR)g_install_dvdImages[item].versionDetailString.String();
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch ( LOWORD( wParam ) )
|
|
{
|
|
case IDC_OK:
|
|
InstallDlg_GetChanges( hWnd );
|
|
EndDialog( hWnd, wParam );
|
|
return ( TRUE );
|
|
|
|
case IDC_INSTALL_REFRESH:
|
|
InstallDlg_Populate( hWnd );
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
case IDC_CANCEL:
|
|
EndDialog( hWnd, wParam );
|
|
return ( TRUE );
|
|
}
|
|
break;
|
|
}
|
|
return ( FALSE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// InstallDlg_Open
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void InstallDlg_Open( void )
|
|
{
|
|
int result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_INSTALL ), g_hDlgMain, ( DLGPROC )InstallDlg_Proc );
|
|
if ( LOWORD( result ) == IDC_OK && g_install_Selection != -1 )
|
|
{
|
|
InstallDlg_InstallImage(
|
|
g_install_dvdImages[g_install_Selection].installPath.String(),
|
|
g_install_bForceSync,
|
|
g_install_bCleanTarget );
|
|
}
|
|
|
|
g_install_dvdImages.Purge();
|
|
}
|