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.
2683 lines
74 KiB
2683 lines
74 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Params.c
|
|
|
|
Abstract:
|
|
|
|
Routines to write parameters file for use by text mode setup.
|
|
|
|
Author:
|
|
|
|
Ted Miller (tedm) 4 Nov 1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#define DEF_INF_BUFFER_SIZE (1<<15) //32KB
|
|
#define EMPTY_STRING TEXT("")
|
|
|
|
// Global used in WriteParamsFile and AddExternalParams
|
|
TCHAR ActualParamFile[MAX_PATH] = {'\0'};
|
|
|
|
//
|
|
// boot loader timeout value, in string form
|
|
//
|
|
TCHAR Timeout[32];
|
|
|
|
#ifdef PRERELEASE
|
|
//
|
|
// if we're in PRERELEASE mode, we will make a /debug entry
|
|
// in the OSLOADOPTIONSVARAPPEND entry.
|
|
//
|
|
BOOL AppendDebugDataToBoot = TRUE;
|
|
#endif
|
|
|
|
#if defined(UNICODE) && defined(_X86_)
|
|
extern TCHAR g_MigDllAnswerFilePath[MAX_PATH];
|
|
#endif
|
|
|
|
DWORD
|
|
PatchWinntSifFile(
|
|
IN LPCTSTR Filename
|
|
);
|
|
|
|
BOOL
|
|
AppendParamsFile(
|
|
IN HWND ParentWindow,
|
|
IN LPCTSTR ParametersFileIn,
|
|
IN LPCTSTR ParametersFileOut
|
|
);
|
|
|
|
BOOL
|
|
WriteCompatibilityData(
|
|
IN LPCTSTR FileName
|
|
);
|
|
|
|
VOID
|
|
WriteGUIModeInfOperations(
|
|
IN LPCTSTR FileName
|
|
);
|
|
|
|
BOOL
|
|
AddGUIModeCompatibilityInfsToCopyList();
|
|
|
|
BOOL
|
|
WriteTextmodeClobberData (
|
|
IN LPCTSTR FileName
|
|
);
|
|
|
|
VOID
|
|
SaveProxyForOobe(
|
|
IN LPCTSTR FileName
|
|
);
|
|
|
|
#if defined(_X86_)
|
|
|
|
VOID
|
|
SaveDriveLetterInformation (
|
|
IN LPCTSTR FileName
|
|
);
|
|
|
|
|
|
#endif
|
|
|
|
|
|
PCTSTR
|
|
pGetPfPath (
|
|
IN HKEY hKey,
|
|
IN PCTSTR ValueName
|
|
)
|
|
{
|
|
DWORD Size;
|
|
LONG rc;
|
|
PBYTE Data;
|
|
DWORD Type;
|
|
UINT DriveType;
|
|
TCHAR RootPath[] = TEXT("?:\\");
|
|
PTSTR QuotedData;
|
|
|
|
rc = RegQueryValueEx (
|
|
hKey,
|
|
ValueName,
|
|
NULL, // lpReserved
|
|
&Type,
|
|
NULL,
|
|
&Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
return NULL;
|
|
}
|
|
|
|
if (Type != REG_SZ && Type != REG_EXPAND_SZ) {
|
|
return NULL;
|
|
}
|
|
|
|
Data = MALLOC(Size + sizeof (TCHAR));
|
|
if (!Data) {
|
|
return NULL;
|
|
}
|
|
|
|
rc = RegQueryValueEx (
|
|
hKey,
|
|
ValueName,
|
|
NULL, // lpReserved
|
|
NULL, // type
|
|
Data,
|
|
&Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
FREE(Data);
|
|
return NULL;
|
|
}
|
|
|
|
*((PTSTR) (Data + Size)) = 0;
|
|
|
|
//
|
|
// Verify data is to a local path
|
|
//
|
|
|
|
RootPath[0] = *((PCTSTR) Data);
|
|
if (RootPath[0] == TEXT('\\')) {
|
|
DriveType = DRIVE_NO_ROOT_DIR;
|
|
} else {
|
|
DriveType = GetDriveType (RootPath);
|
|
}
|
|
|
|
if (DriveType != DRIVE_FIXED) {
|
|
FREE(Data);
|
|
return NULL;
|
|
}
|
|
|
|
QuotedData = (PTSTR) MALLOC(Size + sizeof (TCHAR) * 3);
|
|
if (!QuotedData) {
|
|
FREE(Data);
|
|
return NULL;
|
|
}
|
|
|
|
*QuotedData = TEXT('\"');
|
|
lstrcpy (QuotedData + 1, (PCTSTR) Data);
|
|
lstrcat (QuotedData, TEXT("\""));
|
|
|
|
FREE(Data);
|
|
|
|
return (PCTSTR) QuotedData;
|
|
}
|
|
|
|
|
|
BOOL
|
|
WriteHeadlessParameters(
|
|
IN LPCTSTR FileName
|
|
)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine writes the headless-specific parameters into the file
|
|
that is used to pass information to text mode setup.
|
|
|
|
Arguments:
|
|
|
|
FileName - specifies the full Win32 filename to use for the file.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether the file was written successfully.
|
|
If not, the user will have been informed about why.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL ReturnVal = TRUE;
|
|
|
|
//
|
|
// ISSUE - why MAX_PATH*2 ?
|
|
//
|
|
TCHAR Text[MAX_PATH*2];
|
|
|
|
//
|
|
// Check the global and see if anyone has set any headless parameters.
|
|
//
|
|
if( HeadlessSelection[0] != TEXT('\0') ) {
|
|
|
|
//
|
|
// Write the settings into the unattend file so textmode will
|
|
// fire up through up a headless port.
|
|
//
|
|
if( !WritePrivateProfileString(WINNT_DATA,WINNT_U_HEADLESS_REDIRECT,HeadlessSelection,FileName)) {
|
|
ReturnVal = FALSE;
|
|
}
|
|
|
|
if( HeadlessBaudRate == 0 ) {
|
|
wsprintf( Text, TEXT("%d"), 9600 );
|
|
} else {
|
|
wsprintf( Text, TEXT("%d"), HeadlessBaudRate );
|
|
}
|
|
|
|
if( !WritePrivateProfileString(WINNT_DATA,WINNT_U_HEADLESS_REDIRECTBAUDRATE,Text,FileName)) {
|
|
ReturnVal = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return( ReturnVal );
|
|
|
|
}
|
|
|
|
BOOL WritePidToParametersFile(LPCTSTR Section, LPCTSTR Key, LPCTSTR FileName)
|
|
{
|
|
BOOL b = FALSE;
|
|
LPTSTR Line = NULL;
|
|
LPTSTR pid;
|
|
if (g_EncryptedPID)
|
|
{
|
|
pid = g_EncryptedPID;
|
|
}
|
|
else
|
|
{
|
|
pid = ProductId;
|
|
}
|
|
Line = GlobalAlloc(GPTR, (lstrlen(pid) + 3) * sizeof(TCHAR));
|
|
if (Line)
|
|
{
|
|
*Line = TEXT('\"');
|
|
lstrcpy(&Line[1], pid);
|
|
lstrcat(Line,TEXT("\""));
|
|
b = WritePrivateProfileString(Section,Key,Line,FileName);
|
|
GlobalFree(Line);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
MigrateUnattendDataEntries(
|
|
IN LPCTSTR FileName,
|
|
IN LPTSTR UnattendedScriptFile
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
This routine writes out the keys under [Data] section of an unattend file
|
|
in to the winnt.sif file. This routine is specific to the following keys
|
|
AutoPartition and
|
|
UseBIOSToBoot
|
|
|
|
Arguments:
|
|
|
|
FileName - specifies the full Win32 filename to use for the file.
|
|
|
|
UnattendedScriptFile - Unattend Script File.
|
|
|
|
Return Value:
|
|
|
|
TRUE/FALSE
|
|
--*/
|
|
{
|
|
BOOL ReturnVal = FALSE;
|
|
//
|
|
// If Unattend file exists then migrate the keys under [Data] section.
|
|
//
|
|
if (UnattendedScriptFile){
|
|
CONST ULONG BufSize = 256;
|
|
PTSTR TmpString = (PTSTR)MALLOC(BufSize * sizeof (TCHAR));
|
|
ReturnVal = TRUE;
|
|
|
|
if( NULL != TmpString){
|
|
//
|
|
// Array of keys to be checked
|
|
//
|
|
LPCTSTR KeysToBeMigrated[] = { WINNT_D_AUTO_PART,
|
|
WINNT_D_BIOSTOBOOT
|
|
};
|
|
LPCTSTR WinntDataSection = WINNT_DATA;
|
|
ULONG i = 0;
|
|
|
|
for(i=0; i < ARRAYSIZE(KeysToBeMigrated); i++){
|
|
if(GetPrivateProfileString(WinntDataSection,
|
|
KeysToBeMigrated[i],
|
|
EMPTY_STRING,
|
|
TmpString,
|
|
BufSize,
|
|
UnattendedScriptFile)){
|
|
|
|
if (!WritePrivateProfileString( WinntDataSection,
|
|
KeysToBeMigrated[i],
|
|
TmpString,
|
|
FileName)) {
|
|
DWORD LastError = GetLastError();
|
|
DebugLog ( Winnt32LogError,
|
|
TEXT("MigrateUnattendDatEntries : Error writing to file %1, Section: %2, Key: %3"),
|
|
0,
|
|
FileName,
|
|
WinntDataSection,
|
|
KeysToBeMigrated[i]);
|
|
|
|
ReturnVal = FALSE;
|
|
SetLastError(LastError);
|
|
}
|
|
}
|
|
|
|
}
|
|
FREE(TmpString);
|
|
|
|
}else{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
ReturnVal = FALSE;
|
|
}
|
|
|
|
}
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return ReturnVal;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
DoWriteParametersFile(
|
|
IN HWND ParentWindow,
|
|
IN LPCTSTR FileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine generates a parameters file that is used to pass information
|
|
to text mode setup.
|
|
|
|
Arguments:
|
|
|
|
ParentWindow - supplies window handle of window to be used as the
|
|
parent/owner in case this routine puts up UI.
|
|
|
|
FileName - specifies the full Win32 filename to use for the file.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether the file was written successfully.
|
|
If not, the user will have been informed about why.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR FullPath[MAX_PATH], *t;
|
|
TCHAR Text[MAX_PATH*2];
|
|
LPTSTR OptionalDirString,OptDir;
|
|
UINT OptionalDirLength;
|
|
DWORD d=NO_ERROR;
|
|
PVOID p;
|
|
BOOL b;
|
|
LONG l;
|
|
HKEY hKey;
|
|
PCTSTR PfPath;
|
|
LONG rc;
|
|
|
|
LPCTSTR WinntDataSection = WINNT_DATA;
|
|
LPCTSTR WinntSetupSection = WINNT_SETUPPARAMS;
|
|
LPCTSTR WinntAccessSection = WINNT_ACCESSIBILITY;
|
|
LPCTSTR WinntSetupDataSection = TEXT("SetupData");
|
|
#if defined(REMOTE_BOOT)
|
|
LPCTSTR WinntUserDataSection = TEXT("UserData");
|
|
#endif // defined(REMOTE_BOOT)
|
|
LPCTSTR WinntUniqueId = WINNT_D_UNIQUEID;
|
|
LPCTSTR WinntNull = WINNT_A_NULL;
|
|
LPCTSTR WinntUserSection = WINNT_USERDATA;
|
|
|
|
if( !FileName )
|
|
d=ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// Make sure path for file is present, and form its fully qualified name.
|
|
//
|
|
if(d == NO_ERROR){
|
|
StringCchCopy(FullPath, ARRAYSIZE(FullPath), FileName);
|
|
if((t=_tcsrchr(FullPath,TEXT('\\')))) {
|
|
*t= 0;
|
|
d = CreateMultiLevelDirectory(FullPath);
|
|
}else
|
|
d=ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
if(d != NO_ERROR) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_DIR_CREATE_FAILED,
|
|
d,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
FullPath
|
|
);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Get rid of any existing parameters file.
|
|
//
|
|
DeleteFile(FileName);
|
|
|
|
#ifdef _X86_
|
|
|
|
if (!ISNT()) {
|
|
|
|
//
|
|
// If this is a 9x machine, we need to preserve the drive letters, even
|
|
// if it is an NT clean install.
|
|
//
|
|
|
|
SaveDriveLetterInformation (FileName);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Value indicating that this is winnt/winnt32-based installation,
|
|
// and on amd64/x86, value to indicate that this is a floppyless operation
|
|
// as apropriate.
|
|
//
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_MSDOS,TEXT("1"),FileName);
|
|
if (b && HideWinDir) {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("HideWinDir"),TEXT("1"),FileName);
|
|
}
|
|
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
if(b && Floppyless) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_FLOPPY,TEXT("1"),FileName);
|
|
}
|
|
|
|
if (b && BuildCmdcons) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_CMDCONS,TEXT("1"),FileName);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} // if (!IsArc())
|
|
|
|
if(b && RunFromCD && !MakeLocalSource) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_LOCALSRC_CD,TEXT("1"),FileName);
|
|
}
|
|
if (b) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_AUTO_PART,ChoosePartition?TEXT("0"):TEXT("1"),FileName);
|
|
}
|
|
|
|
if (b && UseSignatures) {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("UseSignatures"),WINNT_A_YES,FileName);
|
|
}
|
|
if (b && InstallDir[0] && (ISNT() || !Upgrade)) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_INSTALLDIR,InstallDir,FileName);
|
|
}
|
|
if (b && EulaComplete) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_EULADONE,TEXT("1"),FileName);
|
|
}
|
|
if (b && NoLs && !MakeLocalSource) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_NOLS,TEXT("1"),FileName);
|
|
}
|
|
|
|
if (b && UseBIOSToBoot) {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("UseBIOSToBoot"),TEXT("1"),FileName);
|
|
}
|
|
|
|
if (b && WriteAcpiHalValue && Upgrade) {
|
|
if (AcpiHalValue) {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("AcpiHAL"),TEXT("1"),FileName);
|
|
} else {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("AcpiHAL"),TEXT("0"),FileName);
|
|
}
|
|
}
|
|
if (b && IgnoreExceptionPackages) {
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("IgnoreExceptionPackages"),TEXT("1"),FileName);
|
|
}
|
|
|
|
#ifdef PRERELEASE
|
|
if (b && AppendDebugDataToBoot) {
|
|
if (!AsrQuickTest) {
|
|
b = WritePrivateProfileString(WinntSetupDataSection,TEXT("OsLoadOptionsVarAppend"),TEXT("/Debug"),FileName);
|
|
}
|
|
else {
|
|
b = WritePrivateProfileString(WinntSetupDataSection,TEXT("OsLoadOptionsVarAppend"),TEXT("/Debug /Baudrate=115200"),FileName);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (b && AsrQuickTest) {
|
|
wsprintf(Text, TEXT("%d"), AsrQuickTest);
|
|
b = WritePrivateProfileString(WinntDataSection,TEXT("AsrMode"),Text,FileName);
|
|
}
|
|
|
|
if (b && (RunningBVTs || AsrQuickTest)) {
|
|
if (lDebugBaudRate == 1394) {
|
|
// kd via 1394
|
|
lstrcpy(Text, TEXT("/debug /debugport=1394"));
|
|
} else if (lDebugComPort == 0) {
|
|
wsprintf(Text, TEXT("/debug /baudrate=%d"), lDebugBaudRate);
|
|
} else {
|
|
wsprintf(Text, TEXT("/debug /baudrate=%d /debugport=com%d"), lDebugBaudRate, lDebugComPort);
|
|
}
|
|
|
|
// write the string to OsLoadOptions so "textmode" setup to run under the debugger
|
|
b = WritePrivateProfileString(WinntSetupDataSection,TEXT("OsLoadOptions"),Text,FileName);
|
|
|
|
if (b) {
|
|
// write the string to OsLoadOptionsVar so guimode setup to run under the debugger
|
|
b = WritePrivateProfileString(WinntSetupDataSection,TEXT("OsLoadOptionsVar"),Text,FileName);
|
|
|
|
if (b) {
|
|
// also run guimode's setup.exe under NTSD. The -isd switch is needed to ensure that setup.exe starts
|
|
// without a global system manifest since winlogon spawns it with the CREATE_IGNORE_SYSTEM_DEFAULT flag,
|
|
// and ntsd normall calls CreateProcess which would undo the above flag.
|
|
b = WritePrivateProfileString(WinntSetupDataSection,TEXT("SetupCmdlinePrepend"),TEXT("ntsd -isd -odgGx"),FileName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (b && Timeout[0]) {
|
|
|
|
b = WritePrivateProfileString(WinntSetupDataSection,WINNT_S_OSLOADTIMEOUT,Timeout,FileName);
|
|
}
|
|
|
|
if(b) {
|
|
//
|
|
// Write upgrade stuff. WinntUpgrade and Win95Upgrade will both be set,
|
|
// and at most one of them will be set to yes.
|
|
//
|
|
if(b = WritePrivateProfileString(WinntDataSection,WINNT_D_NTUPGRADE,WINNT_A_NO,FileName)) {
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_WIN95UPGRADE,WINNT_A_NO,FileName);
|
|
}
|
|
if(b) {
|
|
wsprintf(Text,TEXT("%x"),GetVersion());
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_WIN32_VER,Text,FileName);
|
|
if(b && Upgrade) {
|
|
b = WritePrivateProfileString(
|
|
WinntDataSection,
|
|
ISNT() ? WINNT_D_NTUPGRADE : WINNT_D_WIN95UPGRADE,
|
|
WINNT_A_YES,
|
|
FileName
|
|
);
|
|
|
|
|
|
MyGetWindowsDirectory(Text,MAX_PATH);
|
|
Text[2] = 0;
|
|
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_WIN32_DRIVE,Text,FileName);
|
|
if(b) {
|
|
Text[2] = TEXT('\\');
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_WIN32_PATH,Text+2,FileName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Flags for Accessible Setup
|
|
//
|
|
AccessibleSetup = FALSE;
|
|
|
|
if(!Upgrade) {
|
|
if(b && AccessibleMagnifier) {
|
|
b = WritePrivateProfileString(WinntAccessSection,WINNT_D_ACC_MAGNIFIER,
|
|
TEXT("1"),FileName);
|
|
AccessibleSetup = TRUE;
|
|
}
|
|
if(b && AccessibleReader) {
|
|
b = WritePrivateProfileString(WinntAccessSection,WINNT_D_ACC_READER,
|
|
TEXT("1"),FileName);
|
|
AccessibleSetup = TRUE;
|
|
}
|
|
if(b && AccessibleKeyboard) {
|
|
b = WritePrivateProfileString(WinntAccessSection,WINNT_D_ACC_KEYBOARD,
|
|
TEXT("1"),FileName);
|
|
AccessibleSetup = TRUE;
|
|
}
|
|
}
|
|
|
|
if(b && AccessibleSetup && !UnattendedOperation) {
|
|
UnattendedOperation = TRUE;
|
|
UnattendedShutdownTimeout = 0;
|
|
UnattendedScriptFile = MALLOC(MAX_PATH * sizeof(TCHAR));
|
|
b = (UnattendedScriptFile != NULL);
|
|
if(b) {
|
|
lstrcpy(UnattendedScriptFile,NativeSourcePaths[0]);
|
|
ConcatenatePaths(UnattendedScriptFile,AccessibleScriptFile,MAX_PATH);
|
|
}
|
|
}
|
|
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Value indicating we're automatically and quietly skipping missing files.
|
|
//
|
|
if(AutoSkipMissingFiles) {
|
|
b = WritePrivateProfileString(WinntSetupSection,WINNT_S_SKIPMISSING,TEXT("1"),FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Command to be executed at end of GUI setup, if any.
|
|
//
|
|
if(CmdToExecuteAtEndOfGui) {
|
|
|
|
b = WritePrivateProfileString(
|
|
WinntSetupSection,
|
|
WINNT_S_USEREXECUTE,
|
|
CmdToExecuteAtEndOfGui,
|
|
FileName
|
|
);
|
|
|
|
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Ensure that Plug and Play state in upgraded os will be the same as the
|
|
// original. Enables per-device settings to be preserved in the NT5+
|
|
// upgrade scenario.
|
|
//
|
|
if (ISNT() && (BuildNumber > NT40) && Upgrade) {
|
|
LPTSTR buffer = NULL;
|
|
|
|
if (MigrateDeviceInstanceData(&buffer)) {
|
|
WritePrivateProfileSection(WINNT_DEVICEINSTANCES,
|
|
buffer,
|
|
FileName);
|
|
//
|
|
// Free the allocated buffer that was returned
|
|
//
|
|
LocalFree(buffer);
|
|
buffer = NULL;
|
|
}
|
|
|
|
if (MigrateClassKeys(&buffer)) {
|
|
WritePrivateProfileSection(WINNT_CLASSKEYS,
|
|
buffer,
|
|
FileName);
|
|
//
|
|
// Free the allocated buffer that was returned
|
|
//
|
|
LocalFree(buffer);
|
|
buffer = NULL;
|
|
}
|
|
|
|
if (MigrateHashValues(&buffer)) {
|
|
WritePrivateProfileSection(WINNT_DEVICEHASHVALUES,
|
|
buffer,
|
|
FileName);
|
|
//
|
|
// Free the allocated buffer that was returned
|
|
//
|
|
LocalFree(buffer);
|
|
buffer = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remember udf info. If there's a database file, stick a * on the end
|
|
// of the ID before writing it.
|
|
//
|
|
if(UniquenessId) {
|
|
|
|
d = lstrlen(UniquenessId);
|
|
if(d >= (MAX_PATH-1)) {
|
|
d--;
|
|
}
|
|
lstrcpyn(Text,UniquenessId,MAX_PATH-1);
|
|
if(UniquenessDatabaseFile) {
|
|
Text[d] = TEXT('*');
|
|
Text[d+1] = 0;
|
|
}
|
|
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_UNIQUENESS,Text,FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
if(UniquenessDatabaseFile) {
|
|
|
|
if ('\0' == LocalSourceDirectory[0]) {
|
|
MessageBoxFromMessage(
|
|
ParentWindow,
|
|
MSG_UDF_INVALID_USAGE,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
UniquenessDatabaseFile
|
|
);
|
|
goto c0;
|
|
}
|
|
|
|
lstrcpyn(Text,LocalSourceDirectory,MAX_PATH);
|
|
ConcatenatePaths(Text,WINNT_UNIQUENESS_DB,MAX_PATH);
|
|
|
|
CreateMultiLevelDirectory(LocalSourceDirectory);
|
|
b = CopyFile(UniquenessDatabaseFile,Text,FALSE);
|
|
if(!b) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_UDF_FILE_INVALID,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
UniquenessDatabaseFile
|
|
);
|
|
|
|
goto c0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If any optional dirs are present then we want to generate
|
|
// an entry in the sif file that contains a line that specifies them
|
|
// in the form dir1*dir2*...*dirn
|
|
//
|
|
OptionalDirLength = 0;
|
|
OptionalDirString = NULL;
|
|
|
|
for(d=0; d<OptionalDirectoryCount; d++) {
|
|
//
|
|
// Ignore temp-only and oem directories here.
|
|
//
|
|
if(OptionalDirectoryFlags[d] & (OPTDIR_OEMSYS | OPTDIR_TEMPONLY | OPTDIR_OVERLAY)) {
|
|
continue;
|
|
}
|
|
|
|
if (OptionalDirectoryFlags[d] & (OPTDIR_DEBUGGER)) {
|
|
// hardcode the dest dir to "Debuggers"
|
|
OptDir = TEXT("Debuggers");
|
|
} else {
|
|
if (OptionalDirectoryFlags[d] & OPTDIR_USE_TAIL_FOLDER_NAME) {
|
|
//
|
|
// create all copydir: directories in a subdirectory under target %windir%
|
|
//
|
|
OptDir = _tcsrchr (OptionalDirectories[d], TEXT('\\'));
|
|
if (OptDir) {
|
|
OptDir++;
|
|
} else {
|
|
OptDir = OptionalDirectories[d];
|
|
}
|
|
} else {
|
|
OptDir = OptionalDirectories[d];
|
|
}
|
|
}
|
|
|
|
//
|
|
// support ".." syntax
|
|
//
|
|
while (_tcsstr(OptDir,TEXT("..\\"))) {
|
|
OptDir += 3;
|
|
}
|
|
|
|
if(OptionalDirString) {
|
|
|
|
p = REALLOC(
|
|
OptionalDirString,
|
|
(lstrlen(OptDir) + 2 + OptionalDirLength) * sizeof(TCHAR)
|
|
);
|
|
} else {
|
|
p = MALLOC((lstrlen(OptDir)+2)*sizeof(TCHAR));
|
|
}
|
|
|
|
if(!p) {
|
|
if(OptionalDirString) {
|
|
FREE(OptionalDirString);
|
|
}
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
goto c1;
|
|
}
|
|
|
|
OptionalDirString = p;
|
|
|
|
if(OptionalDirLength) {
|
|
lstrcat(OptionalDirString,OptDir);
|
|
} else {
|
|
lstrcpy(OptionalDirString,OptDir);
|
|
}
|
|
|
|
lstrcat(OptionalDirString,TEXT("*"));
|
|
OptionalDirLength = lstrlen(OptionalDirString);
|
|
}
|
|
|
|
if(OptionalDirString) {
|
|
//
|
|
// Remove trailing * if any
|
|
//
|
|
d = lstrlen(OptionalDirString);
|
|
if(d && (OptionalDirString[d-1] == TEXT('*'))) {
|
|
OptionalDirString[d-1] = 0;
|
|
}
|
|
|
|
b = WritePrivateProfileString(
|
|
WinntSetupSection,
|
|
WINNT_S_OPTIONALDIRS,
|
|
OptionalDirString,
|
|
FileName
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
FREE(OptionalDirString);
|
|
|
|
if(!b) {
|
|
SetLastError(d);
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Slap a unique identifier into the registry.
|
|
// We'll use this in unattended upgrade during text mode
|
|
// to find this build.
|
|
//
|
|
// Pretty simple: we'll use a string that derives
|
|
// from the sysroot, and some unique value based on
|
|
// the current tick count.
|
|
//
|
|
l = RegCreateKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\Setup"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_SET_VALUE,
|
|
NULL,
|
|
&hKey,
|
|
&d
|
|
);
|
|
|
|
if(l != NO_ERROR) {
|
|
SetLastError(l);
|
|
goto c2;
|
|
}
|
|
|
|
d = MyGetWindowsDirectory(Text,MAX_PATH);
|
|
if((d + 5) > MAX_PATH) {
|
|
d = MAX_PATH - 5;
|
|
}
|
|
|
|
Text[d++] = TEXT('\\');
|
|
Text[d++] = (TCHAR)(((GetTickCount() & 0x00f) >> 0) + 'A');
|
|
Text[d++] = (TCHAR)(((GetTickCount() & 0x0f0) >> 4) + 'A');
|
|
Text[d++] = (TCHAR)(((GetTickCount() & 0xf00) >> 8) + 'A');
|
|
Text[d++] = 0;
|
|
|
|
//
|
|
// Set the value in the registry.
|
|
//
|
|
l = RegSetValueEx(hKey,WinntUniqueId,0,REG_SZ,(CONST BYTE *)Text,d*sizeof(TCHAR));
|
|
if(l == NO_ERROR) {
|
|
l = RegFlushKey (hKey);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
if(l != NO_ERROR) {
|
|
SetLastError(l);
|
|
goto c2;
|
|
}
|
|
|
|
//
|
|
// Stick the value in winnt.sif so we can correlate
|
|
// later when we go to upgrade.
|
|
//
|
|
b = WritePrivateProfileString(WinntDataSection,WinntUniqueId,Text,FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Now write information about the source path(s) we used.
|
|
// Use SourcePath[0].
|
|
//
|
|
// If the name starts with \\ then we assume it's UNC and
|
|
// just use it directly. Otherwise we call MyGetDriveType on it
|
|
// and if it's a network drive we get the UNC path.
|
|
// Otherwise we just go ahead and save as-is.
|
|
// Also save the type.
|
|
//
|
|
if((SourcePaths[0][0] == TEXT('\\')) && (SourcePaths[0][1] == TEXT('\\'))) {
|
|
|
|
d = DRIVE_REMOTE;
|
|
lstrcpy(Text,SourcePaths[0]);
|
|
|
|
} else {
|
|
if(GetFullPathName(SourcePaths[0],MAX_PATH,FullPath,(LPTSTR *)&p)) {
|
|
if(FullPath[0] == TEXT('\\')) {
|
|
//
|
|
// Assume UNC, since a full path should normally start
|
|
// with a drive letter.
|
|
//
|
|
d = DRIVE_REMOTE;
|
|
lstrcpy(Text,FullPath);
|
|
} else {
|
|
d = MyGetDriveType(FullPath[0]);
|
|
if((d == DRIVE_REMOTE) && (FullPath[1] == TEXT(':')) && (FullPath[2] == TEXT('\\'))) {
|
|
//
|
|
// Get actual UNC path.
|
|
//
|
|
FullPath[2] = 0;
|
|
l = MAX_PATH;
|
|
|
|
if(WNetGetConnection(FullPath,Text,(LPDWORD)&l) == NO_ERROR) {
|
|
|
|
l = lstrlen(Text);
|
|
if(l && (Text[l-1] != TEXT('\\')) && FullPath[3]) {
|
|
Text[l] = TEXT('\\');
|
|
Text[l+1] = 0;
|
|
}
|
|
StringCchCat(Text, ARRAYSIZE(Text), FullPath+3);
|
|
} else {
|
|
//
|
|
// Strange case.
|
|
//
|
|
FullPath[2] = TEXT('\\');
|
|
lstrcpy(Text,FullPath);
|
|
d = DRIVE_UNKNOWN;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Use as-is.
|
|
//
|
|
if(d == DRIVE_REMOTE) {
|
|
d = DRIVE_UNKNOWN;
|
|
}
|
|
lstrcpy(Text,FullPath);
|
|
}
|
|
}
|
|
} else {
|
|
//
|
|
// Type is unknown. Just use as-is.
|
|
//
|
|
d = DRIVE_UNKNOWN;
|
|
lstrcpy(Text,SourcePaths[0]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// In the preinstall case ignore all the above and
|
|
// force gui setup to search for a CD.
|
|
// This particular combination of values will do it.
|
|
//
|
|
if(OemPreinstall) {
|
|
|
|
//
|
|
// marcw (7-22-97) - Changed to fix alpha build break.
|
|
// FirstFloppyDriveLetter is defined on amd64/X86s only.
|
|
//
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
Text[0] = FirstFloppyDriveLetter;
|
|
Text[1] = TEXT(':');
|
|
Text[2] = TEXT('\\');
|
|
Text[3] = 0;
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
lstrcpy(Text,TEXT("A:\\"));
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
|
|
if (LocalSourceWithPlatform[0]) {
|
|
|
|
ConcatenatePaths(
|
|
Text,
|
|
&LocalSourceWithPlatform[lstrlen(LocalSourceDirectory)],
|
|
MAX_PATH
|
|
);
|
|
|
|
}
|
|
|
|
d = DRIVE_CDROM;
|
|
}
|
|
|
|
b = WritePrivateProfileString(WinntDataSection,WINNT_D_ORI_SRCPATH,Text,FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
//
|
|
// If this is a remote boot upgrade, write the source path to SetupSourceDevice
|
|
// under [SetupData]. We do NOT want the platform path here. Also write the
|
|
// path to the machine directory to TargetNtPartition under [SetupData]. This
|
|
// is just whatever \DosDevices\C: translates to. Finally, write the computer
|
|
// name to ComputerName under [UserData].
|
|
//
|
|
if (RemoteBoot) {
|
|
|
|
DWORD len;
|
|
|
|
MYASSERT(d == DRIVE_REMOTE);
|
|
MYASSERT((*Text == TEXT('\\')) && (*(Text + 1) == TEXT('\\')));
|
|
|
|
lstrcpy(FullPath, TEXT("\\Device\\LanmanRedirector"));
|
|
ConcatenatePaths(FullPath, Text+1, MAX_PATH);
|
|
|
|
p = _tcsrchr(FullPath,TEXT('\\'));
|
|
MYASSERT(p != NULL);
|
|
*(LPTSTR)p = 0;
|
|
|
|
b = WritePrivateProfileString(
|
|
WinntSetupDataSection,
|
|
TEXT("SetupSourceDevice"),
|
|
FullPath,
|
|
FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
|
|
MyGetWindowsDirectory(Text, MAX_PATH);
|
|
Text[2] = 0;
|
|
len = QueryDosDevice(Text, Text, MAX_PATH);
|
|
if (len == 0) {
|
|
goto c1;
|
|
}
|
|
b = WritePrivateProfileString(
|
|
WinntSetupDataSection,
|
|
TEXT("TargetNtPartition"),
|
|
Text,
|
|
FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
|
|
len = MAX_PATH;
|
|
b = GetComputerName(Text, &len);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
b = WritePrivateProfileString(
|
|
WinntUserDataSection,
|
|
WINNT_US_COMPNAME,
|
|
Text,
|
|
FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
}
|
|
#endif // defined(REMOTE_BOOT)
|
|
|
|
wsprintf(Text,TEXT("%u"),d);
|
|
WritePrivateProfileString(WinntDataSection,WINNT_D_ORI_SRCTYPE,Text,FileName);
|
|
if(!b) {
|
|
goto c1;
|
|
}
|
|
#ifdef _X86_
|
|
//
|
|
// NT 4 and Win95 for NEC98 have 2 types Drive assing.
|
|
// - NEC DOS Type(A: HD, B:HD,...X:FD)
|
|
// - PC-AT Type(A:FD, B:FD, C:HD, D:HD, ....)
|
|
//
|
|
// Upgrade setup should be keep above drive assign and All setup should
|
|
// be keep FT information.
|
|
// Because some Applications have drive letter in own data file or registry.
|
|
// NT5 setup for NEC98 have Drive assign type in winnt.sif section[data].
|
|
// And this key is "DriveAssign_Nec98".
|
|
// Value is "yes", It means NEC DOS Type assign.
|
|
// Value is "no", It means PC-AT Type.
|
|
// Now, This Key defined this place, but near future, this key move into
|
|
// \nt\public\sdk\inc\setupbat.h, I hope.
|
|
//
|
|
// \textmode\kernel\spsetup.c has same defines.
|
|
//
|
|
|
|
#define WINNT_D_DRIVEASSIGN_NEC98_W L"DriveAssign_Nec98"
|
|
#define WINNT_D_DRIVEASSIGN_NEC98_A "DriveAssign_Nec98"
|
|
|
|
#ifdef UNICODE
|
|
#define WINNT_D_DRIVEASSIGN_NEC98 WINNT_D_DRIVEASSIGN_NEC98_W
|
|
#else
|
|
#define WINNT_D_DRIVEASSIGN_NEC98 WINNT_D_DRIVEASSIGN_NEC98_A
|
|
#endif
|
|
|
|
if (IsNEC98()){
|
|
if (IsDriveAssignNEC98() == TRUE){
|
|
WritePrivateProfileString(WinntDataSection, WINNT_D_DRIVEASSIGN_NEC98, WINNT_A_YES, FileName);
|
|
} else {
|
|
WritePrivateProfileString(WinntDataSection, WINNT_D_DRIVEASSIGN_NEC98, WINNT_A_NO, FileName);
|
|
|
|
}
|
|
}
|
|
#endif
|
|
//
|
|
// At this point we process the file, and surround all values with
|
|
// double-quotes. This gets around certain problems in the various
|
|
// inf parsers used in later stages of setup. Do this BEFORE appending
|
|
// the unattend stript file, because some of the stuff in there expects
|
|
// to be treated as multiple values, which double quotes ruin.
|
|
//
|
|
WritePrivateProfileString(NULL,NULL,NULL,FileName);
|
|
d = PatchWinntSifFile(FileName);
|
|
if(d != NO_ERROR) {
|
|
SetLastError(d);
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Language options
|
|
// Note: we don't want these values surrounded by double-quotes.
|
|
//
|
|
if( SaveLanguageParams( FileName ) ) {
|
|
FreeLanguageData();
|
|
} else {
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Append unattend script file if necessary.
|
|
//
|
|
if(UnattendedOperation && UnattendedScriptFile) {
|
|
if (!MigrateUnattendDataEntries(FileName, UnattendedScriptFile)){
|
|
goto c1;
|
|
}
|
|
|
|
if(!AppendParamsFile(ParentWindow,UnattendedScriptFile,FileName)) {
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
#if defined(UNICODE) && defined(_X86_)
|
|
//
|
|
// Append any migdll info.
|
|
//
|
|
if (Upgrade && ISNT() && *g_MigDllAnswerFilePath && FileExists (g_MigDllAnswerFilePath, NULL)) {
|
|
AppendParamsFile (ParentWindow, g_MigDllAnswerFilePath, FileName);
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
//
|
|
// append DynamicUpdate data
|
|
//
|
|
if (!DynamicUpdateWriteParams (FileName)) {
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// If we're explicitly in unattended mode then it's possible that
|
|
// there is no [Unattended] section in winnt.sif yet, such as if
|
|
// the user used the /unattend switch without specifying a file,
|
|
// or if the file he did specify didn't have an [Unattended] section
|
|
// for some reason.
|
|
//
|
|
// Also, make all upgrades unattended.
|
|
//
|
|
// Text mode setup kicks into unattended mode based on the presence
|
|
// of the [Unattended] section.
|
|
//
|
|
if(UnattendedOperation || Upgrade) {
|
|
if(!WritePrivateProfileString(WINNT_UNATTENDED,TEXT("unused"),TEXT("unused"),FileName)) {
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Since several conditions can turn on UnattendedOperation, we keep track
|
|
// of whether the user actually specified the "/unattend" switch separately.
|
|
//
|
|
if( UnattendSwitchSpecified ) {
|
|
if(!WritePrivateProfileString(WinntDataSection,WINNT_D_UNATTEND_SWITCH,WINNT_A_YES,FileName)) {
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// set the NTFS conversion flag
|
|
//
|
|
GetPrivateProfileString(WINNT_UNATTENDED,TEXT("FileSystem"),TEXT(""),Text,sizeof(Text)/sizeof(TCHAR),FileName);
|
|
if (_tcslen(Text) == 0) {
|
|
if (ForceNTFSConversion) {
|
|
if(!WritePrivateProfileString(WinntDataSection,TEXT("FileSystem"),TEXT("ConvertNTFS"),FileName)) {
|
|
goto c1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Headless Stuff.
|
|
//
|
|
if( !WriteHeadlessParameters( FileName ) ) {
|
|
goto c1;
|
|
}
|
|
|
|
|
|
|
|
if ( (Upgrade) &&
|
|
!(ISNT() && (BuildNumber <= NT351)) ) {
|
|
|
|
//
|
|
// Save current Program Files directory
|
|
//
|
|
|
|
rc = RegOpenKeyEx (
|
|
HKEY_LOCAL_MACHINE,
|
|
TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"),
|
|
0, //ulOptions (reserved)
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
goto c1;
|
|
}
|
|
|
|
PfPath = pGetPfPath (hKey, TEXT("ProgramFilesDir"));
|
|
if (PfPath) {
|
|
if (!WritePrivateProfileString (
|
|
WINNT_UNATTENDED,
|
|
WINNT_U_PROGRAMFILESDIR,
|
|
PfPath,
|
|
FileName
|
|
)) {
|
|
goto c3;
|
|
}
|
|
|
|
FREE((PVOID) PfPath);
|
|
}
|
|
|
|
PfPath = pGetPfPath (hKey, TEXT("CommonFilesDir"));
|
|
if (PfPath) {
|
|
if (!WritePrivateProfileString (
|
|
WINNT_UNATTENDED,
|
|
WINNT_U_COMMONPROGRAMFILESDIR,
|
|
PfPath,
|
|
FileName
|
|
)) {
|
|
goto c3;
|
|
}
|
|
|
|
FREE((PVOID) PfPath);
|
|
}
|
|
|
|
#ifdef WX86
|
|
|
|
PfPath = pGetPfPath (hKey, TEXT("ProgramFilesDir (x86)"));
|
|
if (PfPath) {
|
|
if (!WritePrivateProfileString (
|
|
WINNT_UNATTENDED,
|
|
WINNT_U_PROGRAMFILESDIR_X86,
|
|
PfPath,
|
|
FileName
|
|
)) {
|
|
goto c3;
|
|
}
|
|
|
|
FREE((PVOID) PfPath);
|
|
}
|
|
|
|
PfPath = pGetPfPath (hKey, TEXT("CommonFilesDir (x86)"));
|
|
if (PfPath) {
|
|
if (!WritePrivateProfileString (
|
|
WINNT_UNATTENDED,
|
|
WINNT_U_COMMONPROGRAMFILESDIR_X86,
|
|
PfPath,
|
|
FileName
|
|
)) {
|
|
goto c3;
|
|
}
|
|
|
|
FREE((PVOID) PfPath);
|
|
}
|
|
|
|
#endif
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
//
|
|
// value indicating the product ID
|
|
// we need to write this in after appending the unattend file data, since the
|
|
// product ID in the unattend file may have been incorrect, but this product ID
|
|
// has already been verified as valid. we need to make sure we surround the product ID with quotes
|
|
//
|
|
if (b ) {
|
|
// This will overwrite any existing "ProductID" entry. Which may have been added
|
|
// by merging the unattend file.
|
|
// If we don't do this. GUI mode overwrites the "ProductKey" with the entry
|
|
// under "ProductID".
|
|
b = WritePidToParametersFile(WinntUserSection,WINNT_US_PRODUCTID,FileName);
|
|
if (!b) {
|
|
goto c1;
|
|
}
|
|
|
|
b = WritePidToParametersFile(WinntUserSection,WINNT_US_PRODUCTKEY,FileName);
|
|
if (!b) {
|
|
goto c1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Do not save the proxy settings if we are running under WINPE.
|
|
//
|
|
if (!IsWinPEMode()){
|
|
SaveProxyForOobe(FileName);
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
|
|
c3:
|
|
FREE((PVOID) PfPath);
|
|
RegCloseKey(hKey);
|
|
|
|
c2:
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_REGISTRY_ACCESS_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
NULL
|
|
);
|
|
goto c0;
|
|
|
|
c1:
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
FileName
|
|
);
|
|
c0:
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
PatchWinntSifFile(
|
|
IN LPCTSTR Filename
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function works around the problems in the setupldr parser,
|
|
which cannot handle unquoted strings. Each line in the given file
|
|
is enclosed within quotation marks.
|
|
|
|
Arguments:
|
|
|
|
Filename - Name of the WINNT.SIF file
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating outcome. If FALSE the user is NOT
|
|
informed about why; the caller must do that.
|
|
|
|
--*/
|
|
|
|
{
|
|
PVOID Base;
|
|
HANDLE hMap,hFile;
|
|
DWORD Size;
|
|
DWORD d;
|
|
PCHAR End;
|
|
PCHAR p,q;
|
|
PCHAR o,a;
|
|
PCHAR Buffer;
|
|
int l1,l2;
|
|
int tryagain=0;
|
|
|
|
//
|
|
// Open the file.
|
|
//
|
|
|
|
d = MapFileForRead(Filename,&Size,&hFile,&hMap,&Base);
|
|
if(d != NO_ERROR) {
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Allocate the output buffer; the original size + extra space for quotes
|
|
//
|
|
Buffer = MALLOC(Size + Size / 4);
|
|
if(!Buffer) {
|
|
UnmapFile(hMap,Base);
|
|
CloseHandle(hFile);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
o = Buffer;
|
|
p = Base;
|
|
End = p+Size;
|
|
|
|
while(p < End) {
|
|
//
|
|
// Find end of line.
|
|
//
|
|
for(q=p; (q < End) && (*q != '\n'); q++) {
|
|
NOTHING;
|
|
}
|
|
|
|
//
|
|
// Find equals sign, if present
|
|
//
|
|
for(a=p; a<q; a++) {
|
|
if(*a == '=') {
|
|
break;
|
|
}
|
|
}
|
|
if(a >= q) {
|
|
a = NULL;
|
|
}
|
|
|
|
if(a) {
|
|
|
|
a++;
|
|
|
|
l1 = (int)(a - p);
|
|
l2 = (int)(q - a);
|
|
|
|
CopyMemory(o,p,l1);
|
|
o += l1;
|
|
*o++ = '\"';
|
|
CopyMemory(o,a,l2);
|
|
o += l2;
|
|
if(*(o-1) == '\r') {
|
|
o--;
|
|
}
|
|
*o++ = '\"';
|
|
*o++ = '\r';
|
|
*o++ = '\n';
|
|
|
|
} else {
|
|
|
|
l1 = (int)(q-p);
|
|
CopyMemory(o,p,l1);
|
|
o += l1;
|
|
*o++ = '\n';
|
|
}
|
|
|
|
//
|
|
// Skip to start of next line
|
|
//
|
|
p=q+1;
|
|
}
|
|
|
|
UnmapFile(hMap,Base);
|
|
CloseHandle(hFile);
|
|
|
|
SetFileAttributes(Filename,FILE_ATTRIBUTE_NORMAL);
|
|
//
|
|
// We try opening the file thrice to get around the problem of anti-virus software
|
|
// that monitor files on the root of the system partition. The problem is that usually these
|
|
// s/w examine the files we touch and in somecases open it with exclusive access.
|
|
// We just need to wait for them to be done.
|
|
//
|
|
|
|
|
|
while( tryagain++ < 3 ){
|
|
hFile = CreateFile(
|
|
Filename,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
if(hFile != INVALID_HANDLE_VALUE)
|
|
break;
|
|
Sleep(500);
|
|
|
|
}
|
|
|
|
|
|
if(hFile == INVALID_HANDLE_VALUE) {
|
|
d = GetLastError();
|
|
FREE(Buffer);
|
|
return(d);
|
|
}
|
|
|
|
d = WriteFile(hFile,Buffer,(DWORD)(o-Buffer),&Size,NULL) ? NO_ERROR : GetLastError();
|
|
|
|
CloseHandle(hFile);
|
|
FREE(Buffer);
|
|
|
|
return(d);
|
|
}
|
|
|
|
|
|
BOOL
|
|
AppendParamsFile(
|
|
IN HWND ParentWindow,
|
|
IN LPCTSTR ParametersFileIn,
|
|
IN LPCTSTR ParametersFileOut
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Read an external file (such as an unattended script file)
|
|
and copy it section by section into the winnt.sif parameters
|
|
file. (The [Data] and [OemBootFiles] sections of the unattend file
|
|
are ignored.)
|
|
|
|
Arguments:
|
|
|
|
ParentWindow - supplies window handle of window to act as owner/parent
|
|
if this routine has to put up ui, such as when the script file
|
|
is bogus.
|
|
|
|
ParametersFileIn - supplies win32 filename of the file, such as
|
|
unattend.txt, being appended to winnt.sif.
|
|
|
|
ParametersFileOut - supplies win32 filename of the winnt.sif file
|
|
being generated.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating outcome. If FALSE, the user will have been
|
|
informed of why.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR *SectionNames;
|
|
TCHAR *SectionData;
|
|
TCHAR *SectionName;
|
|
DWORD SectionNamesSize;
|
|
DWORD SectionDataSize;
|
|
DWORD d;
|
|
TCHAR TempFile[MAX_PATH] = TEXT("");
|
|
PCTSTR RealInputFile = NULL;
|
|
BOOL b;
|
|
PVOID p;
|
|
|
|
|
|
|
|
#define PROFILE_BUFSIZE 16384
|
|
#define PROFILE_BUFGROW 4096
|
|
|
|
//
|
|
// Allocate some memory for the required buffers
|
|
//
|
|
SectionNames = MALLOC(PROFILE_BUFSIZE * sizeof(TCHAR));
|
|
SectionData = MALLOC(PROFILE_BUFSIZE * sizeof(TCHAR));
|
|
|
|
if(!SectionNames || !SectionData) {
|
|
MessageBoxFromMessage(
|
|
ParentWindow,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
b = FALSE;
|
|
goto c0;
|
|
}
|
|
|
|
*TempFile = 0;
|
|
RealInputFile = ParametersFileIn;
|
|
|
|
|
|
//
|
|
// There is a bug in Win9x's GetPrivateProfileSection() Such that if the file
|
|
// being queried exists on a read only share, it will not return the section strings.
|
|
// This is bad.
|
|
//
|
|
// To work around this, on win9x, we are going to make a temporary copy of the inf
|
|
// merge it in and then delete it.
|
|
//
|
|
#ifdef _X86_
|
|
if (!ISNT() && ParametersFileIn && FileExists (ParametersFileIn, NULL)) {
|
|
|
|
GetSystemDirectory (TempFile, MAX_PATH);
|
|
GetTempFileName (TempFile, TEXT("USF"), 0, TempFile);
|
|
CopyFile (ParametersFileIn, TempFile, FALSE);
|
|
RealInputFile = TempFile;
|
|
}
|
|
#endif
|
|
|
|
|
|
SectionNamesSize = PROFILE_BUFSIZE;
|
|
SectionDataSize = PROFILE_BUFSIZE;
|
|
|
|
//
|
|
// Retreive a list of section names in the unattend script file.
|
|
//
|
|
do {
|
|
d = GetPrivateProfileString(
|
|
NULL,
|
|
NULL,
|
|
TEXT(""),
|
|
SectionNames,
|
|
SectionNamesSize,
|
|
RealInputFile
|
|
);
|
|
|
|
if(!d) {
|
|
//
|
|
// No section names. Bogus file.
|
|
//
|
|
MessageBoxFromMessage(
|
|
ParentWindow,
|
|
MSG_UNATTEND_FILE_INVALID,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ParametersFileIn
|
|
);
|
|
|
|
b = FALSE;
|
|
goto c0;
|
|
}
|
|
|
|
if(d == (SectionNamesSize-2)) {
|
|
//
|
|
// Buffer was too small. Reallocate it and try again.
|
|
//
|
|
p = REALLOC(
|
|
SectionNames,
|
|
(SectionNamesSize+PROFILE_BUFGROW)*sizeof(TCHAR)
|
|
);
|
|
|
|
if(!p) {
|
|
MessageBoxFromMessage(
|
|
ParentWindow,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
b = FALSE;
|
|
goto c0;
|
|
}
|
|
|
|
SectionNames = p;
|
|
SectionNamesSize += PROFILE_BUFGROW;
|
|
}
|
|
} while(d == (SectionNamesSize-2));
|
|
|
|
for(SectionName=SectionNames; *SectionName; SectionName+=lstrlen(SectionName)+1) {
|
|
//
|
|
// Ignore the [data] section in the source, as we do not
|
|
// want copy it into the target, because this would overwrite
|
|
// our internal settings.
|
|
// Ignore also [OemBootFiles]
|
|
//
|
|
if(lstrcmpi(SectionName,WINNT_DATA) && lstrcmpi(SectionName,WINNT_OEMBOOTFILES)) {
|
|
//
|
|
// Fetch the entire section and write it to the target file.
|
|
// Note that the section-based API call will leave double-quotes
|
|
// intact when we retrieve the data, which is what we want.
|
|
// Key-based API calls will strip quotes, which screws us.
|
|
//
|
|
while(GetPrivateProfileSection(
|
|
SectionName,
|
|
SectionData,
|
|
SectionDataSize,
|
|
RealInputFile
|
|
) == (SectionDataSize-2)) {
|
|
|
|
//
|
|
// Reallocate the buffer and try again.
|
|
//
|
|
p = REALLOC(
|
|
SectionData,
|
|
(SectionDataSize+PROFILE_BUFGROW)*sizeof(TCHAR)
|
|
);
|
|
|
|
if(!p) {
|
|
MessageBoxFromMessage(
|
|
ParentWindow,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
|
|
b = FALSE;
|
|
goto c0;
|
|
}
|
|
|
|
SectionData = 0;
|
|
SectionDataSize += PROFILE_BUFGROW;
|
|
}
|
|
|
|
//
|
|
// Write the entire section to the output file.
|
|
//
|
|
if(!WritePrivateProfileSection(SectionName,SectionData,ParametersFileOut)) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ParametersFileOut
|
|
);
|
|
|
|
b = FALSE;
|
|
goto c0;
|
|
}
|
|
}
|
|
}
|
|
|
|
b = TRUE;
|
|
|
|
c0:
|
|
if(SectionNames) {
|
|
FREE(SectionNames);
|
|
}
|
|
if(SectionData) {
|
|
FREE(SectionData);
|
|
}
|
|
|
|
if (*TempFile) {
|
|
|
|
DeleteFile (TempFile);
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
BOOL
|
|
WriteParametersFile(
|
|
IN HWND ParentWindow
|
|
)
|
|
{
|
|
TCHAR SysPartFile[MAX_PATH];
|
|
DWORD d;
|
|
BOOL b;
|
|
|
|
//
|
|
// Write the file out onto the root of the system partition drive
|
|
// and then move the file into place where it actually belongs.
|
|
//
|
|
#if defined(REMOTE_BOOT)
|
|
if (RemoteBoot) {
|
|
//
|
|
// For remote boot, put the file in the root of the machine directory
|
|
// and leave it there.
|
|
//
|
|
StringCchCopy(SysPartFile, ARRAYSIZE(SysPartFile), MachineDirectory);
|
|
StringCchCat(SysPartFile, ARRAYSIZE(SysPartFile), TEXT("\\"));
|
|
StringCchCat(SysPartFile, ARRAYSIZE(SysPartFile), WINNT_SIF_FILE);
|
|
StringCchCopy(ActualParamFile, ARRAYSIZE(ActualParamFile), SysPartFile);
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
if (!BuildSystemPartitionPathToFile (WINNT_SIF_FILE, SysPartFile, MAX_PATH)) {
|
|
return(FALSE); // this should never happen.
|
|
}
|
|
}
|
|
|
|
if(!DoWriteParametersFile(ParentWindow,SysPartFile)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
//
|
|
// For remote boot, leave the file in the root of the machine directory.
|
|
//
|
|
|
|
if (!RemoteBoot)
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
//
|
|
// In the amd64/x86 case this file belongs on the boot media
|
|
// somewhere. If we're generating floppyless boot media
|
|
// then move the file into place. Otherwise there's no point.
|
|
//
|
|
// In the non-floppyless case we keep the file around until later
|
|
// when the floppy-generation code gets to run.
|
|
//
|
|
if(MakeBootMedia) {
|
|
|
|
if(Floppyless) {
|
|
|
|
BuildSystemPartitionPathToFile (LOCAL_BOOT_DIR, ActualParamFile, MAX_PATH);
|
|
|
|
d = CreateMultiLevelDirectory(ActualParamFile);
|
|
if(d != NO_ERROR) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_DIR_CREATE_FAILED,
|
|
d,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ActualParamFile
|
|
);
|
|
|
|
DeleteFile(SysPartFile);
|
|
return(FALSE);
|
|
}
|
|
|
|
ConcatenatePaths(ActualParamFile,WINNT_SIF_FILE,MAX_PATH);
|
|
|
|
//
|
|
// Move the file into its real location.
|
|
//
|
|
DeleteFile(ActualParamFile);
|
|
|
|
//
|
|
// On Windows 95, MoveFile fails in strange ways
|
|
// when the profile APIs have the file open (for instance,
|
|
// it will leave the src file and the dest file will be
|
|
// filled with garbage).
|
|
//
|
|
// Flush it.
|
|
//
|
|
WritePrivateProfileString(NULL,NULL,NULL,SysPartFile);
|
|
|
|
if (SysPartFile[0] == ActualParamFile[0]) {
|
|
b = MoveFile(SysPartFile,ActualParamFile);
|
|
} else {
|
|
b = CopyFile (SysPartFile, ActualParamFile, FALSE);
|
|
if (b) {
|
|
DeleteFile (SysPartFile);
|
|
}
|
|
}
|
|
|
|
if (!b) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ActualParamFile
|
|
);
|
|
|
|
DeleteFile(SysPartFile);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
}
|
|
} else {
|
|
DeleteFile(SysPartFile);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
//
|
|
// If we're making a local source, move the file there.
|
|
// Otherwise just leave it on the root of the system partition.
|
|
//
|
|
if(MakeLocalSource) {
|
|
|
|
d = CreateMultiLevelDirectory(LocalSourceWithPlatform);
|
|
if(d != NO_ERROR) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_DIR_CREATE_FAILED,
|
|
d,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
LocalSourceWithPlatform
|
|
);
|
|
|
|
DeleteFile(SysPartFile);
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Move the file into its real location.
|
|
//
|
|
StringCchPrintf(ActualParamFile, ARRAYSIZE(ActualParamFile), TEXT("%s\\%s"),LocalSourceWithPlatform,WINNT_SIF_FILE);
|
|
DeleteFile(ActualParamFile);
|
|
if(!MoveFile(SysPartFile,ActualParamFile)) {
|
|
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ActualParamFile
|
|
);
|
|
|
|
DeleteFile(SysPartFile);
|
|
return(FALSE);
|
|
}
|
|
}
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
#define MULTI_SZ_NEXT_STRING(x) ((x) + _tcslen(x) + 1)
|
|
|
|
BOOL
|
|
MergeINFFiles(
|
|
IN PCTSTR SourceFileName,
|
|
IN PCTSTR DestFileName
|
|
)
|
|
{
|
|
DWORD dwAttributes;
|
|
PTSTR pSectionsBuffer = NULL;
|
|
PTSTR pKeysBuffer = NULL;
|
|
PTSTR pString = NULL;
|
|
PTSTR pSection;
|
|
PTSTR pKey;
|
|
UINT sizeOfBuffer;
|
|
UINT sizeOfSectionBuffer;
|
|
BOOL bResult = FALSE;
|
|
|
|
MYASSERT (SourceFileName && DestFileName);
|
|
|
|
if(-1 == GetFileAttributes(SourceFileName)){
|
|
return TRUE;
|
|
}
|
|
|
|
__try{
|
|
//
|
|
// Allocate buffer for sections names.
|
|
//
|
|
sizeOfBuffer = 0;
|
|
do{
|
|
if(pSectionsBuffer){
|
|
FREE(pSectionsBuffer);
|
|
}
|
|
sizeOfBuffer += DEF_INF_BUFFER_SIZE;
|
|
pSectionsBuffer = (PTSTR)MALLOC(sizeOfBuffer * sizeof (TCHAR));
|
|
if(!pSectionsBuffer){
|
|
__leave;
|
|
}
|
|
}while((sizeOfBuffer - 2) ==
|
|
GetPrivateProfileSectionNames(pSectionsBuffer,
|
|
sizeOfBuffer,
|
|
SourceFileName));
|
|
|
|
sizeOfSectionBuffer = DEF_INF_BUFFER_SIZE;
|
|
pKeysBuffer = (PTSTR)MALLOC(sizeOfSectionBuffer * sizeof (TCHAR));
|
|
if(!pKeysBuffer){
|
|
__leave;
|
|
}
|
|
|
|
sizeOfBuffer = DEF_INF_BUFFER_SIZE;
|
|
pString = (PTSTR)MALLOC(sizeOfBuffer * sizeof (TCHAR));
|
|
if(!pString){
|
|
__leave;
|
|
}
|
|
|
|
for(pSection = pSectionsBuffer; pSection[0]; pSection = MULTI_SZ_NEXT_STRING(pSection)){
|
|
//
|
|
// Allocate buffer for entries names;
|
|
//
|
|
while((sizeOfSectionBuffer - 2) ==
|
|
GetPrivateProfileString(pSection,
|
|
NULL,
|
|
EMPTY_STRING,
|
|
pKeysBuffer,
|
|
sizeOfSectionBuffer,
|
|
SourceFileName)){
|
|
if(pKeysBuffer){
|
|
FREE(pKeysBuffer);
|
|
}
|
|
sizeOfSectionBuffer += DEF_INF_BUFFER_SIZE;
|
|
pKeysBuffer = (PTSTR)MALLOC(sizeOfSectionBuffer * sizeof (TCHAR));
|
|
if(!pKeysBuffer){
|
|
__leave;
|
|
}
|
|
};
|
|
|
|
|
|
for(pKey = pKeysBuffer; pKey[0]; pKey = MULTI_SZ_NEXT_STRING(pKey))
|
|
{
|
|
//
|
|
// Allocate buffer for value string;
|
|
//
|
|
GetPrivateProfileString(pSection,
|
|
pKey,
|
|
EMPTY_STRING,
|
|
pString,
|
|
sizeOfBuffer,
|
|
SourceFileName);
|
|
|
|
if (!WritePrivateProfileString(pSection, pKey, pString, DestFileName)) {
|
|
__leave;
|
|
}
|
|
}
|
|
}
|
|
bResult = TRUE;
|
|
}
|
|
__finally{
|
|
DWORD rc = GetLastError ();
|
|
if(pSectionsBuffer){
|
|
FREE(pSectionsBuffer);
|
|
}
|
|
if(pKeysBuffer){
|
|
FREE(pKeysBuffer);
|
|
}
|
|
if(pString){
|
|
FREE(pString);
|
|
}
|
|
SetLastError (rc);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
AddExternalParams (
|
|
IN HWND ParentWindow
|
|
)
|
|
{
|
|
DWORD rc = ERROR_SUCCESS;
|
|
static BOOL Done = FALSE;
|
|
|
|
if(Done) {
|
|
return(TRUE);
|
|
}
|
|
|
|
//
|
|
// Append external parameters if necessary.
|
|
//
|
|
|
|
if(Upgrade && UpgradeSupport.WriteParamsRoutine) {
|
|
rc = UpgradeSupport.WriteParamsRoutine(ActualParamFile);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
ActualParamFile
|
|
);
|
|
}
|
|
}
|
|
|
|
#if defined(UNICODE) && defined(_X86_)
|
|
//
|
|
// Merge NT migration unattented inf file with winnt.sif
|
|
//
|
|
if(Upgrade && !MergeINFFiles(g_MigDllAnswerFilePath, ActualParamFile)){
|
|
MessageBoxFromMessageAndSystemError(
|
|
ParentWindow,
|
|
MSG_BOOT_FILE_ERROR,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
g_MigDllAnswerFilePath
|
|
);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// write the compatibility stuff in these cases
|
|
//
|
|
// 1. upgrade from downlevel NT platform
|
|
// 2. clean install
|
|
// 3. upgrade from current NT platform and we have NT5 compatibility items
|
|
//
|
|
// note that win9x has it's own upgrade code path.
|
|
//
|
|
if( (ISNT() && (BuildNumber <= NT40) && Upgrade)
|
|
|| !Upgrade
|
|
|| (ISNT() && Upgrade && AnyNt5CompatDlls) ){
|
|
|
|
//
|
|
// Disable stuff for <= NT4 case, clean install (unsupported arch. etc.)
|
|
// and NT5 upgrade with NT5 upgrade components set
|
|
//
|
|
|
|
WriteCompatibilityData( ActualParamFile );
|
|
WriteGUIModeInfOperations( ActualParamFile );
|
|
AddGUIModeCompatibilityInfsToCopyList();
|
|
}
|
|
|
|
if (ISNT() && Upgrade) {
|
|
if (!WriteTextmodeClobberData (ActualParamFile)) {
|
|
rc = GetLastError ();
|
|
}
|
|
}
|
|
|
|
Done = TRUE;
|
|
return rc == ERROR_SUCCESS;
|
|
}
|
|
|
|
BOOL
|
|
MyWritePrivateProfileString(
|
|
LPCTSTR lpAppName, // pointer to section name
|
|
LPCTSTR lpKeyName, // pointer to key name
|
|
LPCTSTR lpString, // pointer to string to add
|
|
LPCTSTR lpFileName // pointer to initialization filename
|
|
)
|
|
/*
|
|
Wrapper for WritePrivateProfileString to try more than once on instances
|
|
where we can't write to the winnt.sif file. This commonly occurs when
|
|
virus software monitors the root of C drive.
|
|
|
|
The problem is that usually these s/w examine the files we touch and in somecases open it
|
|
with exclusive access. We just need to wait for them to be done.
|
|
|
|
*/
|
|
{
|
|
|
|
int i = 0;
|
|
BOOL ret = FALSE;
|
|
DWORD Err;
|
|
|
|
while(i++ < 3){
|
|
#ifdef UNICODE
|
|
#ifdef WritePrivateProfileStringW
|
|
#undef WritePrivateProfileStringW
|
|
|
|
if( !lpAppName && !lpKeyName && !lpString ){
|
|
WritePrivateProfileStringW( lpAppName, lpKeyName, lpString, lpFileName);
|
|
return FALSE;
|
|
}
|
|
|
|
if( ret = WritePrivateProfileStringW( lpAppName, lpKeyName, lpString, lpFileName) )
|
|
break;
|
|
#endif
|
|
#else
|
|
#ifdef WritePrivateProfileStringA
|
|
#undef WritePrivateProfileStringA
|
|
|
|
if( !lpAppName && !lpKeyName && !lpString ){
|
|
WritePrivateProfileStringA( lpAppName, lpKeyName, lpString, lpFileName);
|
|
return FALSE;
|
|
}
|
|
|
|
if( ret = WritePrivateProfileStringA( lpAppName, lpKeyName, lpString, lpFileName) )
|
|
break;
|
|
#endif
|
|
#endif
|
|
Sleep( 500 );
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
VOID
|
|
FixWininetList(
|
|
LPTSTR List
|
|
)
|
|
{
|
|
PTCHAR t = List;
|
|
|
|
if (t != NULL)
|
|
{
|
|
while (*t)
|
|
{
|
|
if (*t == (TCHAR)' ')
|
|
{
|
|
*t = (TCHAR)';';
|
|
}
|
|
t++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
|
|
LPWSTR
|
|
AnsiToText(
|
|
LPCSTR Ansi
|
|
)
|
|
{
|
|
int Length;
|
|
LPWSTR Unicode = NULL;
|
|
|
|
if (Ansi == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
Length = MultiByteToWideChar(
|
|
CP_ACP,
|
|
0,
|
|
Ansi,
|
|
-1,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
if (Length > 0)
|
|
{
|
|
int i;
|
|
|
|
Unicode = (LPWSTR) GlobalAlloc(GPTR, Length * sizeof(WCHAR));
|
|
if (!Unicode) {
|
|
return NULL;
|
|
}
|
|
|
|
i = MultiByteToWideChar(
|
|
CP_ACP,
|
|
0,
|
|
Ansi,
|
|
-1,
|
|
Unicode,
|
|
Length);
|
|
|
|
if (i == 0)
|
|
{
|
|
GlobalFree(Unicode);
|
|
Unicode = NULL;
|
|
}
|
|
}
|
|
|
|
return Unicode;
|
|
}
|
|
|
|
|
|
#else
|
|
|
|
LPSTR AnsiToText(
|
|
LPCSTR Ansi
|
|
)
|
|
|
|
/*++
|
|
|
|
Note:
|
|
|
|
Can't use DupString because the caller assume memory obtained from
|
|
GlobalAlloc.
|
|
|
|
--*/
|
|
|
|
{
|
|
LPSTR CopyOfAnsi = NULL;
|
|
|
|
if (Ansi != NULL)
|
|
{
|
|
CopyOfAnsi = GlobalAlloc(GPTR, (strlen(Ansi)+1) * sizeof(CHAR));
|
|
if (CopyOfAnsi)
|
|
{
|
|
strcpy(CopyOfAnsi, Ansi);
|
|
}
|
|
}
|
|
|
|
return CopyOfAnsi;
|
|
}
|
|
|
|
#endif
|
|
|
|
BOOL
|
|
QuoteString(
|
|
IN OUT LPTSTR* StringPointer
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Replace the input string with a double quoted one.
|
|
|
|
Arguments:
|
|
|
|
StringPointer - pointer to a string allocated by GlobalAlloc. The input
|
|
string is always free. If it is successful the new string, allocated
|
|
by GlobalAlloc, is returned; otherwise, NULL is returned.
|
|
|
|
Return:
|
|
|
|
TRUE - successfully quote a string
|
|
|
|
FALSE - otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
LPTSTR StringValue = *StringPointer;
|
|
LPTSTR QuotedString;
|
|
|
|
QuotedString = GlobalAlloc(GPTR, (lstrlen(StringValue) + 3) * sizeof(TCHAR));
|
|
if (QuotedString)
|
|
{
|
|
wsprintf(QuotedString, TEXT("\"%s\""), StringValue);
|
|
*StringPointer = QuotedString;
|
|
}
|
|
else
|
|
{
|
|
*StringPointer = NULL;
|
|
}
|
|
|
|
GlobalFree(StringValue);
|
|
|
|
return (*StringPointer != NULL);
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
SaveProxyForOobe(
|
|
IN LPCTSTR FileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Save the LAN http and https proxy settings, if any, for OOBE to use while
|
|
it is running in 'SYSTEM' context.
|
|
|
|
Arguments:
|
|
|
|
FileName - specifies the full Win32 filename for saving Setup settings.
|
|
|
|
--*/
|
|
|
|
{
|
|
typedef BOOL (WINAPI* PINTERNETQUERYOPTION)(
|
|
IN HINTERNET hInternet OPTIONAL,
|
|
IN DWORD dwOption,
|
|
OUT LPVOID lpBuffer OPTIONAL,
|
|
IN OUT LPDWORD lpdwBufferLength
|
|
);
|
|
|
|
HMODULE WinInetLib;
|
|
LPTSTR ProxyList = NULL;
|
|
LPTSTR ProxyOverride = NULL;
|
|
LPTSTR AutoConfigUrl = NULL;
|
|
LPTSTR AutoConfigUrl2 = NULL;
|
|
DWORD ProxyFlags = 0;
|
|
DWORD AutoDiscoveryFlags = 0;
|
|
TCHAR NumberStr[25];
|
|
BOOL Captured = FALSE;
|
|
|
|
WinInetLib = LoadLibrary(TEXT("WININET.DLL"));
|
|
|
|
//
|
|
// We prefer the INTERNET_OPTION_PER_CONNECTION_OPTION because we just
|
|
// want to save the LAN proxy settings and we want to know the auto proxy
|
|
// setting, but this option is not supported until IE 5.0
|
|
//
|
|
if (WinInetLib != NULL)
|
|
{
|
|
PINTERNETQUERYOPTION pInternetQueryOption;
|
|
|
|
pInternetQueryOption = (PINTERNETQUERYOPTION) GetProcAddress(
|
|
WinInetLib,
|
|
#ifdef UNICODE
|
|
"InternetQueryOptionW"
|
|
#else
|
|
"InternetQueryOptionA"
|
|
#endif
|
|
);
|
|
|
|
if (pInternetQueryOption)
|
|
{
|
|
INTERNET_PER_CONN_OPTION_LIST OptionList;
|
|
INTERNET_PER_CONN_OPTION Option[6];
|
|
DWORD BufferLength = sizeof(OptionList);
|
|
|
|
OptionList.dwSize = sizeof(OptionList);
|
|
OptionList.pszConnection = NULL;
|
|
OptionList.dwOptionCount = 6;
|
|
|
|
ZeroMemory(&Option, sizeof(Option));
|
|
|
|
Option[0].dwOption = INTERNET_PER_CONN_FLAGS;
|
|
Option[1].dwOption = INTERNET_PER_CONN_PROXY_SERVER;
|
|
Option[2].dwOption = INTERNET_PER_CONN_PROXY_BYPASS;
|
|
Option[3].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL;
|
|
Option[4].dwOption = INTERNET_PER_CONN_AUTODISCOVERY_FLAGS;
|
|
Option[5].dwOption = INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL;
|
|
|
|
OptionList.pOptions = Option;
|
|
|
|
if (pInternetQueryOption(
|
|
NULL,
|
|
INTERNET_OPTION_PER_CONNECTION_OPTION,
|
|
&OptionList,
|
|
&BufferLength
|
|
) == TRUE)
|
|
{
|
|
ProxyFlags = Option[0].Value.dwValue;
|
|
ProxyList = Option[1].Value.pszValue;
|
|
ProxyOverride = Option[2].Value.pszValue;
|
|
AutoConfigUrl = Option[3].Value.pszValue;
|
|
AutoDiscoveryFlags = Option[4].Value.dwValue;
|
|
AutoConfigUrl2 = Option[5].Value.pszValue;
|
|
Captured = TRUE;
|
|
}
|
|
else
|
|
{
|
|
|
|
INTERNET_PROXY_INFO* ProxyInfo = NULL;
|
|
DWORD BufferLength = 0;
|
|
|
|
//
|
|
// We obtain the ANSI string for INTERNET_OPTION_PROXY,
|
|
// even if we call InternetQueryOptionW.
|
|
//
|
|
// Proxy list returned from INTERNET_OPTION_PER_CONNECTION are
|
|
// delimited by ';', while that returned from INTERNET_OPTION_PROXY
|
|
// are delimited by ' '.
|
|
//
|
|
if (pInternetQueryOption(
|
|
NULL,
|
|
INTERNET_OPTION_PROXY,
|
|
ProxyInfo,
|
|
&BufferLength
|
|
) == FALSE
|
|
&&
|
|
GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
|
|
ProxyInfo = (INTERNET_PROXY_INFO*) GlobalAlloc(GPTR, BufferLength);
|
|
|
|
if (ProxyInfo)
|
|
{
|
|
if (pInternetQueryOption(
|
|
NULL,
|
|
INTERNET_OPTION_PROXY,
|
|
ProxyInfo,
|
|
&BufferLength
|
|
) == TRUE)
|
|
{
|
|
//
|
|
// Map the values to INTERNET_OPTION_PER_CONN_OPTION
|
|
// We enable the auto proxy settings even though
|
|
// INTERNET_OPTION_PROXY doesn't have value relevant
|
|
// to auto proxy, because IE5 default to use auto proxy.
|
|
//
|
|
// PROXY_TYPE_DIRECT is always set because wininet
|
|
// return this flags whether inetcpl.cpl is set
|
|
// to use proxy or not.
|
|
//
|
|
ProxyFlags = PROXY_TYPE_DIRECT | PROXY_TYPE_AUTO_DETECT;
|
|
if (ProxyInfo->dwAccessType != INTERNET_OPEN_TYPE_DIRECT)
|
|
{
|
|
ProxyFlags |= PROXY_TYPE_PROXY;
|
|
}
|
|
|
|
ProxyList = AnsiToText((LPCSTR)ProxyInfo->lpszProxy);
|
|
FixWininetList(ProxyList);
|
|
ProxyOverride = AnsiToText((LPCSTR)ProxyInfo->lpszProxyBypass);
|
|
FixWininetList(ProxyOverride);
|
|
AutoDiscoveryFlags = 0;
|
|
Captured = TRUE;
|
|
}
|
|
|
|
GlobalFree(ProxyInfo);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FreeLibrary(WinInetLib);
|
|
|
|
}
|
|
|
|
if (Captured)
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_ENABLE_OOBEPROXY,
|
|
TEXT("1"),
|
|
FileName
|
|
);
|
|
|
|
if (ProxyList && QuoteString(&ProxyList))
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_PROXY_SERVER,
|
|
ProxyList,
|
|
FileName
|
|
);
|
|
|
|
GlobalFree(ProxyList);
|
|
}
|
|
|
|
|
|
//
|
|
// Fix the ProxyOverride to not have any "\r\n"s
|
|
//
|
|
if (ProxyOverride) {
|
|
ReplaceSubStr(ProxyOverride, TEXT("\r\n"), TEXT(";"));
|
|
}
|
|
|
|
if (ProxyOverride && QuoteString(&ProxyOverride))
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_PROXY_BYPASS,
|
|
ProxyOverride,
|
|
FileName
|
|
);
|
|
GlobalFree(ProxyOverride);
|
|
}
|
|
|
|
if (AutoConfigUrl && QuoteString(&AutoConfigUrl))
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_AUTOCONFIG_URL,
|
|
AutoConfigUrl,
|
|
FileName
|
|
);
|
|
GlobalFree(AutoConfigUrl);
|
|
}
|
|
|
|
if (AutoConfigUrl2 && QuoteString(&AutoConfigUrl2))
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_AUTOCONFIG_SECONDARY_URL,
|
|
AutoConfigUrl2,
|
|
FileName
|
|
);
|
|
GlobalFree(AutoConfigUrl2);
|
|
}
|
|
|
|
wsprintf(NumberStr, TEXT("%u"), ProxyFlags);
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_FLAGS,
|
|
NumberStr,
|
|
FileName
|
|
);
|
|
|
|
wsprintf(NumberStr, TEXT("%u"), AutoDiscoveryFlags);
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_AUTODISCOVERY_FLAGS,
|
|
NumberStr,
|
|
FileName
|
|
);
|
|
}
|
|
else
|
|
{
|
|
WritePrivateProfileString(
|
|
WINNT_OOBEPROXY,
|
|
WINNT_O_ENABLE_OOBEPROXY,
|
|
TEXT("0"),
|
|
FileName
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef _X86_
|
|
BOOL
|
|
IsDriveAssignNEC98(
|
|
VOID
|
|
)
|
|
{
|
|
TCHAR sz95KeyName[] = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion");
|
|
TCHAR sz95ValueName[] = TEXT("ATboot");
|
|
TCHAR szNTKeyName[] = TEXT("System\\setup");
|
|
TCHAR szNTValueName[] = TEXT("DriveLetter");
|
|
HKEY hKey;
|
|
DWORD type95 = REG_BINARY;
|
|
DWORD typeNT = REG_SZ;
|
|
TCHAR szData[5];
|
|
DWORD dwSize = 5;
|
|
DWORD rc;
|
|
|
|
if(ISNT()){
|
|
rc = RegOpenKeyEx (HKEY_LOCAL_MACHINE,
|
|
szNTKeyName,
|
|
0, //ulOptions (reserved)
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
if (ERROR_SUCCESS != rc) {
|
|
return TRUE;
|
|
}
|
|
//
|
|
// Query key to get the subkey count and max string lengths
|
|
//
|
|
rc = RegQueryValueEx (hKey,
|
|
szNTValueName,
|
|
NULL, // lpReserved
|
|
&typeNT,
|
|
(LPBYTE) szData,
|
|
&dwSize);
|
|
|
|
if (ERROR_SUCCESS != rc) {
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
RegCloseKey(hKey);
|
|
|
|
if (szData[0] != L'C'){
|
|
// NEC DOS Type.
|
|
return TRUE;
|
|
}
|
|
} else { // It will be Win9x
|
|
rc = RegOpenKeyEx (HKEY_LOCAL_MACHINE,
|
|
sz95KeyName,
|
|
0, //ulOptions (reserved)
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
if (ERROR_SUCCESS != rc) {
|
|
return TRUE;
|
|
}
|
|
//
|
|
// Query key to get the subkey count and max string lengths
|
|
//
|
|
rc = RegQueryValueEx (hKey,
|
|
sz95ValueName,
|
|
NULL, // lpReserved
|
|
&type95,
|
|
(LPBYTE) szData,
|
|
&dwSize);
|
|
|
|
if (ERROR_SUCCESS != rc) {
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
RegCloseKey(hKey);
|
|
if (szData[0] == 0){
|
|
// NEC DOS Type.
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
|
|
|