You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
785 lines
22 KiB
785 lines
22 KiB
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) 1997-1999 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
// File Name:
|
|
// save.c
|
|
//
|
|
// Description:
|
|
// This file has the code that dumps the user's answers to the
|
|
// answer file.
|
|
//
|
|
// The entry point SaveAllSettings() is called by the wizard when
|
|
// it is time to save the answer file (and possibly the .udf and
|
|
// sample batch script).
|
|
//
|
|
// The global vars GenSettings, NetSettings, etc. are examined
|
|
// and we decide what [Section] key=value settings need to be
|
|
// written.
|
|
//
|
|
// If you're adding a page to this wizard, see the function
|
|
// QueueSettingsToAnswerFile().
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#include "allres.h"
|
|
|
|
|
|
#define FILE_DOT_UDB _T(".udb")
|
|
|
|
//
|
|
// local prototypes
|
|
//
|
|
|
|
static BOOL IsOkToOverwriteFiles(HWND hwnd);
|
|
static BOOL BuildAltFileNames(HWND hwnd);
|
|
static BOOL WriteSampleBatchScript(HWND hwnd);
|
|
|
|
static VOID QuoteStringIfNecessary( OUT TCHAR *szOutputString,
|
|
IN const TCHAR* const szInputString,
|
|
IN DWORD cbSize);
|
|
|
|
//
|
|
// Localized "Usage" string
|
|
//
|
|
|
|
static TCHAR *StrUsage = NULL;
|
|
|
|
//
|
|
// External function in savefile.c
|
|
//
|
|
|
|
extern BOOL QueueSettingsToAnswerFile(HWND hwnd);
|
|
|
|
BOOL SettingQueueHalScsi_Flush(LPTSTR lpFileName,
|
|
QUEUENUM dwWhichQueue);
|
|
|
|
static TCHAR *StrSampleBatchScriptLine1 = NULL;
|
|
static TCHAR *StrSampleBatchScriptLine2 = NULL;
|
|
static TCHAR *StrBatchScriptSysprepWarning = NULL;
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: SetCdRomPath
|
|
//
|
|
// Purpose: To find the CD-ROM on this local machine and set
|
|
// WizGlobals.CdSourcePath to it.
|
|
//
|
|
// Arguments: VOID
|
|
//
|
|
// Returns: BOOL TRUE - if the CD path was set
|
|
// FALSE - if no CD path was found
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
static BOOL
|
|
SetCdRomPath( VOID )
|
|
{
|
|
|
|
TCHAR *p;
|
|
TCHAR DriveLetters[MAX_PATH];
|
|
TCHAR PathBuffer[MAX_PATH];
|
|
|
|
//
|
|
// Find the CD-ROM
|
|
//
|
|
// GetLogicalDriveStrings() fills in the DriveLetters buffer, and it
|
|
// looks like:
|
|
//
|
|
// c:\(null)d:\(null)x:\(null)(null)
|
|
//
|
|
// (i.e. double-null at the end)
|
|
//
|
|
|
|
|
|
// ISSUE-2002/02/27-stelo,swamip - Replace with existing code that searches drives
|
|
//
|
|
if ( ! GetLogicalDriveStrings(MAX_PATH, DriveLetters) )
|
|
DriveLetters[0] = _T('\0');
|
|
|
|
p = DriveLetters;
|
|
|
|
while ( *p ) {
|
|
|
|
if ( GetDriveType(p) == DRIVE_CDROM ) {
|
|
|
|
SYSTEM_INFO SystemInfo;
|
|
HRESULT hrCat;
|
|
|
|
lstrcpyn( PathBuffer, p , AS(PathBuffer));
|
|
|
|
GetSystemInfo( &SystemInfo );
|
|
|
|
switch( SystemInfo.wProcessorArchitecture )
|
|
{
|
|
case PROCESSOR_ARCHITECTURE_INTEL:
|
|
|
|
hrCat=StringCchCat( PathBuffer, AS(PathBuffer), _T("i386") );
|
|
|
|
break;
|
|
|
|
case PROCESSOR_ARCHITECTURE_AMD64:
|
|
|
|
hrCat=StringCchCat( PathBuffer, AS(PathBuffer), _T("amd64") );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
hrCat=StringCchCat( PathBuffer, AS(PathBuffer), _T("i386") );
|
|
|
|
AssertMsg( FALSE,
|
|
"Unknown Processor. Can't set setup files path." );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
while ( *p++ );
|
|
}
|
|
|
|
//
|
|
// If no CD Found, leave the setup files path blank
|
|
//
|
|
if( *p == _T('\0') )
|
|
{
|
|
lstrcpyn( WizGlobals.CdSourcePath, _T(""), AS(WizGlobals.CdSourcePath) );
|
|
|
|
return( FALSE );
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn( WizGlobals.CdSourcePath, PathBuffer, AS(WizGlobals.CdSourcePath) );
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: DidSetupmgrWriteThisFile
|
|
//
|
|
// Purpose: To check to see if a specific file was written by Setup Manager
|
|
//
|
|
// Arguments: IN LPTSTR lpFile - the full path and name of the file to check
|
|
//
|
|
// Returns: BOOL TRUE - if setup manager wrote the file
|
|
// FALSE - if it didn't
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
static BOOL
|
|
DidSetupmgrWriteThisFile( IN LPTSTR lpFile )
|
|
{
|
|
|
|
INT iRet;
|
|
TCHAR Buffer[MAX_INILINE_LEN];
|
|
FILE *fp = My_fopen(lpFile, _T("r") );
|
|
|
|
if ( fp == NULL )
|
|
return( FALSE );
|
|
|
|
if ( My_fgets(Buffer, MAX_INILINE_LEN - 1, fp) == NULL )
|
|
return( FALSE );
|
|
|
|
My_fclose(fp);
|
|
|
|
if ( lstrcmp(Buffer, _T(";SetupMgrTag\n")) == 0 ||
|
|
lstrcmp(Buffer, _T("@rem SetupMgrTag\n")) == 0 )
|
|
{
|
|
return( TRUE );
|
|
}
|
|
else
|
|
{
|
|
return( FALSE );
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: SaveAllSettings
|
|
//
|
|
// Purpose: This is the entry point for saving the answer file. It is
|
|
// called by the SaveScript page.
|
|
//
|
|
// If multiple computers were specified, it also writes a .udf.
|
|
//
|
|
// It always writes a batch file that makes it easy to use the
|
|
// answer file just created.
|
|
//
|
|
// Arguments: HWND hwnd
|
|
//
|
|
// Returns: BOOL
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
SaveAllSettings(HWND hwnd)
|
|
{
|
|
//
|
|
// Build the file names for the .udf and sample batch script. The
|
|
// results are stored in FixedGlobals.
|
|
//
|
|
// After calling BuildAltFileNames(), FixedGlobals.UdfFileName and
|
|
// FixedGlobals.BatchFileName will be null strings if we're not
|
|
// supposed to write those files out
|
|
//
|
|
|
|
if ( ! BuildAltFileNames(hwnd) )
|
|
return FALSE;
|
|
|
|
//
|
|
// Before overwriting anything do some checks.
|
|
//
|
|
|
|
if ( ! IsOkToOverwriteFiles(hwnd) )
|
|
return FALSE;
|
|
|
|
//
|
|
// Empty any intermediatte stuff we have on the queues because
|
|
// user is going back & next alot.
|
|
//
|
|
// Then initialize the queues with the original settings.
|
|
//
|
|
|
|
SettingQueue_Empty(SETTING_QUEUE_ANSWERS);
|
|
SettingQueue_Empty(SETTING_QUEUE_UDF);
|
|
|
|
SettingQueue_Copy(SETTING_QUEUE_ORIG_ANSWERS,
|
|
SETTING_QUEUE_ANSWERS);
|
|
|
|
SettingQueue_Copy(SETTING_QUEUE_ORIG_UDF,
|
|
SETTING_QUEUE_UDF);
|
|
|
|
//
|
|
// Call the function that everybody plugs into in savefile.c to
|
|
// queue up all the answers from the UI.
|
|
//
|
|
|
|
if (!QueueSettingsToAnswerFile(hwnd))
|
|
return FALSE;
|
|
|
|
//
|
|
// Flush the answer file queue.
|
|
//
|
|
|
|
if ( ! SettingQueue_Flush(FixedGlobals.ScriptName,
|
|
SETTING_QUEUE_ANSWERS) ) {
|
|
ReportErrorId(hwnd,
|
|
MSGTYPE_ERR | MSGTYPE_WIN32,
|
|
IDS_ERRORS_WRITING_ANSWER_FILE,
|
|
FixedGlobals.ScriptName);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// If multiple computernames, flush the .udf queue
|
|
//
|
|
|
|
if ( FixedGlobals.UdfFileName[0] ) {
|
|
|
|
if ( ! SettingQueue_Flush(FixedGlobals.UdfFileName,
|
|
SETTING_QUEUE_UDF) ) {
|
|
ReportErrorId(hwnd,
|
|
MSGTYPE_ERR | MSGTYPE_WIN32,
|
|
IDS_ERRORS_WRITING_UDF,
|
|
FixedGlobals.UdfFileName);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// If they are using SCSI or HAL files, then flush the txtsetup.oem queue
|
|
//
|
|
|
|
// NTRAID#NTBUG9-551746-2002/02/27-stelo,swamip - Unused code, should be removed
|
|
//
|
|
if ( GetNameListSize( &GenSettings.OemScsiFiles ) > 0 ||
|
|
GetNameListSize( &GenSettings.OemHalFiles ) > 0 ) {
|
|
|
|
TCHAR szTextmodePath[MAX_PATH + 1] = _T("");
|
|
|
|
// Note-ConcatenatePaths truncates to prevent overflow
|
|
ConcatenatePaths( szTextmodePath,
|
|
WizGlobals.OemFilesPath,
|
|
_T("Textmode\\txtsetup.oem"),
|
|
NULL );
|
|
|
|
if ( ! SettingQueueHalScsi_Flush(szTextmodePath,
|
|
SETTING_QUEUE_TXTSETUP_OEM) ) {
|
|
ReportErrorId(hwnd,
|
|
MSGTYPE_ERR | MSGTYPE_WIN32,
|
|
IDS_ERRORS_WRITING_ANSWER_FILE,
|
|
szTextmodePath);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Write the sample batch script if BuildAltFileNames hasn't already
|
|
// determined that we should not (i.e. If a remote boot answer file,
|
|
// don't write a sample batch script)
|
|
//
|
|
|
|
if ( FixedGlobals.BatchFileName[0] ) {
|
|
if ( ! WriteSampleBatchScript(hwnd) )
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: IsOkToOverwriteFiles
|
|
//
|
|
// Purpose: This is called prior to writing the answer file, .udf and sample
|
|
// batch script.
|
|
//
|
|
// Before overwriting any file, we make sure that it was created
|
|
// by setupmgr. If not, we prompt the user.
|
|
//
|
|
// Returns:
|
|
// TRUE - to go ahead and overwrite any of the files that might exist
|
|
// FALSE - user canceled the overwrite
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
static BOOL
|
|
IsOkToOverwriteFiles(HWND hwnd)
|
|
{
|
|
INT i;
|
|
INT iRet;
|
|
|
|
//
|
|
// If we are editing a script just write out the files
|
|
//
|
|
if( ! WizGlobals.bNewScript )
|
|
{
|
|
return( TRUE );
|
|
}
|
|
|
|
//
|
|
// Check foo.txt foo.udf and foo.bat that we're about to write out.
|
|
// If any of them already exists, then check to see if they were
|
|
// created by setupmgr. We will prompt the user before overwriting
|
|
// something we didn't write before.
|
|
//
|
|
|
|
for ( i=0; i<3; i++ ) {
|
|
|
|
LPTSTR lpFile = NULL;
|
|
|
|
//
|
|
// The answer file, .udf or the batch script?
|
|
//
|
|
|
|
if ( i == 0 )
|
|
lpFile = FixedGlobals.ScriptName;
|
|
else if ( i == 1 )
|
|
lpFile = FixedGlobals.UdfFileName;
|
|
else
|
|
lpFile = FixedGlobals.BatchFileName;
|
|
|
|
//
|
|
// If the file already exists, prompt the user if it doesn't
|
|
// have our tag.
|
|
//
|
|
// Look for ;SetupMgrTag in the answer file and .udf
|
|
// Look for rem SetupMgrTag in the batch script
|
|
//
|
|
|
|
if ( lpFile[0] && DoesFileExist(lpFile) ) {
|
|
|
|
if( DidSetupmgrWriteThisFile( lpFile ) )
|
|
{
|
|
|
|
iRet = ReportErrorId(hwnd,
|
|
MSGTYPE_YESNO,
|
|
IDS_ERR_FILE_ALREADY_EXISTS,
|
|
lpFile);
|
|
if ( iRet == IDNO )
|
|
return( FALSE );
|
|
|
|
}
|
|
else {
|
|
|
|
iRet = ReportErrorId(hwnd,
|
|
MSGTYPE_YESNO,
|
|
IDS_ERR_SAVEFILE_NOT_SETUPMGR,
|
|
lpFile);
|
|
if ( iRet == IDNO )
|
|
return( FALSE );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: BuildAltFileNames
|
|
//
|
|
// Purpose: This function derives the name for the .udf and the .bat
|
|
// associatted with a given answer filename.
|
|
//
|
|
// Note: This function has a couple of side-effects. If there is no
|
|
// extension on FixedGlobals.ScriptName, it adds one.
|
|
//
|
|
// Also, after this function runs, FixedGlobals.UdfFileName will
|
|
// be a null string if there <= 1 computer names (i.e. no udf)
|
|
//
|
|
// If we're writing a .sif (remote boot), FixGlobals.BatchFileName
|
|
// will be a null-string.
|
|
//
|
|
// The finish page relies on this.
|
|
//
|
|
// Returns: BOOL
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
static BOOL
|
|
BuildAltFileNames(HWND hwnd)
|
|
{
|
|
TCHAR PathBuffer[MAX_PATH],
|
|
*lpFilePart = NULL,
|
|
*pExtension;
|
|
|
|
INT nEntries = GetNameListSize(&GenSettings.ComputerNames);
|
|
BOOL bMultipleComputers = ( nEntries > 1 );
|
|
HRESULT hrCat;
|
|
|
|
//
|
|
// Find out the filename part of the answer file pathname and copy
|
|
// it to PathBuffer[]
|
|
//
|
|
|
|
GetFullPathName(FixedGlobals.ScriptName,
|
|
MAX_PATH,
|
|
PathBuffer,
|
|
&lpFilePart);
|
|
|
|
if (lpFilePart == NULL)
|
|
return FALSE;
|
|
//
|
|
// Point at the extension in the PathBuffer[].
|
|
//
|
|
// e.g. foo.txt, point at the dot.
|
|
// foo, point at the null byte.
|
|
//
|
|
// If there is no extension, put one on it
|
|
//
|
|
|
|
if ( (pExtension = wcsrchr(lpFilePart, _T('.'))) == NULL ) {
|
|
|
|
pExtension = &lpFilePart[lstrlen(lpFilePart)];
|
|
|
|
if ( WizGlobals.iProductInstall == PRODUCT_REMOTEINSTALL )
|
|
hrCat=StringCchCat(FixedGlobals.ScriptName, AS(FixedGlobals.ScriptName), _T(".sif"));
|
|
else
|
|
hrCat=StringCchCat(FixedGlobals.ScriptName, AS(FixedGlobals.ScriptName), _T(".txt"));
|
|
}
|
|
|
|
//
|
|
// Cannot allow foo.bat or foo.udf as answer file names because we
|
|
// will probably be writing other stuff to foo.bat and/or foo.udf
|
|
//
|
|
|
|
if ( (LSTRCMPI(pExtension, _T(".bat")) == 0) ||
|
|
(LSTRCMPI(pExtension, FILE_DOT_UDB) == 0) )
|
|
{
|
|
ReportErrorId(hwnd,
|
|
MSGTYPE_ERR,
|
|
IDS_ERR_BAD_SCRIPT_EXTENSION);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Build the .udf name if there was > 1 computer names specified
|
|
//
|
|
|
|
if ( bMultipleComputers ) {
|
|
lstrcpyn(pExtension, FILE_DOT_UDB, MAX_PATH- (int)(pExtension - PathBuffer) );
|
|
lstrcpyn(FixedGlobals.UdfFileName, PathBuffer,AS(FixedGlobals.UdfFileName));
|
|
} else {
|
|
FixedGlobals.UdfFileName[0] = _T('\0');
|
|
}
|
|
|
|
//
|
|
// Build the .bat file name. We won't be creating a sample batch
|
|
// script in the case of remote boot, so null it out, else the Finish
|
|
// page will be broken.
|
|
//
|
|
|
|
if ( (WizGlobals.iProductInstall == PRODUCT_REMOTEINSTALL) ||
|
|
(WizGlobals.iProductInstall == PRODUCT_SYSPREP) ) {
|
|
FixedGlobals.BatchFileName[0] = _T('\0');
|
|
} else {
|
|
lstrcpyn(pExtension, _T(".bat"), MAX_PATH - (int)(pExtension - PathBuffer) );
|
|
lstrcpyn(FixedGlobals.BatchFileName, PathBuffer,AS(FixedGlobals.BatchFileName));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: AddLanguageSwitch
|
|
//
|
|
// Purpose: Add the /copysource language switch to copy over the right
|
|
// language files
|
|
//
|
|
// Returns: VOID
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
static VOID
|
|
AddLanguageSwitch( TCHAR *Buffer, DWORD cbSize )
|
|
{
|
|
INT iNumLanguages;
|
|
HRESULT hrCat;
|
|
|
|
iNumLanguages = GetNameListSize( &GenSettings.LanguageFilePaths );
|
|
|
|
if ( iNumLanguages > 0 )
|
|
{
|
|
hrCat=StringCchCat( Buffer, cbSize, _T(" /copysource:lang") );
|
|
|
|
}
|
|
|
|
hrCat=StringCchCat( Buffer, cbSize, _T("\n") ); // make sure it has a line-feed at the end
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: WriteSampleBatchScript
|
|
//
|
|
// Purpose: writes the sample batch script
|
|
//
|
|
// Returns: FALSE if errors writing the file. Any errors are reported
|
|
// to the user.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
static BOOL
|
|
WriteSampleBatchScript(HWND hwnd)
|
|
{
|
|
|
|
FILE *fp;
|
|
TCHAR Buffer[MAX_INILINE_LEN];
|
|
TCHAR *pszScriptName = NULL;
|
|
TCHAR szComputerName[MAX_PATH];
|
|
TCHAR SetupFilesBuffer[MAX_INILINE_LEN];
|
|
TCHAR AnswerFileBuffer[MAX_INILINE_LEN];
|
|
TCHAR SetupFilesQuotedBuffer[MAX_INILINE_LEN];
|
|
TCHAR Winnt32Buffer[MAX_INILINE_LEN];
|
|
DWORD dwSize;
|
|
INT nEntries = GetNameListSize(&GenSettings.ComputerNames);
|
|
BOOL bMultipleComputers = ( nEntries > 1 );
|
|
HRESULT hrPrintf;
|
|
|
|
if ( (fp = My_fopen(FixedGlobals.BatchFileName, _T("w")) ) == NULL ) {
|
|
ReportErrorId(hwnd,
|
|
MSGTYPE_ERR | MSGTYPE_WIN32,
|
|
IDS_ERR_OPEN_SAMPLE_BAT,
|
|
FixedGlobals.BatchFileName);
|
|
return FALSE;
|
|
}
|
|
|
|
My_fputs(_T("@rem SetupMgrTag\n@echo off\n\n"), fp);
|
|
|
|
if( StrSampleBatchScriptLine1 == NULL )
|
|
{
|
|
StrSampleBatchScriptLine1 = MyLoadString( IDS_BATCH_SCRIPT_LINE1 );
|
|
StrSampleBatchScriptLine2 = MyLoadString( IDS_BATCH_SCRIPT_LINE2 );
|
|
}
|
|
|
|
|
|
My_fputs( _T("rem\nrem "), fp );
|
|
|
|
My_fputs( StrSampleBatchScriptLine1, fp );
|
|
|
|
My_fputs( _T("\nrem "), fp );
|
|
|
|
My_fputs( StrSampleBatchScriptLine2, fp );
|
|
|
|
My_fputs( _T("\nrem\n\n"), fp );
|
|
|
|
|
|
if ( !(pszScriptName = MyGetFullPath( FixedGlobals.ScriptName )) )
|
|
{
|
|
My_fclose( fp );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Quote the Script name if it contains spaces
|
|
//
|
|
|
|
QuoteStringIfNecessary( AnswerFileBuffer, pszScriptName, AS(AnswerFileBuffer) );
|
|
|
|
// Note: MAX_INILINE_LEN=1K AnswerFileBuffer at this time is MAX_PATH+2 MAX
|
|
// buffer overrun should not be a problem.
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer), _T("set AnswerFile=.\\%s\n"), AnswerFileBuffer );
|
|
|
|
My_fputs( Buffer, fp );
|
|
|
|
if( bMultipleComputers )
|
|
{
|
|
|
|
TCHAR UdfFileBuffer[1024];
|
|
|
|
pszScriptName = MyGetFullPath( FixedGlobals.UdfFileName );
|
|
|
|
//
|
|
// Quote the UDF name if it contains spaces
|
|
//
|
|
|
|
QuoteStringIfNecessary( UdfFileBuffer, pszScriptName, AS(UdfFileBuffer) );
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("set UdfFile=.\\%s\nset ComputerName=%%1\n"),
|
|
UdfFileBuffer );
|
|
|
|
My_fputs( Buffer, fp );
|
|
|
|
}
|
|
|
|
|
|
if( WizGlobals.bStandAloneScript )
|
|
{
|
|
|
|
SetCdRomPath();
|
|
|
|
lstrcpyn( SetupFilesBuffer, WizGlobals.CdSourcePath, AS(SetupFilesBuffer) );
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
GetComputerNameFromUnc( WizGlobals.UncDistFolder, szComputerName, AS(szComputerName) );
|
|
|
|
hrPrintf=StringCchPrintf( SetupFilesBuffer, AS(SetupFilesBuffer),
|
|
_T("%s%s%s%s%s"),
|
|
szComputerName,
|
|
_T("\\"),
|
|
WizGlobals.DistShareName,
|
|
_T("\\"),
|
|
WizGlobals.Architecture );
|
|
}
|
|
|
|
QuoteStringIfNecessary( SetupFilesQuotedBuffer, SetupFilesBuffer, AS(SetupFilesQuotedBuffer) );
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("set SetupFiles=%s\n\n"),
|
|
SetupFilesQuotedBuffer );
|
|
My_fputs( Buffer, fp );
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("%s\\winnt32"),
|
|
SetupFilesBuffer );
|
|
|
|
QuoteStringIfNecessary( Winnt32Buffer, Buffer, AS(Winnt32Buffer) );
|
|
|
|
if( bMultipleComputers )
|
|
{
|
|
|
|
if( StrUsage == NULL )
|
|
{
|
|
StrUsage = MyLoadString( IDS_USAGE );
|
|
}
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("if \"%%ComputerName%%\" == \"\" goto USAGE\n\n") );
|
|
|
|
My_fputs( Buffer, fp );
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("%s%s"),
|
|
Winnt32Buffer,
|
|
_T(" /s:%SetupFiles% ")
|
|
_T("/unattend:%AnswerFile% ")
|
|
_T("/udf:%ComputerName%,%UdfFile% ")
|
|
_T("/makelocalsource") );
|
|
|
|
AddLanguageSwitch( Buffer, AS(Buffer) );
|
|
|
|
My_fputs( Buffer, fp );
|
|
|
|
My_fputs( _T("goto DONE\n\n"), fp );
|
|
|
|
My_fputs( _T(":USAGE\n"), fp );
|
|
|
|
My_fputs( _T("echo.\n"), fp );
|
|
|
|
hrPrintf=StringCchPrintf( Buffer, AS(Buffer),
|
|
_T("echo %s: unattend ^<computername^>\n"),
|
|
StrUsage );
|
|
|
|
My_fputs( Buffer, fp );
|
|
|
|
My_fputs( _T("echo.\n\n"), fp );
|
|
|
|
My_fputs( _T(":DONE\n"), fp );
|
|
|
|
}
|
|
else
|
|
{
|
|
hrPrintf=StringCchPrintf(Buffer, AS(Buffer),
|
|
_T("%s%s"),
|
|
Winnt32Buffer,
|
|
_T(" /s:%SetupFiles% ")
|
|
_T("/unattend:%AnswerFile%"));
|
|
|
|
AddLanguageSwitch( Buffer, AS(Buffer) );
|
|
|
|
My_fputs( Buffer, fp );
|
|
}
|
|
|
|
My_fclose( fp );
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: QuoteStringIfNecessary
|
|
//
|
|
// Purpose: If the given input string has white space then the whole string
|
|
// is quoted and returned in the output string. Else just the string
|
|
// is returned in the output string.
|
|
//
|
|
// szOutputString is assumed to be of size MAX_INILINE_LEN
|
|
//
|
|
// Arguments: OUT TCHAR *szOutputString
|
|
//
|
|
// Returns: VOID
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
static VOID
|
|
QuoteStringIfNecessary( OUT TCHAR *szOutputString,
|
|
IN const TCHAR* const szInputString,
|
|
IN DWORD cbSize)
|
|
{
|
|
HRESULT hrPrintf;
|
|
|
|
if( DoesContainWhiteSpace( szInputString ) )
|
|
{
|
|
hrPrintf=StringCchPrintf( szOutputString, cbSize,
|
|
_T("\"%s\""),
|
|
szInputString );
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn( szOutputString, szInputString ,cbSize);
|
|
}
|
|
|
|
}
|