archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/base/ntsetup/winnt32/dll/winnt32.c

5714 lines
166 KiB
Raw Blame History

#include "precomp.h"
#pragma hdrstop
#if defined(_X86_) //NEC98 I970721
#include <stdlib.h>
#include <stdio.h>
#include <winbase.h>
#include <n98boot.h>
#endif // PC98
#include <pencrypt.h>
#include <winsta.h>
#include <ntverp.h>
#include <undo.h>
#include "errorrep.h"
#include "faulth.h"
void PrepareBillBoard(HWND hwnd);
void TerminateBillBoard();
void CreateMainWindow();
UINT GetMediaProductBuildNumber (VOID);
void CopyExtraBVTDirs();
HWND BackgroundWnd2 = NULL;
//
// Misc globals.
//
HINSTANCE hInst;
DWORD TlsIndex;
//
// Upgrade information block
//
WINNT32_PLUGIN_INIT_INFORMATION_BLOCK info;
#if defined(_AMD64_) || defined(_X86_)
WINNT32_WIN9XUPG_INIT_INFORMATION_BLOCK Win9xInfo;
#if defined(_X86_)
PWINNT32_PLUGIN_SETAUTOBOOT_ROUTINE W95SetAutoBootFlag;
#endif
#endif
//
// This is the title of the application. It changes dynamically depending on
// whether we're on server or workstation, etc.
//
UINT AppTitleStringId = IDS_APPTITLE;
//
// Flag indicating whether we are initiating an MSI-install.
//
BOOL RunFromMSI = FALSE;
//
// Flag indicating whether we are initiating an Typical install
// Initialize to Typical install.
DWORD dwSetupFlags = UPG_FLAG_TYPICAL;
//
// Flag indicating whether we are initiating an upgrade.
//
BOOL Upgrade = TRUE;
//
// Flag to say if we need to write the AcpiHAL value to the winnt.sif file
//
BOOL WriteAcpiHalValue = FALSE;
//
// What should we write as the value for the AcpiHalValue
//
BOOL AcpiHalValue = FALSE;
//
// Flag indicating whether we're installing/upgrading to NT Server
//
BOOL Server;
//
// Flag to indicate if we are running BVT's
//
BOOL RunningBVTs = FALSE;
//
// When running BVT's, what baudrate should we set the debugger to?
//
LONG lDebugBaudRate = 115200;
//
// When running BVT's, what comport should we set the debugger to?
//
LONG lDebugComPort = 0;
//
// When running BVT's, should we copy the symbols locally?
//
BOOL CopySymbols = TRUE;
//
// Flag to indicate if we are running ASR tests
//
DWORD AsrQuickTest = 0;
//
// Flags for product type and flavor for upgrade modules
//
PRODUCTTYPE UpgradeProductType = UNKNOWN;
UINT ProductFlavor = UNKNOWN_PRODUCTTYPE;
//
// Global flag indicating whether the entire overall program operation
// was successful. Also a flag indicating whether to shut down automatically
// when the wizard is done in the non-unattended case.
//
BOOL GlobalResult = FALSE;
BOOL AutomaticallyShutDown = TRUE;
//
// Global OS version info.
//
OSVERSIONINFO OsVersion;
DWORD OsVersionNumber = 0;
//
// Flags indicating how we were run and whether to create
// a local source.
//
BOOL RunFromCD;
BOOL MakeLocalSource;
BOOL UserSpecifiedMakeLocalSource = FALSE;
BOOL NoLs = FALSE;
TCHAR UserSpecifiedLocalSourceDrive;
//
// the default for MLS is CD1 only
//
DWORD MLSDiskID = 1;
//
// advanced install options
//
BOOL ChoosePartition = TRUE;
BOOL UseSignatures = TRUE;
TCHAR InstallDir[MAX_PATH];
//
// SMS support
//
typedef DWORD (*SMSPROC) (char *, char*, char*, char*, char *, char *, char *, BOOL);
PSTR LastMessage = NULL;
#if defined(REMOTE_BOOT)
//
// Flag indicating whether we're running on a remote boot client.
//
BOOL RemoteBoot;
//
// Path to the machine directory for a remote boot client.
//
TCHAR MachineDirectory[MAX_PATH];
#endif // defined(REMOTE_BOOT)
//
// Flags indicating which Accessibility utilities to use
//
BOOL AccessibleMagnifier;
BOOL AccessibleKeyboard;
BOOL AccessibleVoice;
BOOL AccessibleReader;
//
// Build number we're upgrading from
//
DWORD BuildNumber = 0;
//
// Are any of the Accesssibility utilities enabled?
//
BOOL AccessibleSetup;
//
// Name of unattended script file to be used for Accessible Setup
//
TCHAR AccessibleScriptFile[MAX_PATH] = TEXT("setupacc.txt");
//
// Flags and values relating to unattended operation.
//
BOOL UnattendedOperation;
BOOL UnattendSwitchSpecified = FALSE;
PTSTR UnattendedScriptFile;
UINT UnattendedShutdownTimeout;
BOOL BatchMode;
//
// Source paths and count of paths.
//
TCHAR SourcePaths[MAX_SOURCE_COUNT][MAX_PATH];
UINT SourceCount;
//
// source paths to current architecture's files
//
TCHAR NativeSourcePaths[MAX_SOURCE_COUNT][MAX_PATH];
TCHAR *UserSpecifiedOEMShare = NULL;
//
// Local source information.
//
TCHAR LocalSourceDrive;
DWORD LocalSourceDriveOffset;
TCHAR LocalSourceDirectory[MAX_PATH];
TCHAR LocalSourceWithPlatform[MAX_PATH];
TCHAR LocalBootDirectory[MAX_PATH];
#if defined(_AMD64_) || defined(_X86_)
TCHAR LocalBackupDirectory[MAX_PATH];
TCHAR FirstFloppyDriveLetter;
#endif
LONGLONG LocalSourceSpaceRequired;
LONGLONG WinDirSpaceFor9x = 0l;
BOOL BlockOnNotEnoughSpace = TRUE;
UINT UpgRequiredMb;
UINT UpgAvailableMb;
BOOL UpginfsUpdated = FALSE;
//
// Optional directory stuff.
//
UINT OptionalDirectoryCount;
TCHAR OptionalDirectories[MAX_OPTIONALDIRS][MAX_PATH];
UINT OptionalDirectoryFlags[MAX_OPTIONALDIRS];
//
// Name of INF. Constructed so we don't have to realloc anything.
// Note the default.
// Also, handles to dosnet.inf and txtsetup.sif.
//
TCHAR InfName[] = TEXT("DOSNET.INF");
PVOID MainInf;
TCHAR FullInfName[MAX_PATH];
PVOID TxtsetupSif;
PVOID NtcompatInf;
//
// Array of drive letters for all system partitions.
// Note that on amd64/x86 there will always be exactly one.
// The list is 0-terminated.
//
TCHAR SystemPartitionDriveLetters[27];
TCHAR SystemPartitionDriveLetter;
#ifdef UNICODE
UINT SystemPartitionCount;
PWSTR* SystemPartitionNtNames;
PWSTR SystemPartitionNtName;
#else
//
// if running on Win9x, there may be a LocalSourcePath passed as parameter
//
PCSTR g_LocalSourcePath;
#endif
//
// UDF stuff
//
LPCTSTR UniquenessId;
LPCTSTR UniquenessDatabaseFile;
//
// Variables relating to the multi string of options that are passed
// to plugin DLLs (Like Win9xUpg)
//
LPTSTR UpgradeOptions;
DWORD UpgradeOptionsLength;
DWORD UpgradeOptionsSize;
//
// Compliance related variables
//
BOOL NoCompliance = FALSE;
//
// Variables to hold messages concerning reason that the upgrade cannot be completed.
//
#define MSG_UPGRADE_OK 0
#define MSG_LAST_REASON 0
#define FAILREASON(x) MSG_##x,
DWORD UpgradeFailureMessages[] = {
UPGRADEFAILURES /*,*/ MSG_UPGRADE_INIT_ERROR
};
#undef FAILREASON
UINT UpgradeFailureReason = 0;
TCHAR UpgradeSourcePath[MAX_PATH];
//
// Internal override to version checking. Useful for making quick
// privates for foreign language versions.
//
BOOL SkipLocaleCheck = FALSE;
//
// override for the win9x virus scanner check.
//
BOOL SkipVirusScannerCheck = FALSE;
BOOL UseBIOSToBoot = FALSE;
//
// Preinstall stuff
//
BOOL OemPreinstall;
#if defined(_AMD64_) || defined(_X86_)
POEM_BOOT_FILE OemBootFiles;
#endif
//
// Miscellaneous other command line parameters.
//
LPCTSTR CmdToExecuteAtEndOfGui;
BOOL AutoSkipMissingFiles;
BOOL HideWinDir;
TCHAR ProductId[64] = TEXT("\0");
UINT PIDDays = 0;
LPTSTR g_EncryptedPID = NULL;
BOOL g_bDeferPIDValidation = FALSE;
//
// Flag indicating that the user cancelled.
// Handle for mutex used to guarantee that only one error dialog
// is on the screen at once.
//
BOOL Cancelled;
HANDLE UiMutex;
//
// Flag indicating user is aborting. This flag suppresses the final screen in
// cancel mode. I.E. The unsuccssessful completion page.
// win9xupg ReportOnly mode.
//
BOOL Aborted;
//
// Floppy-related stuff.
// Defined, but not used for ARC based machines.
//
BOOL MakeBootMedia = TRUE;
BOOL Floppyless = TRUE;
//
// Upgrade extension DLL.
//
UPGRADE_SUPPORT UpgradeSupport;
//
// Only check to see if we can upgrade or not.
//
BOOL CheckUpgradeOnly;
BOOL CheckUpgradeOnlyQ;
//
// Specifies that winnt32 runs as an "Upgrade Advisor"
// and not all installation files are available
//
BOOL UpgradeAdvisorMode;
//
// Build the command console.
//
BOOL BuildCmdcons;
//
// Are we doing the PID encyption?
//
BOOL PIDEncryption = FALSE;
BOOL g_Quiet = FALSE;
#define WINNT_U_ENCRYPT TEXT("ENCRYPT")
#ifdef RUN_SYSPARSE
// Remove this before RTM.
// Be default run sysparse
BOOL NoSysparse = FALSE;
PROCESS_INFORMATION piSysparse = { NULL, NULL, 0, 0};
LRESULT SysParseDlgProc( IN HWND hdlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam);
HWND GetBBhwnd();
#endif
// Name of module for Program compatibility.
static const TCHAR ShimEngine_ModuleName[] = TEXT("Shimeng.dll");
//
// Log Functions
//
SETUPOPENLOG fnSetupOpenLog = NULL;
SETUPLOGERROR fnSetupLogError = NULL;
SETUPCLOSELOG fnSetupCloseLog = NULL;
//
// Unsupported driver list
// This list contains the information about the unsupported drivers that needs
// to be migrated on a clean install or upgrade.
//
// PUNSUPORTED_DRIVER_INFO UnsupportedDriverList = NULL;
//
// When Winnt32.exe is launched over a network, these two parameters have valid
// values and need to be taken into consideration before displaying any dialog box
//
HWND Winnt32Dlg = NULL;
HANDLE WinNT32StubEvent = NULL;
HINSTANCE hinstBB = NULL;
//
// List of required privileges (on NT) to run this app
//
#ifdef UNICODE
PCTSTR g_RequiredPrivileges[] = {
SE_SHUTDOWN_NAME,
SE_BACKUP_NAME,
SE_RESTORE_NAME,
SE_SYSTEM_ENVIRONMENT_NAME
};
#define COUNT_OF_PRIVILEGES (ARRAYSIZE(g_RequiredPrivileges))
#endif
//
// Definition for dynamically-loaded InitiateSystemShutdownEx API
//
typedef
(WINAPI *PFNINITIATESYSTEMSHUTDOWNEX)(LPTSTR,
LPTSTR,
DWORD,
BOOL,
BOOL,
DWORD);
//
// Routines from Setupapi.dll
//
//
// ISSUE: be careful when using this routine on NT4, as it may fail;
// setupapi on NT4 doesn't understand LZX compression, currently used to compress files
//
DWORD
(*SetupapiDecompressOrCopyFile)(
IN PCTSTR SourceFileName,
OUT PCTSTR TargetFileName,
OUT PUINT CompressionType OPTIONAL
);
HINF
(*SetupapiOpenInfFile)(
IN LPCTSTR FileName,
IN LPCTSTR InfClass, OPTIONAL
IN DWORD InfStyle,
OUT PUINT ErrorLine OPTIONAL
);
VOID
(*SetupapiCloseInfFile)(
IN HINF InfHandle
);
BOOL
(*SetupapiFindFirstLine)(
IN HINF InfHandle,
IN PCTSTR Section,
IN PCTSTR Key, OPTIONAL
OUT PINFCONTEXT Context
);
BOOL
(*SetupapiFindNextLine)(
IN PINFCONTEXT Context1,
OUT PINFCONTEXT Context2
);
BOOL
(*SetupapiFindNextMatchLine)(
IN PINFCONTEXT Context1,
IN PCTSTR Key,
OUT PINFCONTEXT Context2
);
LONG
(*SetupapiGetLineCount)(
IN HINF InfHandle,
IN LPCTSTR Section
);
DWORD
(*SetupapiGetFieldCount)(
IN PINFCONTEXT Context
);
BOOL
(*SetupapiGetStringField)(
IN PINFCONTEXT Context,
DWORD FieldIndex,
PTSTR ReturnBuffer,
DWORD ReturnBufferSize,
PDWORD RequiredSize
);
BOOL
(*SetupapiGetLineByIndex)(
IN HINF InfHandle,
IN LPCTSTR Section,
IN DWORD Index,
OUT PINFCONTEXT Context
);
HSPFILEQ
(*SetupapiOpenFileQueue) (
VOID
);
BOOL
(*SetupapiCloseFileQueue) (
IN HSPFILEQ QueueHandle
);
BOOL
(*SetupapiQueueCopy) (
IN HSPFILEQ QueueHandle,
IN PCTSTR SourceRootPath, OPTIONAL
IN PCTSTR SourcePath, OPTIONAL
IN PCTSTR SourceFilename,
IN PCTSTR SourceDescription, OPTIONAL
IN PCTSTR SourceTagfile, OPTIONAL
IN PCTSTR TargetDirectory,
IN PCTSTR TargetFilename, OPTIONAL
IN DWORD CopyStyle
);
BOOL
(*SetupapiCommitFileQueue) (
IN HWND Owner, OPTIONAL
IN HSPFILEQ QueueHandle,
IN PSP_FILE_CALLBACK_W MsgHandler,
IN PVOID Context
);
UINT
(*SetupapiDefaultQueueCallback) (
IN PVOID Context,
IN UINT Notification,
IN UINT_PTR Param1,
IN UINT_PTR Param2
);
PVOID
(*SetupapiInitDefaultQueueCallback) (
HWND OwnerWindow
);
VOID
(*SetupapiTermDefaultQueueCallback) (
PVOID Context
);
#ifdef UNICODE
BOOL
(*SetupapiGetSourceFileLocation) (
HINF InfHandle, // handle of an INF file
PINFCONTEXT InfContext, // optional, context of an INF file
PCTSTR FileName, // optional, source file to locate
PUINT SourceId, // receives the source media ID
PTSTR ReturnBuffer, // optional, receives the location
DWORD ReturnBufferSize, // size of the supplied buffer
PDWORD RequiredSize // optional, buffer size needed
);
BOOL
(*SetupapiGetInfInformation) (
LPCVOID InfSpec, // handle or filename of the INF file
DWORD SearchControl, // how to search for the INF file
PSP_INF_INFORMATION ReturnBuffer, // optional, receives the INF info
DWORD ReturnBufferSize, // size of the supplied buffer
PDWORD RequiredSize // optional, buffer size needed
);
BOOL
(*SetupapiQueryInfFileInformation) (
PSP_INF_INFORMATION InfInformation, // structure that contains the INF info
UINT InfIndex, // index of the file to investigate
PTSTR ReturnBuffer, // optional, receives the information
DWORD ReturnBufferSize, // size of the supplied buffer
PDWORD RequiredSize // optional, buffer size needed
);
BOOL
(*SetupapiQueryInfOriginalFileInformation) (
PSP_INF_INFORMATION InfInformation, // structure that contains the INF information
UINT InfIndex, // index of the file to investigate
PSP_ALTPLATFORM_INFO AlternatePlatformInfo, // optional, receives the alternate platform information
PSP_ORIGINAL_FILE_INFO OriginalFileInfo // original file information
);
#endif
//
//srclient.dll (SystemRestore) functions
//
DWORD
(*SRClientDisableSR) (
LPCWSTR pszDrive
);
//
// NEC98 Specific local function
//
VOID
DeleteNEC98DriveAssignFlag(
VOID
);
BOOLEAN
AdjustPrivilege(
PCTSTR Privilege
);
VOID
LocateFirstFloppyDrive(
VOID
);
VOID
W95SetABFwFresh(
int bBootDrvLtr
);
BOOL
NEC98CheckDMI(
VOID
);
VOID
DisableSystemRestore( void );
//
//
//
BOOL
GetArgsFromUnattendFile(
VOID
)
/*++
Routine Description:
This routine read relevent arguments from any specified unattended file.
Specifically we are concerned here with oem preinstall stuff and whether
to upgrade.
Arguments:
None.
Return Value:
Boolean value indicating whether the unattend file the user specified is
valid. If not, the user will have been told about why.
If the user specified no unattend file on the command line, then the
return value is TRUE.
--*/
{
DWORD d;
TCHAR Buffer[2*MAX_PATH];
BOOL b = TRUE;
PVOID InfHandle;
LPCTSTR p;
BOOL userDDU = FALSE;
#if defined(_AMD64_) || defined(_X86_)
POEM_BOOT_FILE FileStruct,Previous;
#endif
if(UnattendedScriptFile) {
d = GetFileAttributes(UnattendedScriptFile);
if(d == (DWORD)(-1)) {
MessageBoxFromMessage(
NULL,
MSG_UNATTEND_FILE_INVALID,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UnattendedScriptFile
);
return(FALSE);
}
//
// Before we do much else, we should make sure the user has given
// us a valid answer file. We can't check everything, but a quick
// and dirty sanity check would be to go ahead and call LoadInfFile
// and see what he says about it.
//
switch(LoadInfFile(UnattendedScriptFile,FALSE,&InfHandle)) {
case NO_ERROR:
break;
case ERROR_NOT_ENOUGH_MEMORY:
MessageBoxFromMessage(
NULL,
MSG_OUT_OF_MEMORY,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
return(FALSE);
break;
default:
MessageBoxFromMessage(
NULL,
MSG_UNATTEND_FILE_INVALID,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UnattendedScriptFile
);
return(FALSE);
break;
}
//
// Check upgrade.
//
// In previous versions of NT the default was not to upgrade if
// the value wasn't present at all. In addition there was an upgrade
// type of "single" which meant to upgrade only if there was only one
// NT build on the machine.
//
// We preserve the original default behavior but don't bother with
// dealing with the "single" semantics -- just accept "single" as
// a synonym for "yes".
//
GetPrivateProfileString(
WINNT_UNATTENDED,
ISNT() ? WINNT_U_NTUPGRADE : WINNT_U_WIN95UPGRADE,
WINNT_A_NO,
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
Upgrade = ((lstrcmpi(Buffer,WINNT_A_YES) == 0) || (lstrcmpi(Buffer,TEXT("single")) == 0));
#if defined(REMOTE_BOOT)
//
// Remote boot machines MUST upgrade.
//
if (RemoteBoot) {
Upgrade = TRUE;
}
#endif // defined(REMOTE_BOOT)
GetPrivateProfileString(
WINNT_UNATTENDED,
WINNT_OEMPREINSTALL,
WINNT_A_NO,
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
if(!lstrcmpi(Buffer,WINNT_A_YES)) {
//
// NTBUG9: 770278
// block setup if they specify both Upgrade and OemPreinstall
//
if (Upgrade) {
MessageBoxFromMessage(
NULL,
MSG_UNATTEND_FILE_INVALID,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UnattendedScriptFile
);
return FALSE;
}
OemPreinstall = TRUE;
//
// Add oem system directory to the list of optional directories.
//
// The user may have specified a different location for the $OEM$
// directory, so we need to look in the unattend file for that.
//
GetPrivateProfileString(
WINNT_UNATTENDED,
WINNT_OEM_DIRLOCATION,
WINNT_A_NO,
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
if( lstrcmpi( Buffer, WINNT_A_NO ) ) {
//
// make sure the location ends with "\$oem$". If it
// doesn't, then append it ourselves.
//
_tcsupr( Buffer );
if( !_tcsstr(Buffer, TEXT("$OEM$")) ) {
if (!ConcatenatePaths( Buffer, TEXT("$OEM$"), ARRAYSIZE(Buffer) )) {
DebugLog (
Winnt32LogError,
TEXT("The unattend file %1 specifies a path too long for key %2"),
0,
UnattendedScriptFile,
WINNT_OEM_DIRLOCATION
);
return FALSE;
}
}
UserSpecifiedOEMShare = DupString( Buffer );
RememberOptionalDir( UserSpecifiedOEMShare, OPTDIR_OEMSYS );
} else {
RememberOptionalDir(WINNT_OEM_DIR,OPTDIR_OEMSYS | OPTDIR_ADDSRCARCH);
}
if (!IsArc()) {
#if defined(_AMD64_) || defined(_X86_)
//
// Remember all oem boot files and then unload the inf.
//
Previous = NULL;
for(d=0; b && (p=InfGetFieldByIndex(InfHandle,WINNT_OEMBOOTFILES,d,0)); d++) {
if(FileStruct = MALLOC(sizeof(OEM_BOOT_FILE))) {
FileStruct->Next = NULL;
if(FileStruct->Filename = DupString(p)) {
if(Previous) {
Previous->Next = FileStruct;
} else {
OemBootFiles = FileStruct;
}
Previous = FileStruct;
} else {
b = FALSE;
}
} else {
b = FALSE;
}
}
if(!b) {
MessageBoxFromMessage(
NULL,
MSG_OUT_OF_MEMORY,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
}
#endif // defined(_AMD64_) || defined(_X86_)
} // if (!IsArc())
}
GetPrivateProfileString(
WINNT_USERDATA,
WINNT_US_PRODUCTID,
WINNT_A_NO,
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
if( lstrcmpi( Buffer, WINNT_A_NO ) == 0 )
{
GetPrivateProfileString(
WINNT_USERDATA,
WINNT_US_PRODUCTKEY,
WINNT_A_NO,
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
}
// Buffer contains the Product ID or WINNT_A_NO if none in the unattend file
// Is the PID encrypted?
// We would only need to check for the exact length, but since we can defer
// the decryption of an encrypted PID until GUI mode, 2 time the length should be saver
if (lstrlen(Buffer) > (4 + MAX_PID30_EDIT*5)*2)
{
LPTSTR szDecryptedPID = NULL;
HRESULT hr = ValidateEncryptedPID(Buffer, &szDecryptedPID);
DebugLog (Winnt32LogInformation, TEXT("ValidateEncryptedPID returned: <hr=0x%1!lx!>"), 0, hr);
if (FAILED(hr) || (hr == S_OK))
{
// if FAILED(hr) assume Crypto is not installed correct.
// If we encrypted the data, but the encrypted data did not contain valid data
// the function does not return a FAILED(hr) and does not return S_OK;
// It returns 0x01 to 0x04, depending on what failure.
// In the case we get a failure from Crypto ( it returns FAILED(hr))
// we want to defer the checking of the PID until GUI mode
// for that we need to save the encrypted PID
// First assume we defer PID validation.
g_bDeferPIDValidation = TRUE;
g_EncryptedPID = GlobalAlloc(GPTR, (lstrlen(Buffer) + 1) *sizeof(TCHAR));
if (g_EncryptedPID)
{
// Save the decrypted PID we need to write it to winnt.sif
lstrcpy(g_EncryptedPID, Buffer);
}
// Only if the PID could be decrypted and falls in to the time interval
// do we save the decrypted PID.
if (hr == S_OK)
{
lstrcpyn(ProductId, szDecryptedPID, ARRAYSIZE(ProductId));
g_bDeferPIDValidation = FALSE;
}
}
// else we could encrypt the data, but something is wrong
//
if (szDecryptedPID)
{
GlobalFree(szDecryptedPID);
}
}
else if (lstrcmpi(Buffer, WINNT_A_NO))
{
lstrcpyn(ProductId, Buffer, ARRAYSIZE(ProductId));
}
else
{
*ProductId = TEXT('\0');
}
GetPrivateProfileString(
WINNT_UNATTENDED,
TEXT("FileSystem"),
TEXT(""),
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
);
ForceNTFSConversion = !lstrcmpi(Buffer, TEXT("ConvertNTFS"));
if (!g_DynUpdtStatus->Disabled && !g_DynUpdtStatus->DynamicUpdatesSource[0]) {
//
// will Setup do the Dynamic Updates step at all?
//
if (GetPrivateProfileString(
WINNT_UNATTENDED,
WINNT_U_DYNAMICUPDATESDISABLE,
TEXT(""),
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
)
#ifdef PRERELEASE
|| GetPrivateProfileString(
WINNT_UNATTENDED,
TEXT("disabledynamicupdates"),
TEXT(""),
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
)
#endif
) {
userDDU = TRUE;
if( !lstrcmpi( Buffer, WINNT_A_YES ) ) {
g_DynUpdtStatus->Disabled = TRUE;
g_DynUpdtStatus->UserSpecifiedUpdates = FALSE;
}
}
}
if (!g_DynUpdtStatus->Disabled && !g_DynUpdtStatus->DynamicUpdatesSource[0]) {
//
// get location of previously downloaded files (if any)
//
if (GetPrivateProfileString(
WINNT_UNATTENDED,
WINNT_U_DYNAMICUPDATESHARE,
TEXT(""),
Buffer,
ARRAYSIZE(Buffer),
UnattendedScriptFile
)) {
if (MyGetFullPathName (
Buffer,
ARRAYSIZE(g_DynUpdtStatus->DynamicUpdatesSource),
g_DynUpdtStatus->DynamicUpdatesSource,
NULL) &&
DoesDirectoryExist (g_DynUpdtStatus->DynamicUpdatesSource)) {
RemoveTrailingWack (g_DynUpdtStatus->DynamicUpdatesSource);
g_DynUpdtStatus->UserSpecifiedUpdates = TRUE;
} else {
b = FALSE;
}
} else {
if (!userDDU) {
g_DynUpdtStatus->Disabled = TRUE;
}
}
}
UnloadInfFile(InfHandle);
}
return(b);
}
BOOL
ParseArguments(
VOID
)
/*++
Routine Description:
Parse arguments passed to the program. Perform syntactic validation
and fill in defaults where necessary.
Valid arguments:
/batch suppress message boxes
/cmd:command_line command to execute at end of gui setup
/copydir:dirname tree copy directory from source into %systemroot%
Note that this supports ".." syntax to backtrack
one directory
/copysource:dirname copy directory for use as source
/debug[level][:filename] maintain debug log at level, defaults to warning level 2
and file c:\winnt32.log
/DynamicUpdatesDisable disable dynamic setup
/s:source specify source
/syspart:letter force a drive to be considered the system partition
/tempdrive:letter manually specify drive for local source
/udf:id[,file] uniqueness id and optional udf
/unattend[num][:file] unattended mode with optional countdown
and unattend file. (The countdown is ignored
on Win95.) 'Unattended' is also accepted.
/nodownload not documented; on Win9x installs over the net,
do NOT download program files to a temporary directory and restart
from there. Effective in winnt32.exe only; here it's ignored
/local not documented; used by winnt32.exe only; ignored in winnt32a|u.dll
/# introduces undoc'ed/internal switches. Handed off
to internal switch handler in internal.c.
/restart specified when winnt32.exe was restarted as a result
of updating one of the underlying modules; internal only
/nosysparse suppress running sysparse.
/E:"PID:days" To encrypt the PID and add a delta of days,
needs to have /Unattend:file specified.
Arguments:
None. Arguments are retreived via GetCommandLine().
Return Value:
None.
--*/
{
LPTSTR Arg;
LPTSTR BadParam = NULL;
LPTSTR Colon;
LPTSTR p;
BOOL Valid;
LPCTSTR DebugFileLog;
LONG DebugLevel;
BOOL b;
unsigned u;
int argc;
LPTSTR *argv;
DWORD d;
WIN32_FIND_DATA fd;
DWORD attr;
TCHAR buffer[MAX_PATH];
argv = CommandLineToArgv(&argc);
//
// Skip program name. We should always get back argc as at least 1,
// but be robust anyway.
//
if(argc) {
argc--;
argv++;
}
DebugFileLog = NULL;
DebugLevel = 0;
Valid = TRUE;
while(argc--) {
Arg = *argv++;
if((*Arg == TEXT('/')) || (*Arg == TEXT('-'))) {
switch(_totupper(Arg[1])) {
case TEXT('B'):
if(!_tcsnicmp(Arg+1,TEXT("batch"),LENGTHOF("batch"))) {
BatchMode = TRUE;
} else {
Valid = FALSE;
}
break;
case TEXT('C'):
if(!_tcsnicmp(Arg+1,TEXT("copydir:"),LENGTHOF("copydir:"))) {
if(Arg[9]) {
RememberOptionalDir(Arg+9, OPTDIR_PLATFORM_SPECIFIC_FIRST);
} else {
Valid = FALSE;
}
} else if(!_tcsnicmp(Arg+1,TEXT("copysource:"),LENGTHOF("copysource:"))) {
if(Arg[12]) {
TCHAR TempString[MAX_PATH];
RememberOptionalDir(Arg+12, OPTDIR_TEMPONLY| OPTDIR_ADDSRCARCH);
#if defined(_WIN64)
//
// Add the i386\<optional dir> folder if it exists. This helps in the lang folder case where
// we advocate in the network install case to explicitly specify /copysource:lang
lstrcpy( TempString, TEXT("..\\I386"));
if (!ConcatenatePaths ( TempString, Arg+12, ARRAYSIZE(TempString))) {
Valid = FALSE;
break;
}
//Also check if an I386 equivalent WOW directory exists
AddCopydirIfExists( TempString, OPTDIR_TEMPONLY | OPTDIR_PLATFORM_INDEP );
#endif
} else {
Valid = FALSE;
}
} else if(!_tcsnicmp(Arg+1,TEXT("cmd:"),LENGTHOF("cmd:"))) {
if(CmdToExecuteAtEndOfGui) {
Valid = FALSE;
} else {
CmdToExecuteAtEndOfGui = Arg+5;
}
} else if(!_tcsnicmp(Arg+1,TEXT("checkupgradeonly"),LENGTHOF("checkupgradeonly"))) {
CheckUpgradeOnly = TRUE;
UnattendedOperation = TRUE;
//
// Tell the win9X upgrade dll to generate a
// report.
//
InternalProcessCmdLineArg( TEXT("/#U:ReportOnly") );
InternalProcessCmdLineArg( TEXT("/#U:PR") );
//
// See if the user wants this to run *really*
// quietly...
//
if(!_tcsnicmp(Arg+1,TEXT("checkupgradeonlyq"),LENGTHOF("checkupgradeonlyq"))) {
//
// Yep. Tell everyone to go through quietly...
//
CheckUpgradeOnlyQ = TRUE;
InternalProcessCmdLineArg( TEXT("/#U:CheckUpgradeOnlyQ") );
}
} else if(!_tcsnicmp(Arg+1,TEXT("cmdcons"),LENGTHOF("cmdcons"))) {
BuildCmdcons = TRUE;
NoCompliance = TRUE; // disable the compliance checking
} else {
Valid = FALSE;
}
break;
case TEXT('D'):
if (_tcsicmp(Arg+1,WINNT_U_DYNAMICUPDATESDISABLE) == 0
#ifdef PRERELEASE
|| _tcsicmp(Arg+1,TEXT("disabledynamicupdates")) == 0
#endif
) {
g_DynUpdtStatus->Disabled = TRUE;
break;
}
if (!_tcsnicmp (Arg + 1, WINNT_U_DYNAMICUPDATESHARE, LENGTHOF(WINNT_U_DYNAMICUPDATESHARE)) &&
Arg[LENGTHOF(WINNT_U_DYNAMICUPDATESHARE) + 1] == TEXT(':')) {
//
// Updated files specified on the command line
//
if (g_DynUpdtStatus->DynamicUpdatesSource[0]) {
Valid = FALSE;
break;
}
if (!MyGetFullPathName (
Arg + 1 + LENGTHOF(WINNT_U_DYNAMICUPDATESHARE) + 1,
ARRAYSIZE(g_DynUpdtStatus->DynamicUpdatesSource),
g_DynUpdtStatus->DynamicUpdatesSource,
NULL) ||
!DoesDirectoryExist (g_DynUpdtStatus->DynamicUpdatesSource)) {
Valid = FALSE;
break;
}
RemoveTrailingWack (g_DynUpdtStatus->DynamicUpdatesSource);
g_DynUpdtStatus->UserSpecifiedUpdates = !g_DynUpdtStatus->Disabled;
break;
}
if (!_tcsnicmp (Arg + 1, WINNT_U_DYNAMICUPDATESPREPARE, LENGTHOF(WINNT_U_DYNAMICUPDATESPREPARE)) &&
Arg[LENGTHOF(WINNT_U_DYNAMICUPDATESPREPARE) + 1] == TEXT(':')) {
if (g_DynUpdtStatus->DynamicUpdatesSource[0]) {
Valid = FALSE;
break;
}
if (!MyGetFullPathName (
Arg + 1 + LENGTHOF(WINNT_U_DYNAMICUPDATESPREPARE) + 1,
ARRAYSIZE(g_DynUpdtStatus->DynamicUpdatesSource),
g_DynUpdtStatus->DynamicUpdatesSource,
NULL) ||
!DoesDirectoryExist (g_DynUpdtStatus->DynamicUpdatesSource)) {
Valid = FALSE;
break;
}
RemoveTrailingWack (g_DynUpdtStatus->DynamicUpdatesSource);
g_DynUpdtStatus->PrepareWinnt32 = TRUE;
g_DynUpdtStatus->UserSpecifiedUpdates = !g_DynUpdtStatus->Disabled;
break;
}
if(DebugFileLog || _tcsnicmp(Arg+1,TEXT("debug"),LENGTHOF("debug"))) {
Valid = FALSE;
break;
}
DebugLevel = _tcstol(Arg+6,&Colon,10);
if((DebugLevel == -1) || (*Colon && (*Colon != TEXT(':')))) {
Valid = FALSE;
break;
}
if(Colon == Arg+6) {
//
// No debug level specified, use default
//
DebugLevel = Winnt32LogInformation;
}
if(*Colon) {
//
// Log file name was specified.
//
Colon++;
if(*Colon) {
DebugFileLog = Colon;
} else {
Valid = FALSE;
break;
}
}
break;
case TEXT('E'):
//
// Take care of headless parameters.
//
if( !_tcsnicmp(Arg+1,WINNT_U_HEADLESS_REDIRECT,LENGTHOF(WINNT_U_HEADLESS_REDIRECT)) ) {
if( Arg[LENGTHOF(WINNT_U_HEADLESS_REDIRECT)+2] ) {
if (FAILED (StringCchCopy (
HeadlessSelection,
ARRAYSIZE(HeadlessSelection),
Arg+(LENGTHOF(WINNT_U_HEADLESS_REDIRECT)+2)
))) {
Valid = FALSE;
}
} else {
Valid = FALSE;
}
} else if( !_tcsnicmp(Arg+1,WINNT_U_HEADLESS_REDIRECTBAUDRATE,LENGTHOF(WINNT_U_HEADLESS_REDIRECTBAUDRATE)) ) {
if( Arg[LENGTHOF(WINNT_U_HEADLESS_REDIRECTBAUDRATE)+2] ) {
HeadlessBaudRate = _tcstoul(Arg+(LENGTHOF(WINNT_U_HEADLESS_REDIRECTBAUDRATE)+2),NULL,10);
} else {
Valid = FALSE;
}
}
else if ( _tcsnicmp(Arg+1,WINNT_U_ENCRYPT,LENGTHOF(WINNT_U_ENCRYPT)) == 0 )
{
LPTSTR pTmp;
pTmp = &Arg[LENGTHOF(WINNT_U_ENCRYPT)+1];
Valid = FALSE;
// Make sure we have /Encrypt:
if (*pTmp == TEXT(':'))
{
pTmp++;
while (*pTmp && (*pTmp != TEXT(':')))
{
pTmp = CharNext(pTmp);
}
if (*pTmp == TEXT(':'))
{
*pTmp = TEXT('\0');
++pTmp;
PIDDays = _tcstoul(pTmp, NULL, 10);
Valid = ((PIDDays >= 5) && (PIDDays <= 60));
}
// Save the product ID.
if (FAILED (StringCchCopy (
ProductId,
ARRAYSIZE(ProductId),
&Arg[LENGTHOF(WINNT_U_ENCRYPT)+2]
))) {
Valid = FALSE;
break;
}
PIDEncryption = TRUE;
}
}else{
Valid = FALSE;
}
break;
case TEXT('L'):
if (_tcsicmp (Arg+1, TEXT("local"))) {
Valid = FALSE;
}
break;
case TEXT('M'):
//
// Alternate source for missing files
//
if(Arg[2] == TEXT(':')) {
if (!MyGetFullPathName (Arg+3, ARRAYSIZE(AlternateSourcePath), AlternateSourcePath, NULL) ||
!DoesDirectoryExist (AlternateSourcePath)) {
Valid = FALSE;
break;
}
//
// If the user is using the /M switch, he's got privates
// that he wants to use. It's possible that some of these
// privates will be in the driver cab, inwhich case, he'd
// have to make a copy of the cab with his private. Unreasonable.
// We can get around this by simply copying all the files
// from the user-specified private directory (/M<foobar>)
// into the local source. textmode and guimode will look
// for files before extractifi ming them from the CAB. All we
// need to do here is add the user's directory to the master
// copy list.
//
RememberOptionalDir(AlternateSourcePath,OPTDIR_OVERLAY);
//
// If we're using privates, go ahead and copy the
// source local.
//
MakeLocalSource = TRUE;
UserSpecifiedMakeLocalSource = TRUE;
} else if( !_tcsnicmp( Arg+1, TEXT("MakeLocalSource"), 15)) {
//
// check if there are any options for this switch
//
if (Arg[16] && Arg[16] != TEXT(':')) {
Valid = FALSE;
break;
}
MakeLocalSource = TRUE;
UserSpecifiedMakeLocalSource = TRUE;
if (!Arg[16]) {
break;
}
if (!Arg[17]) {
//
// add this for W2K backwards compatibility
//
break;
}
if (!_tcsicmp (Arg + 17, TEXT("all"))) {
//
// copy ALL CDs
//
MLSDiskID = 0;
} else {
DWORD chars;
if (!_stscanf (Arg + 17, TEXT("%u%n"), &MLSDiskID, &chars) || Arg[17 + chars] != 0) {
Valid = FALSE;
}
}
} else {
Valid = FALSE;
}
break;
case TEXT('N'):
//
// Possibly a /noreboot or /nosysparse?
//
if( !_tcsnicmp( Arg+1, TEXT("noreboot"), LENGTHOF("noreboot"))
//
// add this hack for W2K backwards compatibility
//
&& (!Arg[LENGTHOF("noreboot") + 1] ||
Arg[LENGTHOF("noreboot") + 1] == TEXT(':') && !Arg[LENGTHOF("noreboot") + 2]) ) {
AutomaticallyShutDown = FALSE;
}
#ifdef RUN_SYSPARSE
else if( !_tcsicmp( Arg+1, TEXT("nosysparse"))) {
NoSysparse = TRUE;
}
#endif
else if( _tcsicmp( Arg+1, TEXT("nodownload"))) {
Valid = FALSE;
}
break;
case TEXT('Q'):
g_Quiet = TRUE;
break;
case TEXT('R'):
if (!_tcsnicmp (Arg + 1, TEXT("Restart"), LENGTHOF("Restart"))) {
g_DynUpdtStatus->Winnt32Restarted = TRUE;
if (Arg[LENGTHOF("Restart") + 1] == TEXT(':')) {
lstrcpy (g_DynUpdtStatus->RestartAnswerFile, Arg + LENGTHOF("Restart:") + 1);
} else if (Arg[LENGTHOF("Restart") + 1]) {
Valid = FALSE;
}
} else {
Valid = FALSE;
}
break;
case TEXT('S'):
if((Arg[2] == TEXT(':')) && Arg[3]) {
//
// Ignore extraneous sources
//
if(SourceCount < MAX_SOURCE_COUNT) {
if (GetFullPathName (
Arg+3,
ARRAYSIZE(NativeSourcePaths[SourceCount]),
NativeSourcePaths[SourceCount],
NULL
)) {
SourceCount++;
} else {
Valid = FALSE;
}
}
} else {
if(!_tcsnicmp(Arg+1,TEXT("syspart:"),LENGTHOF("syspart:"))
&& Arg[1 + LENGTHOF("syspart:")]
&& (_totupper(Arg[1 + LENGTHOF("syspart:")]) >= TEXT('A'))
&& (_totupper(Arg[1 + LENGTHOF("syspart:")]) <= TEXT('Z'))
&& !ForcedSystemPartition) {
#ifdef _X86_
if (IsNEC98()){
if (!IsValidDrive(Arg[1 + LENGTHOF("syspart:")])){
Valid = FALSE;
break;
}
}
#endif
ForcedSystemPartition = (TCHAR)_totupper(Arg[1 + LENGTHOF("syspart:")]);
} else {
Valid = FALSE;
}
}
break;
case TEXT('T'):
if(_tcsnicmp(Arg+1,TEXT("tempdrive:"),LENGTHOF("tempdrive:"))
|| !(UserSpecifiedLocalSourceDrive = (TCHAR)_totupper(Arg[1 + LENGTHOF("tempdrive:")]))
|| (UserSpecifiedLocalSourceDrive < TEXT('A'))
|| (UserSpecifiedLocalSourceDrive > TEXT('Z'))) {
Valid = FALSE;
}
break;
case TEXT('U'):
if (_tcsicmp (Arg+1, TEXT("UpgradeAdvisor")) == 0) {
UpgradeAdvisorMode = TRUE;
break;
}
//
// Accept unattend and unattended as synonyms
//
b = FALSE;
if(!_tcsnicmp(Arg+1,TEXT("unattended"),LENGTHOF("unattended"))) {
b = TRUE;
u = 1 + LENGTHOF("unattended");
} else {
if(!_tcsnicmp(Arg+1,TEXT("unattend"),LENGTHOF("unattend"))) {
b = TRUE;
u = 1 + LENGTHOF("unattend");
}
}
if(b) {
if(!CheckUpgradeOnly && UnattendedOperation) {
Valid = FALSE;
break;
}
UnattendedOperation = TRUE;
UnattendSwitchSpecified = TRUE;
UnattendedShutdownTimeout = _tcstoul(Arg+u,&Colon,10);
if(UnattendedShutdownTimeout == (DWORD)(-1)) {
UnattendedShutdownTimeout = 0;
}
if(*Colon == 0) {
break;
}
if(*Colon++ != TEXT(':')) {
Valid = FALSE;
break;
}
if(*Colon) {
// UnattendedScriptFile = Colon;
//
// Get the name of the unattended script file
//
UnattendedScriptFile = MALLOC(MAX_PATH*sizeof(TCHAR));
if(UnattendedScriptFile) {
if(!GetFullPathName(
Colon,
MAX_PATH,
UnattendedScriptFile,
&p)) {
Valid = FALSE;
}
} else {
Valid = FALSE;
}
} else {
Valid = FALSE;
}
} else if(!_tcsnicmp(Arg+1,TEXT("udf:"),LENGTHOF("udf:"))) {
if(!Arg[1 + LENGTHOF("udf:")] || (Arg[1 + LENGTHOF("udf:")] == TEXT(',')) || UniquenessId) {
Valid = FALSE;
break;
}
//
// Get p to point to the filename if there is one specified,
// and terminate the ID part.
//
if(p = _tcschr(Arg+LENGTHOF("udf:")+2,TEXT(','))) {
*p++ = 0;
if(*p == 0) {
Valid = FALSE;
break;
}
}
UniquenessId = Arg + LENGTHOF("udf:") + 1;
UniquenessDatabaseFile = p;
} else {
Valid = FALSE;
}
break;
case TEXT('#'):
InternalProcessCmdLineArg(Arg);
break;
default:
Valid = FALSE;
break;
}
} else {
Valid = FALSE;
}
if(!Valid && !BadParam) {
BadParam = Arg;
}
}
if(Valid) {
if( DebugLevel == 0 ) {
DebugLevel = Winnt32LogInformation;
}
if( DebugFileLog == NULL ) {
MyGetWindowsDirectory (buffer, ARRAYSIZE(buffer));
if (ConcatenatePaths (buffer, S_WINNT32LOGFILE, ARRAYSIZE(buffer))) {
DebugFileLog = DupString (buffer);
}
}
if( DebugFileLog )
StartDebugLog(DebugFileLog,DebugLevel);
// If we do PID encryption (/Encrypt on the command line)
// we don't read the unattend file. We will write the encrypted PID to it later.
if (!PIDEncryption)
{
Valid = GetArgsFromUnattendFile();
}
}
else
{
//
// try to log the invalid argument pointed by BadParam
// this may not actually work if the log wasn't initialized yet
//
DebugLog (
Winnt32LogError,
TEXT("Error: Invalid argument [%1]"),
0,
BadParam
);
if (PIDEncryption)
{
// Invalid encrypt command line, Time frame invalid
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_INVALID_TIME_FRAME,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
else if(BatchMode) {
//
// Tell SMS about bad paramters
//
SaveMessageForSMS( MSG_INVALID_PARAMETER, BadParam );
} else {
//
// Show user the valid command line parameters
//
MyWinHelp(NULL,HELP_CONTEXT,IDH_USAGE);
}
}
return(Valid);
}
BOOL
RememberOptionalDir(
IN LPCTSTR Directory,
IN UINT Flags
)
/*++
Routine Description:
This routine adds a directory to the list of optional directories
to be copied. If the directory is already present it is not added
again.
Arguments:
Directory - supplies name of directory to be copied.
Flags - supplies flags for the directory. If the directory already
existed in the list, the current flags are NOT overwritten.
Return Value:
Boolean value indicating outcome. If FALSE, the caller can assume that
we've overflowed the number of allowed optional dirs.
--*/
{
UINT u;
//
// See if we have room.
//
if(OptionalDirectoryCount == MAX_OPTIONALDIRS) {
return(FALSE);
}
//
// If already there, do nothing.
//
for(u=0; u<OptionalDirectoryCount; u++) {
if(!lstrcmpi(OptionalDirectories[u],Directory)) {
return(TRUE);
}
}
//
// OK, add it.
//
DebugLog (Winnt32LogInformation, TEXT("Optional Directory <%1> added"), 0, Directory);
lstrcpy(OptionalDirectories[OptionalDirectoryCount],Directory);
OptionalDirectoryFlags[OptionalDirectoryCount] = Flags;
OptionalDirectoryCount++;
return(TRUE);
}
BOOL
CheckBuildNumber(
)
/*++
Routine Description:
This routine checks the build number of the NT system we're currently
running. Note that the build number is stored in a global variable
because we'll need it again later.
Arguments:
None.
Return Value:
Boolean value indicating whether to allow an upgrade from this build.
--*/
{
return( BuildNumber <= NT40 || BuildNumber >= NT50B1 );
}
BOOL
LoadSetupapi(
VOID
)
{
TCHAR Name[MAX_PATH], *p;
WIN32_FIND_DATA FindData;
HANDLE FindHandle;
HMODULE Setupapi;
BOOL WeLoadedLib = FALSE;
BOOL b = FALSE;
PCTSTR Header;
//
// Use the setupapi.dll that was loaded by an upgrade module
//
Setupapi = GetModuleHandle (TEXT("SETUPAPI.DLL"));
if (!Setupapi) {
//
// Upgrade module did not load SETUPAPI.DLL, so we must load it.
// If setupapi.dll is in the system directory, use the one that's there.
//
if (GetSystemDirectory(Name,ARRAYSIZE(Name)) &&
ConcatenatePaths(Name,TEXT("SETUPAPI.DLL"),ARRAYSIZE(Name))) {
FindHandle = FindFirstFile(Name,&FindData);
if(FindHandle == INVALID_HANDLE_VALUE) {
//
// Not there. Fetch the dll out of the win95 upgrade
// support directory.
//
if(MyGetModuleFileName(NULL,Name,ARRAYSIZE(Name)) && (p = _tcsrchr(Name,TEXT('\\')))){
*p= 0;
if (ConcatenatePaths(Name,WINNT_WIN95UPG_95_DIR,ARRAYSIZE(Name)) &&
ConcatenatePaths(Name,TEXT("SETUPAPI.DLL"),ARRAYSIZE(Name))) {
Setupapi = LoadLibraryEx(Name,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
}
}
} else {
//
// Already in system directory.
//
FindClose(FindHandle);
Setupapi = LoadLibrary(TEXT("SETUPAPI.DLL"));
}
if (Setupapi) {
WeLoadedLib = TRUE;
}
}
}
if(Setupapi) {
#ifdef UNICODE
b = (((FARPROC)SetupapiDecompressOrCopyFile = GetProcAddress(Setupapi,"SetupDecompressOrCopyFileW")) != NULL);
b = b && ((FARPROC)SetupapiOpenInfFile = GetProcAddress(Setupapi,"SetupOpenInfFileW"));
b = b && ((FARPROC)SetupapiGetLineCount = GetProcAddress(Setupapi,"SetupGetLineCountW"));
b = b && ((FARPROC)SetupapiGetStringField = GetProcAddress(Setupapi,"SetupGetStringFieldW"));
b = b && ((FARPROC)SetupapiGetLineByIndex = GetProcAddress(Setupapi,"SetupGetLineByIndexW"));
b = b && ((FARPROC)SetupapiFindFirstLine = GetProcAddress(Setupapi,"SetupFindFirstLineW"));
b = b && ((FARPROC)SetupapiFindNextMatchLine = GetProcAddress(Setupapi,"SetupFindNextMatchLineW"));
//
// needed for DU
//
b = b && ((FARPROC)SetupapiQueueCopy = GetProcAddress(Setupapi,"SetupQueueCopyW"));
b = b && ((FARPROC)SetupapiCommitFileQueue = GetProcAddress(Setupapi,"SetupCommitFileQueueW"));
b = b && ((FARPROC)SetupapiDefaultQueueCallback = GetProcAddress(Setupapi,"SetupDefaultQueueCallbackW"));
//
// needed in unsupdrv.c
//
b = b && ((FARPROC)SetupapiGetInfInformation = GetProcAddress(Setupapi,"SetupGetInfInformationW"));
b = b && ((FARPROC)SetupapiQueryInfFileInformation = GetProcAddress(Setupapi,"SetupQueryInfFileInformationW"));
(FARPROC)SetupapiGetSourceFileLocation = GetProcAddress(Setupapi,"SetupGetSourceFileLocationW");
(FARPROC)SetupapiQueryInfOriginalFileInformation = GetProcAddress(Setupapi,"SetupQueryInfOriginalFileInformationW");
#else
b = (((FARPROC)SetupapiDecompressOrCopyFile = GetProcAddress(Setupapi,"SetupDecompressOrCopyFileA")) != NULL);
b = b && ((FARPROC)SetupapiOpenInfFile = GetProcAddress(Setupapi,"SetupOpenInfFileA"));
b = b && ((FARPROC)SetupapiGetLineCount = GetProcAddress(Setupapi,"SetupGetLineCountA"));
b = b && ((FARPROC)SetupapiGetStringField = GetProcAddress(Setupapi,"SetupGetStringFieldA"));
b = b && ((FARPROC)SetupapiGetLineByIndex = GetProcAddress(Setupapi,"SetupGetLineByIndexA"));
b = b && ((FARPROC)SetupapiFindFirstLine = GetProcAddress(Setupapi,"SetupFindFirstLineA"));
b = b && ((FARPROC)SetupapiFindNextMatchLine = GetProcAddress(Setupapi,"SetupFindNextMatchLineA"));
//
// needed for DU
//
b = b && ((FARPROC)SetupapiQueueCopy = GetProcAddress(Setupapi,"SetupQueueCopyA"));
b = b && ((FARPROC)SetupapiCommitFileQueue = GetProcAddress(Setupapi,"SetupCommitFileQueueA"));
b = b && ((FARPROC)SetupapiDefaultQueueCallback = GetProcAddress(Setupapi,"SetupDefaultQueueCallbackA"));
#endif
b = b && ((FARPROC)SetupapiCloseInfFile = GetProcAddress(Setupapi,"SetupCloseInfFile"));
//
// needed for DU
//
b = b && ((FARPROC)SetupapiOpenFileQueue = GetProcAddress(Setupapi,"SetupOpenFileQueue"));
b = b && ((FARPROC)SetupapiCloseFileQueue = GetProcAddress(Setupapi,"SetupCloseFileQueue"));
b = b && ((FARPROC)SetupapiInitDefaultQueueCallback = GetProcAddress(Setupapi,"SetupInitDefaultQueueCallback"));
b = b && ((FARPROC)SetupapiTermDefaultQueueCallback = GetProcAddress(Setupapi,"SetupTermDefaultQueueCallback"));
b = b && ((FARPROC)SetupapiGetFieldCount = GetProcAddress(Setupapi,"SetupGetFieldCount"));
b = b && ((FARPROC)SetupapiFindNextLine = GetProcAddress(Setupapi,"SetupFindNextLine"));
(FARPROC)fnSetupOpenLog = GetProcAddress(Setupapi, "SetupOpenLog");
#ifdef UNICODE
(FARPROC)fnSetupLogError = GetProcAddress(Setupapi, "SetupLogErrorW");
#else
(FARPROC)fnSetupLogError = GetProcAddress(Setupapi, "SetupLogErrorA");
#endif
(FARPROC)fnSetupCloseLog = GetProcAddress(Setupapi, "SetupCloseLog");
}
//
// If the below if() fails, we must be on a platform that has
// a setupapi.dll without the new log API. In that case, neither
// upgrade DLLs have loaded their own setupapi, so we don't care
// about logging, and we eat the error.
//
if (fnSetupOpenLog && fnSetupLogError && fnSetupCloseLog) {
if (!Winnt32Restarted ()) {
//
// Log APIs exist, so delete setupact.log and setuperr.log, write header
//
fnSetupOpenLog (TRUE);
Header = GetStringResource (MSG_LOG_BEGIN);
if (Header) {
fnSetupLogError (Header, LogSevInformation);
FreeStringResource (Header);
}
fnSetupCloseLog();
}
}
if(!b) {
if (WeLoadedLib) {
FreeLibrary(Setupapi);
}
MessageBoxFromMessage(
NULL,
MSG_CANT_LOAD_SETUPAPI,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
TEXT("setupapi.dll")
);
}
return b;
}
VOID
LoadUpgradeSupport(
VOID
)
/*++
Routine Description:
This routine loads the Win95 upgrade dll or the NT upgrade dll and
retreives its significant entry points.
Arguments:
None.
Return Value:
--*/
{
DWORD d;
DWORD i;
LPTSTR *sourceDirectories;
HKEY hKey;
DWORD dwErr = ERROR_SUCCESS;
DWORD dwSize;
TCHAR buffer[MAX_PATH];
PTSTR p;
TCHAR dst[MAX_PATH];
TCHAR src[MAX_PATH];
ZeroMemory(&UpgradeSupport,sizeof(UpgradeSupport));
if (!ISNT()) {
//
// Don't load on server
//
// assert that the Server global variable is accurate
MYASSERT (UpgradeProductType != UNKNOWN);
if (Server) {
return;
}
//
// Form full Win95 path of DLL.
//
if (!BuildPath(buffer, WINNT_WIN95UPG_95_DIR, WINNT_WIN95UPG_95_DLL)) {
buffer[0] = 0;
}
} else {
//
// Form full NT path of DLL.
//
if (!BuildPath(buffer, WINNT_WINNTUPG_DIR, WINNT_WINNTUPG_DLL)) {
buffer[0] = 0;
}
}
if (buffer[0] &&
FindPathToWinnt32File (buffer, UpgradeSupport.DllPath, ARRAYSIZE(UpgradeSupport.DllPath))) {
//
// Load the library. Use LoadLibraryEx to get the system to resolve DLL
// references starting in the dir where w95upg.dll is, instead of the
// directory where winnt32.exe is.
//
// If we're upgrading from NT5, use the system's setupapi.
//
//
// HACK HACK HACK - see NTBUG9: 354926
// some OEM machines have KnownDlls registered, but actually missing
// this leads to a failure of LoadLibrary
// we need a workaround for this
//
PSTRINGLIST missingKnownDlls = NULL;
FixMissingKnownDlls (&missingKnownDlls, TEXT("imagehlp.dll\0"));
if (!ISNT()) {
UpgradeSupport.DllModuleHandle = LoadLibraryEx(
UpgradeSupport.DllPath,
NULL,
LOAD_WITH_ALTERED_SEARCH_PATH
);
} else {
UpgradeSupport.DllModuleHandle = LoadLibraryEx(
UpgradeSupport.DllPath,
NULL,
(BuildNumber > NT40) ? 0 : LOAD_WITH_ALTERED_SEARCH_PATH
);
}
if (missingKnownDlls) {
DWORD rc = GetLastError ();
UndoFixMissingKnownDlls (missingKnownDlls);
SetLastError (rc);
}
} else {
//
// just for display purposes, use default path
//
MyGetModuleFileName (NULL, UpgradeSupport.DllPath, ARRAYSIZE(UpgradeSupport.DllPath));
p = _tcsrchr (UpgradeSupport.DllPath, TEXT('\\'));
if (p) {
*p = 0;
}
ConcatenatePaths (UpgradeSupport.DllPath, buffer, ARRAYSIZE(buffer));
SetLastError (ERROR_FILE_NOT_FOUND);
}
if(!UpgradeSupport.DllModuleHandle) {
d = GetLastError();
if(d == ERROR_DLL_NOT_FOUND) {
d = ERROR_FILE_NOT_FOUND;
}
MessageBoxFromMessageAndSystemError(
NULL,
MSG_UPGRADE_DLL_ERROR,
d,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UpgradeSupport.DllPath
);
goto c0;
} else {
DebugLog (Winnt32LogInformation, TEXT("Loaded upgrade module: <%1>"), 0, UpgradeSupport.DllPath);
}
//
// Get entry points.
//
(FARPROC)UpgradeSupport.InitializeRoutine = GetProcAddress(
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_INIT_NAME
);
(FARPROC)UpgradeSupport.GetPagesRoutine = GetProcAddress(
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_GETPAGES_NAME
);
(FARPROC)UpgradeSupport.WriteParamsRoutine = GetProcAddress(
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_WRITEPARAMS_NAME
);
(FARPROC)UpgradeSupport.CleanupRoutine = GetProcAddress(
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_CLEANUP_NAME
);
#ifdef _X86_
if (IsNEC98()){
(FARPROC)W95SetAutoBootFlag = GetProcAddress(
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_SETAUTOBOOT_NAME
);
}
info.Boot16 = &g_Boot16;
if (!ISNT()) {
(FARPROC)UpgradeSupport.OptionalDirsRoutine = GetProcAddress (
UpgradeSupport.DllModuleHandle,
WINNT32_PLUGIN_GETOPTIONALDIRS_NAME
);
}
#endif
if(!UpgradeSupport.InitializeRoutine
|| !UpgradeSupport.GetPagesRoutine
|| !UpgradeSupport.WriteParamsRoutine
|| !UpgradeSupport.CleanupRoutine) {
//
// Entry points couldn't be found. The upgrade dll is corrupt.
//
MessageBoxFromMessage(
NULL,
MSG_UPGRADE_DLL_CORRUPT,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UpgradeSupport.DllPath
);
goto c1;
}
//
// Fill in the info structure. This will be passed to the DLL's init routine.
//
info.Size = sizeof(info);
info.UnattendedFlag = &UnattendedOperation;
info.CancelledFlag = &Cancelled;
info.AbortedFlag = &Aborted;
info.UpgradeFlag = &Upgrade;
info.LocalSourceModeFlag = &MakeLocalSource;
info.CdRomInstallFlag = &RunFromCD;
info.UnattendedScriptFile = &UnattendedScriptFile;
info.UpgradeOptions = &UpgradeOptions;
info.NotEnoughSpaceBlockFlag = &BlockOnNotEnoughSpace;
info.LocalSourceDrive = &LocalSourceDriveOffset;
info.LocalSourceSpaceRequired = &LocalSourceSpaceRequired;
info.ForceNTFSConversion = &ForceNTFSConversion;
info.ProductFlavor = &ProductFlavor;
info.SetupFlags = &dwSetupFlags;
//
// Version info fields
//
info.ProductType = &UpgradeProductType;
info.BuildNumber = VER_PRODUCTBUILD;
info.ProductVersion = VER_PRODUCTVERSION_W;
#if DBG
info.Debug = TRUE;
#else
info.Debug = FALSE;
#endif
#ifdef PRERELEASE
info.PreRelease = TRUE;
#else
info.PreRelease = FALSE;
#endif
//
// Source directories
//
sourceDirectories = (LPTSTR *) MALLOC(sizeof(LPTSTR) * MAX_SOURCE_COUNT);
if (sourceDirectories) {
for (i=0;i<MAX_SOURCE_COUNT;i++) {
sourceDirectories[i] = NativeSourcePaths[i];
}
}
info.SourceDirectories = sourceDirectories;
info.SourceDirectoryCount = &SourceCount;
info.UnattendSwitchSpecified = &UnattendSwitchSpecified;
info.DUCompletedSuccessfully = &g_DynUpdtStatus->Successful;
if (!IsArc()) {
#if defined(_AMD64_) || defined(_X86_)
if (!ISNT()) {
//
// Fill in win9xupg specific information. This is done so that the win9xupg
// team can add more parameters to the structure without disturbing other
// upgrade dll writers. If a paramter is needed in both cases, it should
// be placed in the info structure above.
//
Win9xInfo.Size = sizeof (Win9xInfo);
Win9xInfo.BaseInfo = &info;
Win9xInfo.WinDirSpace = &WinDirSpaceFor9x;
Win9xInfo.RequiredMb = &UpgRequiredMb;
Win9xInfo.AvailableMb = &UpgAvailableMb;
Win9xInfo.DynamicUpdateLocalDir = g_DynUpdtStatus->WorkingDir;
Win9xInfo.DynamicUpdateDrivers = g_DynUpdtStatus->SelectedDrivers;
Win9xInfo.UpginfsUpdated = &UpginfsUpdated;
//
// Save the location of the original location of w95upg.dll. Because of dll
// replacement, this may be different than the actual w95upg.dll location
// used.
//
MyGetModuleFileName (NULL, UpgradeSourcePath, ARRAYSIZE(UpgradeSourcePath));
p = _tcsrchr (UpgradeSourcePath, TEXT('\\'));
if (p) {
*p = 0;
}
if (!ConcatenatePaths (UpgradeSourcePath, WINNT_WIN95UPG_95_DIR, ARRAYSIZE(UpgradeSourcePath))) {
d = ERROR_INSUFFICIENT_BUFFER;
} else {
Win9xInfo.UpgradeSourcePath = UpgradeSourcePath;
//
// Copy over optional directories just as we did with source directories above.
//
sourceDirectories = (LPTSTR *) MALLOC(sizeof(LPTSTR) * MAX_OPTIONALDIRS);
if (sourceDirectories) {
for (i=0;i<MAX_OPTIONALDIRS;i++) {
sourceDirectories[i] = OptionalDirectories[i];
}
}
Win9xInfo.OptionalDirectories = sourceDirectories;
Win9xInfo.OptionalDirectoryCount = &OptionalDirectoryCount;
Win9xInfo.UpgradeFailureReason = &UpgradeFailureReason;
//
// Read disk sectors routine. Win9xUpg uses this when looking for other os installations.
//
Win9xInfo.ReadDiskSectors = ReadDiskSectors;
d = UpgradeSupport.InitializeRoutine((PWINNT32_PLUGIN_INIT_INFORMATION_BLOCK) &Win9xInfo);
}
}
else {
d = UpgradeSupport.InitializeRoutine(&info);
}
#endif // defined(_AMD64_) || defined(_X86_)
} else {
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
//
// Call the DLL's init routine and get-pages routine. If either fails tell the user.
//
d = UpgradeSupport.InitializeRoutine(&info);
#endif // UNICODE
} // if (!IsArc())
if(d == NO_ERROR) {
d = UpgradeSupport.GetPagesRoutine(
&UpgradeSupport.AfterWelcomePageCount,
&UpgradeSupport.Pages1,
&UpgradeSupport.AfterOptionsPageCount,
&UpgradeSupport.Pages2,
&UpgradeSupport.BeforeCopyPageCount,
&UpgradeSupport.Pages3
);
}
//
// By returning ERROR_REQUEST_ABORTED, an upgrade dll can refuse to upgrade the machine.
// In this case, no message will be generated by this routine and the option to upgrade
// will be grayed out on the wizard page. In the case of all other error messages, winnt32
// will warn the user that the upgrade dll failed to initialize. The upgrade.dll is expected
// to provide whatever UI is necessary before returning from its init routine.
//
if (UpgradeFailureReason > REASON_LAST_REASON) {
UpgradeFailureReason = REASON_LAST_REASON;
}
if(d == NO_ERROR) {
return;
}
if (d != ERROR_REQUEST_ABORTED) {
SkipVirusScannerCheck = TRUE;
MessageBoxFromMessageAndSystemError(
NULL,
MSG_UPGRADE_INIT_ERROR,
d,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
c1:
FreeLibrary(UpgradeSupport.DllModuleHandle);
ZeroMemory (&UpgradeSupport, sizeof (UpgradeSupport));
}
c0:
Upgrade = FALSE;
return;
}
#ifdef _X86_
BOOL
CheckVirusScanners (
VOID
)
/*++
Routine Description:
This routine is used to check for virus scanners on win9x machines that can
impeed setup (either in a clean install or upgrade case.) The function simply
calls an entry point within the w95upg.dll and that module performs the
actual check.
Arguments:
None.
Return Value:
TRUE if no virus scanners were detected that could cause problems. FALSE if a virus
scanner was detected that could cause setup to fail. We rely on the w95upg.dll code
to provide an appropriate message to the user before returning to us.
--*/
{
HANDLE dllHandle;
PWINNT32_PLUGIN_VIRUSSCANNER_CHECK_ROUTINE virusScanRoutine;
//
// This check is win9xupg specific.
//
if (ISNT()) {
return TRUE;
}
dllHandle = GetModuleHandle (WINNT_WIN95UPG_95_DLL);
//
// If the module was not loaded, we'll skip this check.
//
if (!dllHandle) {
return TRUE;
}
//
// Get entry points.
//
(FARPROC) virusScanRoutine = GetProcAddress(dllHandle, WINNT32_PLUGIN_VIRUSSCANCHECK_NAME);
if (!virusScanRoutine) {
//
// corrupt dll or something
//
return FALSE;
}
//
// Now, simply call the routine. It will handle the actuall checking as well as informing the user.
//
return virusScanRoutine ();
}
#endif
BOOL
ValidateSourceLocation(
VOID
)
/*++
Routine Description:
This routine checks the initial source location to see if it's
valid. The first source location must be valid for setup to
work, and this catches typos by the user. It cannot detect
transient network conditions, so this is not foolproof.
We check this by looking for a required file, dosnet.inf, at
the source location.
Arguments:
None.
Return Value:
TRUE if the source location appears valid
--*/
{
TCHAR FileName[MAX_PATH];
WIN32_FIND_DATA fd;
if (FAILED (StringCchCopy (FileName, ARRAYSIZE(FileName), NativeSourcePaths[0])) ||
!ConcatenatePaths(FileName, InfName, ARRAYSIZE(FileName))) {
return FALSE;
}
if (!FileExists( FileName, &fd) || (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
return FALSE;
}
//
// also look for system32\ntdll.dll as a second check
//
if (FAILED (StringCchCopy (FileName, ARRAYSIZE(FileName), NativeSourcePaths[0])) ||
!ConcatenatePaths(FileName, TEXT("system32\\ntdll.dll"), ARRAYSIZE(FileName))) {
return(FALSE);
}
return FileExists( FileName, &fd) && !(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
}
VOID
pRemoveOutdatedBackupImage (
VOID
)
{
REMOVEUNINSTALLIMAGE removeFn;
HMODULE lib;
UINT build;
//
// Is this current build > build we plan to install?
//
if (!ISNT() || !Upgrade) {
return;
}
build = GetMediaProductBuildNumber();
if (!build) {
return;
}
if (build == BuildNumber) {
return;
}
//
// Attempt to remove uninstall image
//
lib = LoadLibraryA ("osuninst.dll");
if (!lib) {
return;
}
removeFn = (REMOVEUNINSTALLIMAGE) GetProcAddress (lib, "RemoveUninstallImage");
if (removeFn) {
removeFn();
}
FreeLibrary (lib);
}
BOOL
GetProductType (
VOID
)
{
TCHAR buffer[256];
if (!FullInfName[0]) {
if (!FindPathToWinnt32File (InfName, FullInfName, ARRAYSIZE(InfName))) {
FullInfName[0] = 0;
return FALSE;
}
}
//
// get some data from the main inf
//
if (!GetPrivateProfileString (
TEXT("Miscellaneous"),
TEXT("ProductType"),
TEXT(""),
buffer,
ARRAYSIZE(buffer),
FullInfName
)) {
DebugLog (
Winnt32LogError,
TEXT("%1 key in [%2] section is missing from %3; aborting operation"),
0,
TEXT("ProductType"),
TEXT("Miscellaneous"),
FullInfName
);
return FALSE;
}
// Test for valid product type (0 == pro, 6 == sbs)
if (buffer[0] < TEXT('0') || buffer[0] > TEXT('6') || buffer[1]) {
DebugLog (
Winnt32LogError,
TEXT("Invalid %1 value (%2) in %3"),
0,
TEXT("ProductType"),
buffer,
FullInfName
);
return FALSE;
}
ProductFlavor = buffer[0] - TEXT('0');
Server = (ProductFlavor != PROFESSIONAL_PRODUCTTYPE && ProductFlavor != PERSONAL_PRODUCTTYPE);
UpgradeProductType = Server ? NT_SERVER : NT_WORKSTATION;
return TRUE;
}
UINT
GetMediaProductBuildNumber (
VOID
)
{
TCHAR buffer[256];
PCTSTR p;
PTSTR q;
UINT build;
if (!FullInfName[0]) {
if (!FindPathToWinnt32File (InfName, FullInfName, MAX_PATH)) {
return 0;
}
}
//
// get some data from the main inf
//
if (!GetPrivateProfileString (
TEXT("Version"),
TEXT("DriverVer"),
TEXT(""),
buffer,
ARRAYSIZE(buffer),
FullInfName
)) {
DebugLog (
Winnt32LogError,
TEXT("Version key in [DriverVer] section is missing from %1; aborting operation"),
0,
FullInfName
);
return 0;
}
p = _tcschr (buffer, TEXT(','));
if (p) {
//
// p should point to ",<major>.<minor>.<build>.0" -- extract <build>
//
p = _tcschr (p + 1, TEXT('.'));
if (p) {
p = _tcschr (p + 1, TEXT('.'));
if (p) {
p = _tcsinc (p);
q = _tcschr (p, TEXT('.'));
if (q) {
*q = 0;
} else {
p = NULL;
}
}
}
}
if (p) {
build = _tcstoul (p, &q, 10);
if (*q) {
p = NULL;
}
}
if (!p || build < NT51B2) {
DebugLog (
Winnt32LogError,
TEXT("Unexpected data %1, found in Version key in [DriverVer] section of %2; aborting operation"),
0,
buffer,
FullInfName
);
return 0;
}
return build;
}
typedef HANDLE (WINAPI * PWINSTATIONOPENSERVERW)(LPWSTR);
typedef BOOLEAN (WINAPI * PWINSTATIONCLOSESERVER)(HANDLE);
UINT GetLoggedOnUserCount()
{
UINT iCount = 0;
HMODULE hwinsta;
PWINSTATIONOPENSERVERW pfnWinStationOpenServerW;
PWINSTATIONENUMERATEW pfnWinStationEnumerateW;
PWINSTATIONFREEMEMORY pfnWinStationFreeMemory;
PWINSTATIONCLOSESERVER pfnWinStationCloseServer;
/*
* Get handle to winsta.dll
*/
hwinsta = LoadLibraryA("WINSTA");
if (hwinsta != NULL)
{
pfnWinStationOpenServerW = (PWINSTATIONOPENSERVERW)GetProcAddress(hwinsta, "WinStationOpenServerW");
pfnWinStationEnumerateW = (PWINSTATIONENUMERATEW)GetProcAddress(hwinsta, "WinStationEnumerateW");
pfnWinStationFreeMemory = (PWINSTATIONFREEMEMORY)GetProcAddress(hwinsta, "WinStationFreeMemory");
pfnWinStationCloseServer = (PWINSTATIONCLOSESERVER)GetProcAddress(hwinsta, "WinStationCloseServer");
if (pfnWinStationOpenServerW &&
pfnWinStationEnumerateW &&
pfnWinStationFreeMemory &&
pfnWinStationCloseServer)
{
HANDLE hServer;
// Open a connection to terminal services and get the number of sessions.
hServer = pfnWinStationOpenServerW((LPWSTR)SERVERNAME_CURRENT);
if (hServer != NULL)
{
PLOGONIDW pLogonIDs;
ULONG ulEntries;
if (pfnWinStationEnumerateW(hServer, &pLogonIDs, &ulEntries))
{
ULONG ul;
PLOGONIDW pLogonID;
/*
* Iterate the sessions looking for active and disconnected sessions only.
* Then match the user name and domain (case INsensitive) for a result.
*/
for (ul = 0, pLogonID = pLogonIDs; ul < ulEntries; ul++, pLogonID++)
{
if ((pLogonID->State == State_Active) ||
(pLogonID->State == State_Disconnected) ||
(pLogonID->State == State_Shadow))
{
iCount++;
}
}
/*
* Free any resources used.
*/
pfnWinStationFreeMemory(pLogonIDs);
}
pfnWinStationCloseServer(hServer);
}
}
FreeLibrary(hwinsta);
}
return iCount;
}
// From winuser.h, but since we cannot define WINVER >= 0x0500 I copied it here.
#define SM_REMOTESESSION 0x1000
BOOL DisplayExitWindowsWarnings(uExitWindowsFlags)
{
BOOL bRet = TRUE;
BOOL fIsRemote = GetSystemMetrics(SM_REMOTESESSION);
UINT iNumUsers = GetLoggedOnUserCount();
UINT uID = 0;
switch (uExitWindowsFlags)
{
case EWX_POWEROFF:
case EWX_SHUTDOWN:
{
if (fIsRemote)
{
// We are running as part of a terminal server session
if (iNumUsers > 1)
{
// Warn the user if remote shut down w/ active users
uID = IDS_SHUTDOWN_REMOTE_OTHERUSERS;
}
else
{
// Warn the user if remote shut down (won't be able to restart via TS client!)
uID = IDS_SHUTDOWN_REMOTE;
}
}
else
{
if (iNumUsers > 1)
{
// Warn the user if more than one user session active
uID = IDS_SHUTDOWN_OTHERUSERS;
}
}
}
break;
case EWX_REBOOT:
{
// Warn the user if more than one user session active.
if (iNumUsers > 1)
{
uID = IDS_RESTART_OTHERUSERS;
}
}
break;
}
if (uID != 0)
{
TCHAR szTitle[MAX_PATH] = TEXT("");
TCHAR szMessage[MAX_PATH] = TEXT("");
LoadString(hInst, IDS_APPTITLE, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
LoadString(hInst, uID, szMessage, sizeof(szMessage)/sizeof(szMessage[0]));
if (MessageBox(NULL,
szMessage,
szTitle,
MB_ICONEXCLAMATION | MB_YESNO | MB_SYSTEMMODAL | MB_SETFOREGROUND) == IDNO)
{
bRet = FALSE;
}
}
return bRet;
}
#define SETUP_MEMORY_MIN_REQUIREMENT ((ULONG_PTR)(50<<20)) //50MB
#define SETUP_DISK_MIN_REQUIREMENT ((ULONG_PTR)(70<<20)) //70MB
BOOL
pIsEnoughVMAndDiskSpace(
OUT ULARGE_INTEGER * OutRemainFreeSpace, OPTIONAL
IN BOOL bCheckOnlyRAM OPTIONAL
)
{
PVOID pMemory;
TCHAR winDir[MAX_PATH];
TCHAR winDrive[] = TEXT("?:\\");
ULARGE_INTEGER RemainFreeSpace = {0, 0};
DWORD sectorPerCluster;
DWORD bytesPerSector;
ULARGE_INTEGER numberOfFreeClusters = {0, 0};
ULARGE_INTEGER totalNumberOfClusters = {0, 0};
BOOL bResult = TRUE;
if(OutRemainFreeSpace){
OutRemainFreeSpace->QuadPart = 0;
}
pMemory = VirtualAlloc(NULL, SETUP_MEMORY_MIN_REQUIREMENT, MEM_COMMIT, PAGE_NOACCESS);
if(!pMemory){
return FALSE;
}
if(!bCheckOnlyRAM){
if (!MyGetWindowsDirectory(winDir, ARRAYSIZE(winDir))) {
bResult = FALSE;
goto exit;
}
winDrive[0] = winDir[0];
bCheckOnlyRAM = GetDriveType(winDrive) != DRIVE_FIXED;
}
if(!bCheckOnlyRAM){
if(Winnt32GetDiskFreeSpaceNew(winDrive,
&sectorPerCluster,
&bytesPerSector,
&numberOfFreeClusters,
&totalNumberOfClusters)){
RemainFreeSpace.QuadPart = sectorPerCluster * bytesPerSector;
RemainFreeSpace.QuadPart *= numberOfFreeClusters.QuadPart;
if(OutRemainFreeSpace){
OutRemainFreeSpace->QuadPart = RemainFreeSpace.QuadPart;
}
if(RemainFreeSpace.QuadPart < SETUP_DISK_MIN_REQUIREMENT){
bResult = FALSE;
}
}
else{
MYASSERT(FALSE);
}
}
exit:
VirtualFree(pMemory, SETUP_MEMORY_MIN_REQUIREMENT, MEM_DECOMMIT);
return bResult;
}
LPTOP_LEVEL_EXCEPTION_FILTER pLastExceptionFilter = NULL;
LONG MyFilter(EXCEPTION_POINTERS *pep)
{
static BOOL fGotHere = FALSE;
PSETUP_FAULT_HANDLER pSetupFH = NULL;
HMODULE hmodFaultRep = NULL;
PFAULTHCreate pfnCreate = NULL;
PFAULTHDelete pfnDelete = NULL;
DWORD dwRetRep = EXCEPTION_CONTINUE_SEARCH;
DWORD dwLength;
TCHAR faulthDllPath[MAX_PATH];
TCHAR additionalFiles[DW_MAX_ADDFILES];
TCHAR title[DW_MAX_ERROR_CWC];
TCHAR errortext[DW_MAX_ERROR_CWC];
TCHAR lcid[10];
LCID dwlcid;
if( fGotHere) {
goto c0;
}
fGotHere = TRUE;
// No way to upload then quit
if( !IsNetConnectivityAvailable()) {
DebugLog (Winnt32LogWarning, TEXT("Warning: Faulthandler did not find netconnectivity."), 0);
goto c0;
}
if( !FindPathToWinnt32File( TEXT(SETUP_FAULTH_APPNAME),faulthDllPath,ARRAYSIZE(faulthDllPath))) {
DebugLog (Winnt32LogWarning, TEXT("Warning: Could not find faulthandler %1"), 0, TEXT(SETUP_FAULTH_APPNAME));
goto c0;
}
additionalFiles[0] = TEXT('0');
//The buffer size should be able to hold both files. Be careful when adding more!
MYASSERT( 2*MAX_PATH < ARRAYSIZE(additionalFiles));
if (MyGetWindowsDirectory (additionalFiles, ARRAYSIZE(additionalFiles))) {
ConcatenatePaths (additionalFiles, S_WINNT32LOGFILE, ARRAYSIZE(additionalFiles));
}
dwLength = lstrlen( additionalFiles);
// Check for case where we could not get winnt32.log
if( dwLength > 0) {
dwLength++; //Reserve space for pipe
}
if (MyGetWindowsDirectory (additionalFiles+dwLength, ARRAYSIZE(additionalFiles)-dwLength)) {
ConcatenatePaths (additionalFiles+dwLength, S_DEFAULT_NT_COMPAT_FILENAME, ARRAYSIZE(additionalFiles)-dwLength);
// If we at least got the first file then add the separator.
if( dwLength) {
additionalFiles[dwLength-1] = TEXT('|');
}
}
hmodFaultRep = LoadLibrary(faulthDllPath);
if (hmodFaultRep == NULL) {
DebugLog (Winnt32LogError, TEXT("Error: Could not load faulthandler %1."), 0, TEXT(SETUP_FAULTH_APPNAME));
goto c0;
}
pfnCreate = (PFAULTHCreate)GetProcAddress(hmodFaultRep, FAULTH_CREATE_NAME);
pfnDelete = (PFAULTHDelete)GetProcAddress(hmodFaultRep, FAULTH_DELETE_NAME);
if (pfnCreate == NULL || pfnDelete == NULL) {
DebugLog (Winnt32LogError, TEXT("Error: Could not get faulthandler exports."), 0);
goto c0;
}
pSetupFH = (*pfnCreate)();
if( pSetupFH == NULL) {
DebugLog (Winnt32LogError, TEXT("Error: Could not get faulthandler object."), 0);
goto c0;
}
if( pSetupFH->IsSupported(pSetupFH) == FALSE) {
DebugLog (Winnt32LogError, TEXT("Error: Dr Watson not supported."), 0);
goto c0;
}
title[0] = TEXT('\0');
lcid[0] = TEXT('\0');
errortext[0] = TEXT('\0');
LoadString(hInst, IDS_APPTITLE, title, sizeof(title)/sizeof(title[0]));
LoadString(hInst, IDS_DRWATSON_ERRORTEXT, errortext, sizeof(errortext)/sizeof(errortext[0]));
LoadString(hInst, IDS_DRWATSON_LCID, lcid, sizeof(lcid)/sizeof(lcid[0]));
if( !StringToInt( lcid, &dwlcid)) {
dwlcid = 1033;
}
pSetupFH->SetLCID(pSetupFH, dwlcid);
pSetupFH->SetURLA(pSetupFH, SETUP_URL);
#ifdef UNICODE
pSetupFH->SetAdditionalFilesW(pSetupFH, additionalFiles);
pSetupFH->SetAppNameW(pSetupFH, title);
pSetupFH->SetErrorTextW(pSetupFH, errortext);
#else
pSetupFH->SetAdditionalFilesA(pSetupFH, additionalFiles);
pSetupFH->SetAppNameA(pSetupFH, title);
pSetupFH->SetErrorTextA(pSetupFH, errortext);
#endif
CloseDebugLog(); //Close log file or else it cannot be uploaded.
dwRetRep = pSetupFH->Report(pSetupFH, pep, 0);
(*pfnDelete)(pSetupFH);
// Pass the error to the default unhandled exception handler
// which will terminate the process.
dwRetRep = EXCEPTION_EXECUTE_HANDLER;
c0:
if (hmodFaultRep != NULL) {
FreeLibrary(hmodFaultRep);
}
SetUnhandledExceptionFilter( pLastExceptionFilter);
return dwRetRep;
}
#ifdef TEST_EXCEPTION
struct {
DWORD dwException;
DWORD dwSetupArea;
} exceptionInfo;
void DoException( DWORD dwSetupArea)
{
TCHAR _testBuffer[10];
TCHAR *_ptestCh = 0;
if( exceptionInfo.dwSetupArea == dwSetupArea) {
switch( exceptionInfo.dwException) {
case 1:
*_ptestCh = TEXT('1');
MessageBox(NULL,TEXT("Exception not hit!"),TEXT("Access violation"),MB_OK);
break;
case 2:
{
DWORD i;
for( i =0; i < 0xffffffff;i++) {
_testBuffer[i] = TEXT('1');
}
}
MessageBox(NULL,TEXT("Exception not hit!"),TEXT("Buffer Overflow"),MB_OK);
break;
case 3:
{
LPVOID pv;
DWORD i;
for (i = 0; i < 0xffffffff; i++) {
pv = MALLOC(2048);
}
}
MessageBox(NULL,TEXT("Exception not hit!"),TEXT("Stack Overflow"),MB_OK);
break;
case 4:
{
typedef DWORD (*FAULT_FN)(void);
FAULT_FN pfn;
BYTE rgc[2048];
FillMemory(rgc, sizeof(rgc), 0);
pfn = (FAULT_FN)(DWORD_PTR)rgc;
(*pfn)();
}
MessageBox(NULL,TEXT("Exception not hit!"),TEXT("Invalid Instruction"),MB_OK);
break;
case 5:
for(;dwSetupArea;dwSetupArea--) ;
exceptionInfo.dwSetupArea = 4/dwSetupArea;
MessageBox(NULL,TEXT("Exception not hit!"),TEXT("Divide by zero"),MB_OK);
break;
default:
break;
}
}
}
void GetTestException( void)
{
TCHAR exceptionType[32];
TCHAR exceptionSetupArea[32];
exceptionType[0] = TEXT('\0');
exceptionSetupArea[0] = TEXT('\0');
exceptionInfo.dwException = 0;
exceptionInfo.dwSetupArea = 0;
GetPrivateProfileString( TEXT("Exception"),
TEXT("ExceptionType"),
TEXT("none"),
exceptionType,
sizeof(exceptionType)/sizeof(exceptionType[0]),
TEXT("c:\\except.inf"));
GetPrivateProfileString( TEXT("Exception"),
TEXT("ExceptionSetupArea"),
TEXT("none"),
exceptionSetupArea,
sizeof(exceptionSetupArea)/sizeof(exceptionSetupArea[0]),
TEXT("c:\\except.inf"));
StringToInt( exceptionType, &exceptionInfo.dwException);
StringToInt( exceptionSetupArea, &exceptionInfo.dwSetupArea);
}
#endif
HRESULT WriteEncryptedPIDtoUnattend(LPTSTR szPID)
{
HRESULT hr = E_FAIL;
LPTSTR szLine = NULL;
HANDLE hFile;
szLine = GlobalAlloc(GPTR, (lstrlen(szPID) + 3)*sizeof(TCHAR)); // + 3 for 2 " and \0
if (szLine)
{
wsprintf(szLine, TEXT("\"%s\""), szPID);
if (WritePrivateProfileString(WINNT_USERDATA, WINNT_US_PRODUCTKEY, szLine, UnattendedScriptFile) &&
WritePrivateProfileString(WINNT_USERDATA, WINNT_US_PRODUCTID, NULL, UnattendedScriptFile))
{
hr = S_OK;
}
else
{
// Error message, Unable to write
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_WRITE_FAILURE_UNATTEND,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
GlobalFree(szLine);
if (hr == S_OK)
{
hFile = CreateFile(UnattendedScriptFile,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
SYSTEMTIME st;
FILETIME ft;
ZeroMemory(&st, sizeof(st));
st.wDay = 1;
st.wMonth = 4;
st.wYear = 2002;
SystemTimeToFileTime(&st, &ft); // converts to file time format
LocalFileTimeToFileTime(&ft, &ft); // Make sure we get this as UTC
SetFileTime(hFile, &ft, &ft, &ft); // Set it.
CloseHandle(hFile);
}
}
}
return hr;
}
DWORD
winnt32 (
IN PCSTR LocalSourcePath, OPTIONAL
IN HWND Dlg, OPTIONAL
IN HANDLE WinNT32Stub, OPTIONAL
OUT PCSTR* RestartCmdLine OPTIONAL
)
/*++
Routine Description:
winnt32 is the main setup routine.
Arguments:
LocalSourcePath - Specifies the local path of installation in case
this DLL is running from a local directory
after download; always ANSI if not NULL
Dlg - Specifies the handle of the welcome dialog displayed by
the stub; it will stay on screen untill the wizard dialog
appears; may be NULL
WinNT32Stub - Specifies the handle of an event that will be
signaled before the Wizard appears on the screen;
may be NULL
RestartCmdLine - Receives a pointer to a command line to be executed
by the caller after this function returns;
always ANSI
Return Value:
none
--*/
{
HMODULE SMSHandle = NULL;
SMSPROC InstallStatusMIF = NULL;
HANDLE Mutex;
BOOL b;
TCHAR Text[MAX_PATH];
PCTSTR Footer;
DWORD i;
BOOL rc = ERROR_SUCCESS;
BOOL bScreenSaverOn = FALSE;
PCTSTR skuPersonal;
#if !defined(UNICODE)
ULARGE_INTEGER RemainFreeSpace;
#endif
#ifdef UNICODE
PTSTR privName[COUNT_OF_PRIVILEGES];
DWORD privSize[COUNT_OF_PRIVILEGES];
DWORD langId[COUNT_OF_PRIVILEGES];
#endif
#ifdef TEST_EXCEPTION
GetTestException();
DoException( 1);
#endif
// Initialize these variables because the exceptionfilter calls FindPathToWinnt32File
#ifndef UNICODE
//
// if running on Win9x, there may be a LocalSourcePath passed as parameter
// use that
//
g_LocalSourcePath = LocalSourcePath;
#endif
AlternateSourcePath[0] = 0;
g_DynUpdtStatus = NULL;
SourceCount = 0;
pLastExceptionFilter = SetUnhandledExceptionFilter(MyFilter);
#ifdef TEST_EXCEPTION
DoException( 2);
#endif
SetErrorMode(SEM_FAILCRITICALERRORS);
InitCommonControls();
#if !defined(UNICODE)
//
// Check virtual memory requirements (only for regular Win9x winnt32 execution)
//
if(!IsWinPEMode()){
RemainFreeSpace.QuadPart = 0;
if(!pIsEnoughVMAndDiskSpace(&RemainFreeSpace, FALSE)){
if(!RemainFreeSpace.QuadPart){
MessageBoxFromMessage(
NULL,
MSG_OUT_OF_MEMORY,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
}
else{
MessageBoxFromMessage(
NULL,
MSG_COPY_ERROR_DISKFULL,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
}
rc = -1;
goto EXITNOW;
}
}
#endif
if(GetModuleHandle(ShimEngine_ModuleName)){
MessageBoxFromMessage(
NULL,
MSG_RUNNING_UNDER_COMPATIBILITY,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
rc = -1;
goto EXITNOW;
}
//
// Init Dynamic update status
//
g_DynUpdtStatus = MALLOC (sizeof (*g_DynUpdtStatus));
if (!g_DynUpdtStatus) {
rc = -1;
goto EXITNOW;
}
//
// start with all defaults
//
ZeroMemory (g_DynUpdtStatus, sizeof (*g_DynUpdtStatus));
g_DynUpdtStatus->Connection = INVALID_HANDLE_VALUE;
#if defined(REMOTE_BOOT)
g_DynUpdtStatus->Disabled = TRUE;
#endif
//
// If we are running WINNT32 under WINPE we disable Dynamic Update as WINPE
// is primarily for OEM's and Dynamic Update feature is not meant for OEM's
//
if (IsWinPEMode()){
g_DynUpdtStatus->Disabled = TRUE;
}
// Save the screen saver state
SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &bScreenSaverOn ,0);
// Disable the screen saver
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL ,0);
//
// Gather os version info, before we parse arguments
// since we use ISNT() function
//
OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&OsVersion);
BuildNumber = OsVersion.dwBuildNumber;
OsVersionNumber = OsVersion.dwMajorVersion*100 + OsVersion.dwMinorVersion;
//
// Parse/check arguments first.
//
if (!ParseArguments()) {
rc = 1;
goto c0;
}
// if we are running to encrypt the PID into an unattend file, don't log the command line.
if (!PIDEncryption)
{
DebugLog (Winnt32LogInformation, TEXT("The command line is: <%1>"), 0, GetCommandLine ());
}
//
// also log the location of the upgrade module
//
if (MyGetModuleFileName (hInst, Text, ARRAYSIZE(Text))) {
DebugLog (Winnt32LogInformation, TEXT("Main module path: <%1>"), 0, Text);
}
if (CheckUpgradeOnly)
{
AppTitleStringId = IDS_APPTITLE_CHECKUPGRADE;
}
//
// If we didn't get any source paths on the command line,
// make one up here. The path will be the path where we were run from.
//
if(!SourceCount) {
PTSTR p;
if (!MyGetModuleFileName (NULL, NativeSourcePaths[0],ARRAYSIZE(NativeSourcePaths[0])) ||
!(p = _tcsrchr (NativeSourcePaths[0], TEXT('\\')))) {
rc = 1;
MessageBoxFromMessage(
NULL,
GetLastError(),
TRUE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
goto c1;
}
//
// check if running from a private build
//
*p = 0;
if ((p = _tcsrchr (NativeSourcePaths[0], TEXT('\\'))) != NULL &&
lstrcmpi (p + 1, INTERNAL_WINNT32_DIR) == 0
) {
*p = 0;
}
SourceCount = 1;
}
//
// setup the SourcePaths array from the legacy source paths array
//
for (i = 0; i < MAX_SOURCE_COUNT; i++) {
if (NativeSourcePaths[i]) {
LPTSTR p;
MYASSERT (ARRAYSIZE(SourcePaths[i]) == ARRAYSIZE(NativeSourcePaths[i]));
lstrcpy(SourcePaths[i], NativeSourcePaths[i]);
p = _tcsrchr (SourcePaths[i], TEXT('\\'));
if (p) {
*++p = TEXT('\0');
}
}
}
//
// Validate the source location
//
if (!ValidateSourceLocation()) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_INVALID_SOURCEPATH,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
NULL );
goto c0;
}
//
//At this point we have the NativeSourcePaths setup and it si safe for operations involving it to be called
//
if (PIDEncryption)
{
rc = 1;
if (UnattendedScriptFile)
{
BOOL bDontCare, bSelect;
GetSourceInstallType(0);
if (ValidatePidEx(ProductId, &bDontCare, &bSelect) && bSelect)
{
LPTSTR szEncryptedPID = NULL;
HRESULT hr = PrepareEncryptedPID(ProductId, PIDDays, &szEncryptedPID);
if (hr != S_OK)
{
DebugLog (Winnt32LogInformation, TEXT("PrepareEncryptedPID failed: <hr=0x%1!lX!>"), 0, hr);
// Error Excryption failed
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_ENCRYPT_FAILURE,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
else
{
if (WriteEncryptedPIDtoUnattend(szEncryptedPID) == S_OK)
{
DebugLog (Winnt32LogInformation, TEXT("Encrypted PID succeeded"), 0);
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_ENCRYPT_SUCCESS,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
if (szEncryptedPID)
{
GlobalFree(szEncryptedPID);
}
rc = 0;
}
}
else
{
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_INVALID_PID,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
}
else
{
// No unattend switch specified
if (!g_Quiet)
{
MessageBoxFromMessage(
NULL,
MSG_ENCRYPT_NOUNATTEND,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
}
}
goto c0;
}
if( RunningBVTs ){
CopyExtraBVTDirs();
}
if (!DynamicUpdateInitialize ()) {
DebugLog (
Winnt32LogError,
TEXT("DynamicUpdateInitialize failed: no dynamic update processing will be done"),
0
);
g_DynUpdtStatus->Disabled = TRUE;
}
if (!GetProductType()) {
MessageBoxFromMessage(
NULL,
MSG_INVALID_INF_FILE,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL,
FullInfName[0] ? FullInfName : InfName
);
rc = 1;
goto c0;
}
if (!g_DynUpdtStatus->Disabled) {
if (Winnt32Restarted ()) {
DebugLog (Winnt32LogWarning, TEXT("\r\n*** Winnt32 restarted ***\r\n"), 0);
if (g_DynUpdtStatus->RestartAnswerFile[0]) {
#ifdef PRERELEASE
TCHAR buf[MAX_PATH];
if (MyGetWindowsDirectory (buf, ARRAYSIZE(buf))) {
if (ConcatenatePaths (buf, S_RESTART_TXT, ARRAYSIZE(buf)) &&
CopyFile (g_DynUpdtStatus->RestartAnswerFile, buf, FALSE)) {
DebugLog (DynUpdtLogLevel, TEXT("Winnt32 restart file backed up to %1"), 0, buf);
}
}
#endif
} else {
DebugLog (DynUpdtLogLevel, TEXT("No restart file is used"), 0);
}
}
}
//
// Init support for SMS.
//
try {
if( SMSHandle = LoadLibrary( TEXT("ISMIF32")) ) {
InstallStatusMIF = (SMSPROC)GetProcAddress(SMSHandle,"InstallStatusMIF");
}
if(LastMessage = MALLOC(1))
LastMessage[0] = '\0';
} except(EXCEPTION_EXECUTE_HANDLER) {
}
Winnt32Dlg = Dlg;
WinNT32StubEvent = WinNT32Stub;
// If the user specified /cmdcons (install the recovery consol) , don't show the
// billboards.
if (!BuildCmdcons && !CheckUpgradeOnly)
{
CreateMainWindow();
PrepareBillBoard(BackgroundWnd2);
if (hinstBB)
{
if (!LoadString (
hInst,
IDS_ESC_TOCANCEL,
Text,
ARRAYSIZE(Text)
)) {
Text[0] = 0;
}
BB_SetInfoText(Text);
UpdateWindow (BackgroundWnd2);
}
else
{
// If we could not load the billboard dll, destroy the backbround window
// This window is currently only here to catch pressing ESC and forward
// this to the wizard dialog proc. If the wizard is always visible, this
// is not needed.
DestroyWindow(BackgroundWnd2);
BackgroundWnd2 = NULL;
}
}
if (!LoadString (hInst, IDS_TIMEESTIMATE_UNKNOWN, Text, ARRAYSIZE(Text)))
{
Text[0] = 0;
}
// BB_SetTimeEstimateText does nothing if the billboard dll is not loaded.
BB_SetTimeEstimateText((PTSTR)Text);
//
// Only let one of this guy run.
// account for TS case (make the mutex global)
//
#ifdef UNICODE
_snwprintf (Text, ARRAYSIZE(Text), TEXT("Global\\%s"), TEXT("Winnt32 Is Running"));
Text[ARRAYSIZE(Text) - 1] = 0;
Mutex = CreateMutex(NULL,FALSE,Text);
// NT4 without TS does not support the "Global\Mutex name", make sure that
// if we could not create the Mutext that the error code is ERROR_PATH_NOT_FOUND
// If that is the case fall back and use the name with out the Global prefix.
if ((Mutex == NULL) && (GetLastError() == ERROR_PATH_NOT_FOUND)) {
#else
Mutex = NULL;
if(Mutex == NULL) {
#endif
Mutex = CreateMutex(NULL,FALSE,TEXT("Winnt32 Is Running"));
if(Mutex == NULL) {
rc = 1;
//
// An error (like out of memory) has occurred.
// Bail now.
//
MessageBoxFromMessage(
NULL,
MSG_OUT_OF_MEMORY,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
goto c0;
}
}
//
// Make sure we are the only process with a handle to our named mutex.
//
if ((Mutex == NULL) || (GetLastError() == ERROR_ALREADY_EXISTS)) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_ALREADY_RUNNING,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
//
// Ensure that the user has privilege/access to run this app.
//
if(!IsUserAdmin()) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_NOT_ADMIN,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONSTOP | MB_TASKMODAL
);
goto c1;
}
#ifdef UNICODE
rc = 0;
for (i = 0; i < COUNT_OF_PRIVILEGES; i++) {
if (!DoesUserHavePrivilege(g_RequiredPrivileges[i])) {
rc = 1;
break;
}
}
if (rc) {
for (i = 0; i < COUNT_OF_PRIVILEGES; i++) {
privSize[i] = 0;
LookupPrivilegeDisplayName (NULL, g_RequiredPrivileges[i], NULL, &privSize[i], &langId[i]);
privName[i] = MALLOC ((privSize[i] + 1) * sizeof (TCHAR));
if (privName[i]) {
privName[i][0] = privName[i][privSize[i]] = 0;
LookupPrivilegeDisplayName (NULL, g_RequiredPrivileges[i], privName[i], &privSize[i], &langId[i]);
}
}
MYASSERT (COUNT_OF_PRIVILEGES >= 4);
MessageBoxFromMessage(
NULL,
MSG_PRIVILEGE_NOT_HELD,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONSTOP | MB_TASKMODAL,
privName[0],
privName[1],
privName[2],
privName[3]
);
goto c1;
}
#endif
#if 0
//
// Don't run if we're a TS client.
//
if( (ISNT()) &&
(BuildNumber >= NT40) ) {
//
// From winuser.h
//
#define SM_REMOTESESSION 0x1000
if( GetSystemMetrics(SM_REMOTESESSION) == TRUE ) {
rc = 1;
//
// Someone is trying to run us inside of a TerminalServer client!!
// Bail.
//
MessageBoxFromMessage(
NULL,
MSG_TS_CLIENT_FAIL,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONSTOP | MB_TASKMODAL
);
goto c1;
}
}
#endif
//
// inititialize com
//
CoInitialize(NULL);
#if defined(REMOTE_BOOT)
//
// Determine whether this is a remote boot client.
//
RemoteBoot = FALSE;
*MachineDirectory = 0;
if (ISNT()) {
HMODULE hModuleKernel32 = LoadLibrary(TEXT("kernel32"));
if (hModuleKernel32) {
BOOL (*getSystemInfoEx)(
IN SYSTEMINFOCLASS dwSystemInfoClass,
OUT LPVOID lpSystemInfoBuffer,
IN OUT LPDWORD nSize);
(FARPROC)getSystemInfoEx = GetProcAddress(
hModuleKernel32,
#if defined(UNICODE)
"GetSystemInfoExW"
#else
"GetSystemInfoExA"
#endif
);
if (getSystemInfoEx != NULL) {
BOOL flag;
DWORD size = sizeof(BOOL);
if (getSystemInfoEx(SystemInfoRemoteBoot, &flag, &size)) {
RemoteBoot = flag;
size = sizeof(MachineDirectory);
if (!getSystemInfoEx(
SystemInfoRemoteBootServerPath,
MachineDirectory,
&size)) {
DWORD error = GetLastError();
MYASSERT( !"GetSystemInfoExW failed!" );
} else {
PTCHAR p;
p = _tcsrchr(MachineDirectory, TEXT('\\'));
MYASSERT(p != NULL);
if (p) {
*p = 0;
}
}
}
}
FreeLibrary(hModuleKernel32);
}
}
#endif // defined(REMOTE_BOOT)
#ifdef _X86_
if (IsNEC98 ()) {
//
// don't install on NEC98 machines (#141004)
//
MessageBoxFromMessage(
NULL,
MSG_PLATFORM_NOT_SUPPORTED,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONSTOP | MB_TASKMODAL
);
rc = 1;
goto c1;
}
//
// Check setup sources and platform.
// NEC98 NT5 have 98PNTN16.DLL.
// I use this file for check platform NEC98 or x86.
//
{
#define WINNT_NEC98SPECIFIC_MODULE TEXT("98PTN16.DLL")
TCHAR MyPath[MAX_PATH];
int CheckNEC98Sources=FALSE;
WIN32_FIND_DATA fdata;
PTSTR p;
HANDLE h;
if( !MyGetModuleFileName (NULL, MyPath, ARRAYSIZE(MyPath)) || !(p=_tcsrchr (MyPath, TEXT('\\')))) {
rc = 1;
goto c1;
}
p = 0;
if (ConcatenatePaths (MyPath, WINNT_NEC98SPECIFIC_MODULE, ARRAYSIZE(MyPath)) &&
(h = FindFirstFile(MyPath, &fdata)) != INVALID_HANDLE_VALUE) {
CloseHandle (h);
CheckNEC98Sources=TRUE;
}
if(CheckNEC98Sources){
if (!IsNEC98()){
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_INCORRECT_PLATFORM,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
} else {
if (IsNEC98()){
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_INCORRECT_PLATFORM,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
}
}
//
// Some NEC98 Windows NT4 system is installed DMITOOL
// This AP block the CreateFile API
// Setup need to check this AP
//
if (IsNEC98() && ISNT()){
if (NEC98CheckDMI() == TRUE){
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_NEC98_NEED_UNINSTALL_DMITOOL,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
}
LocateFirstFloppyDrive();
//
// Fix up boot messages.
// NEC98 FAT16/FAT32 boot code does't have message area.
//
if (!IsNEC98())
{
if(!PatchTextIntoBootCode()) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_BOOT_TEXT_TOO_LONG,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
goto c1;
}
}
//
// Disallow installing/upgrading on a 386 or 486
// 3.51 and Win9x ran on 386's so this check is still necessary.
//
{
SYSTEM_INFO SysInfo;
PCTSTR DestinationPlatform;
GetSystemInfo(&SysInfo);
if (SysInfo.dwProcessorType == PROCESSOR_INTEL_386 ||
SysInfo.dwProcessorType == PROCESSOR_INTEL_486) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_REQUIRES_586,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
#ifdef UNICODE
#ifdef _X86_
//
// 32-bit to 64-bit AMD should only be clean install.
//
DestinationPlatform = InfGetFieldByKey(MainInf, TEXT("Miscellaneous"), TEXT("DestinationPlatform"),0);
if (lstrcmpi (DestinationPlatform, TEXT("amd64")) == 0)
{
Upgrade = FALSE;
}
else
#endif
//
// Disallow amd64 and IA64 machines from running an x86
// version of winnt32.exe.
//
{
ULONG_PTR p;
NTSTATUS status;
status = NtQueryInformationProcess (
NtCurrentProcess (),
ProcessWow64Information,
&p,
sizeof (p),
NULL
);
if (NT_SUCCESS (status) && p) {
HMODULE hModuleKernel32 = LoadLibrary(TEXT("kernel32"));
//
// 64-bit to 32-bit clean install is allowed on AMD64
//
RtlZeroMemory (&SysInfo, sizeof (SysInfo));
if (hModuleKernel32 != NULL) {
typedef VOID (WINAPI *PFNGetNativeSystemInfo)(PSYSTEM_INFO);
PFNGetNativeSystemInfo pfnGetNativeSystemInfo;
pfnGetNativeSystemInfo = (PFNGetNativeSystemInfo)GetProcAddress (hModuleKernel32, "GetNativeSystemInfo");
if (pfnGetNativeSystemInfo != NULL) {
pfnGetNativeSystemInfo (&SysInfo);
}
FreeLibrary(hModuleKernel32);
}
if (SysInfo.dwProcessorType == PROCESSOR_AMD_X8664) {
Upgrade = FALSE;
} else {
rc = 1;
//
// 32-bit code running on Win64
//
MessageBoxFromMessage(
NULL,
MSG_NO_CROSS_PLATFORM,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
}
}
#endif
}
#endif // _X86_
if (!g_DynUpdtStatus->Disabled) {
if (g_DynUpdtStatus->PrepareWinnt32) {
if (!g_DynUpdtStatus->DynamicUpdatesSource[0]) {
//
// no share to update was specified
//
MessageBoxFromMessage(
NULL,
MSG_NO_UPDATE_SHARE,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONSTOP | MB_TASKMODAL
);
rc = 1;
goto c1;
}
} else {
//
// spec change: even if /unattend is specified, still do DU
//
#if 0
if (UnattendedOperation && !g_DynUpdtStatus->UserSpecifiedUpdates) {
//
// if unattended, disable Dynamic Setup page by default
//
g_DynUpdtStatus->Disabled = TRUE;
}
#endif
}
}
//
// Load extension/downlevel DLLs.
//
// Don't load upgrade support if we're running in WinPE.
//
if (!IsWinPEMode()) {
LoadUpgradeSupport();
}
else {
ZeroMemory(&UpgradeSupport, sizeof(UpgradeSupport));
Upgrade = FALSE;
}
//
// Load setupapi. Do this *AFTER* we load upgrade support,
// because one of the upgrade support dlls might link to or load
// setupapi.dll. That dll might be picky but we can use any old
// setupapi.dll for what we need.
//
if (!LoadSetupapi()) {
rc = 1;
goto c1;
}
#ifdef _X86_
//
// If this is a win9x machine, check to ensure that there are no
// virus scanners that could block a successful upgrade _or_
// clean install.
//
if (!ISNT() && !SkipVirusScannerCheck && !CheckVirusScanners()) {
rc = 1;
goto c1;
}
#endif
if(!IsArc()) {
#if defined(_AMD64_) || defined(_X86_)
if(!InitializeArcStuff(NULL)) {
rc = 1;
goto c1;
}
#endif // defined(_AMD64_) || defined(_X86_)
} else {
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
if(!ArcInitializeArcStuff(NULL)) {
rc = 1;
goto c1;
}
#endif // UNICODE
} // if (!IsArc())
//
// Don't allow upgrades from early NT 5 builds.
//
if( !CheckBuildNumber() ) {
MessageBoxFromMessage(
NULL,
MSG_CANT_UPGRADE_FROM_BUILD_NUMBER,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONSTOP | MB_TASKMODAL
);
Upgrade = FALSE;
}
#if defined(REMOTE_BOOT)
//
// If this is a remote boot client, it MUST upgrade. It cannot install a new
// version of the OS. If upgrade has been disabled for some reason, stop now.
//
if (RemoteBoot && !Upgrade) {
rc = 1;
MessageBoxFromMessage(
NULL,
MSG_REQUIRES_UPGRADE,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONINFORMATION | MB_TASKMODAL
);
goto c1;
}
#endif // defined(REMOTE_BOOT)
//if(UnattendedOperation && UnattendedScriptFile && !FetchArguments()) {
// rc = 1;
// goto c1;
//}
//
// Set up various other option defaults.
//
InitVariousOptions();
if (!g_DynUpdtStatus->PrepareWinnt32) {
//
// Make sure the Source files and target operating system
// are of the same locale. If they aren't, we'll disable
// ability to upgrade.
//
// Init the locale engine.
//
//
if( InitLanguageDetection( NativeSourcePaths[0], TEXT("intl.inf") ) ) {
if( !SkipLocaleCheck && (Upgrade || UpgradeFailureReason) && !IsLanguageMatched) {
//
// Tell the user we can't upgrade then kill his ability to do so.
//
MessageBoxFromMessage( NULL,
MSG_UPGRADE_LANG_ERROR,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
NULL );
Upgrade = FALSE;
}
}
//
// Now that we have done the language check, go ahead and see if we have a message
// to give to the user about why they cannot upgrade.
//
if (IsLanguageMatched && UpgradeFailureReason && UpgradeFailureMessages[UpgradeFailureReason]) {
//
// Tell the user we can't upgrade then kill his ability to do so.
//
MessageBoxFromMessage( NULL,
UpgradeFailureMessages[UpgradeFailureReason],
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
NULL );
Upgrade = FALSE;
}
//
// Check to see if we're on a cluster. If so, and the user
// didn't specify a tempdrive, then it's possible for us to
// select a shared disk, which may not be available for us
// when we come back up into textmode. Warn the user.
//
// Note that we need to wait until now because RunFromCD
// doesn't get set until InitVariousOptions().
//
if( ISNT() &&
(RunFromCD == FALSE) &&
(!UserSpecifiedLocalSourceDrive) ) {
int i;
HMODULE ClusApiHandle;
FARPROC MyProc;
HANDLE hCluster;
BOOL OnCluster = FALSE;
try {
if( ClusApiHandle = LoadLibrary( TEXT("clusapi") ) ) {
if( MyProc = GetProcAddress(ClusApiHandle,"OpenCluster")) {
hCluster = (HANDLE)MyProc(NULL);
if( hCluster != NULL ) {
//
// Fire.
//
OnCluster = TRUE;
if( MyProc = GetProcAddress( ClusApiHandle, "CloseCluster")) {
MyProc( hCluster );
}
}
}
FreeLibrary( ClusApiHandle );
}
} except(EXCEPTION_EXECUTE_HANDLER) {
}
if( OnCluster ) {
i = MessageBoxFromMessage( NULL,
MSG_CLUSTER_WARNING,
FALSE,
IDS_APPTITLE,
MB_OKCANCEL | MB_ICONEXCLAMATION,
NULL );
if(i == IDCANCEL) {
rc = 1;
goto c1;
}
}
}
}
//
// setup source install type(retail,oem,or select)
//
GetSourceInstallType(0);
if (FAILED (StringCchCopy (InstallDir, ARRAYSIZE(InstallDir), DEFAULT_INSTALL_DIR ))) {
MYASSERT (FALSE);
}
//
// Create a mutex to serialize error ui.
//
UiMutex = CreateMutex(NULL,FALSE,NULL);
if(!UiMutex) {
rc = 1;
MessageBoxFromMessage(
NULL,
GetLastError(),
TRUE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL
);
goto c1;
}
//
// Attempt to disable the PM engine from powering down
// the machine while the wizard is going. The API we're
// going to call doesn't exist on all versions of Windows,
// so manually try and load the entry point. If we fail,
// so be it.
//
{
typedef EXECUTION_STATE (WINAPI *PTHREADPROC) (IN EXECUTION_STATE esFlags);
HMODULE Kernel32Handle;
PTHREADPROC MyProc;
if( Kernel32Handle = LoadLibrary( TEXT("kernel32") ) ) {
if( MyProc = (PTHREADPROC)GetProcAddress(Kernel32Handle,"SetThreadExecutionState")) {
MyProc( ES_SYSTEM_REQUIRED |
ES_DISPLAY_REQUIRED |
ES_CONTINUOUS );
}
FreeLibrary( Kernel32Handle );
}
}
//
// Go off and do it.
//
if (Winnt32Dlg) {
DestroyWindow (Winnt32Dlg);
Winnt32Dlg = NULL;
}
if (WinNT32StubEvent) {
SetEvent (WinNT32StubEvent);
WinNT32StubEvent = NULL;
}
if( BuildCmdcons ) {
// if we were told to build a cmdcons boot we do this instead
if (!IsArc()) {
#if defined(_AMD64_) || defined(_X86_)
if (ISNT()) {
CalcThroughput();
DoBuildCmdcons();
} else {
//
// We don't support building a cmdcons from Win9x.
//
MessageBoxFromMessage( NULL,
MSG_CMDCONS_WIN9X,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONEXCLAMATION,
NULL );
GlobalResult = FALSE;
}
#endif
} else {
#ifdef UNICODE
//
// We don't support building a cmdcons on Alpha platforms.
//
MessageBoxFromMessage( NULL,
MSG_CMDCONS_RISC,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONEXCLAMATION,
NULL );
GlobalResult = FALSE;
#endif
}
} else if (g_DynUpdtStatus->PrepareWinnt32) {
if (!DynamicUpdateProcessFiles (&b)) {
MessageBoxFromMessage (
NULL,
MSG_PREPARE_SHARE_FAILED,
FALSE,
IDS_APPTITLE,
MB_OK | MB_ICONEXCLAMATION,
NULL
);
rc = 1;
}
//
// clean up stuff
//
if (g_DynUpdtStatus->WorkingDir[0]) {
MyDelnode (g_DynUpdtStatus->WorkingDir);
}
} else {
if (g_DynUpdtStatus->Disabled) {
DebugLog (Winnt32LogInformation, NULL, LOG_DYNUPDT_DISABLED);
}
CalcThroughput();
Wizard();
}
//
// Back from the wizard. Either clean up or shut down, as appropriate.
//
if(GlobalResult) {
#ifdef _X86_
MYASSERT (SystemPartitionDriveLetter);
MarkPartitionActive(SystemPartitionDriveLetter);
if(IsNEC98()){
// If System is NT and NEC98 Driver assign.
// We need delete registry key "DriveLetter=C" in setupreg.hive
if (ISNT() && (IsDriveAssignNEC98() == TRUE)){
DeleteNEC98DriveAssignFlag();
}
//
// If floppyless setup, set AUTO-BOOT flag in boot sector on NEC98
//
if((Floppyless || UnattendedOperation)) {
SetAutomaticBootselector();
}
}
#endif
//
// Uninstall: blow away existing backup of OS, if we are upgrading to
// a newer build.
//
pRemoveOutdatedBackupImage();
//
// SMS: report success
//
if(InstallStatusMIF) {
PSTR Buffer;
FormatMessageA(
FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER,
hInst,
MSG_SMS_SUCCEED,
0,
(PSTR)&Buffer,
0,
NULL
);
InstallStatusMIF(
"setupinf",
"Microsoft",
"Windows NT",
"5.0",
"",
"",
Buffer,
TRUE
);
LocalFree( Buffer );
}
//
// Close the log if it was open
//
if (fnSetupCloseLog) {
Footer = GetStringResource (MSG_LOG_END);
if (Footer) {
fnSetupOpenLog (FALSE);
fnSetupLogError (Footer, LogSevInformation);
FreeStringResource (Footer);
fnSetupCloseLog();
}
}
//
// Success. Attempt to shut down the system. On NT we have
// a cool API that does this with a countdown. On Win95 we don't.
// On NT5 and beyond, we have an even cooler API that takes
// a reason for shutting down. Don't statically link to it
// or else this will fall over when run from an NT4 machine.
//
if(AutomaticallyShutDown) {
#ifdef RUN_SYSPARSE
DWORD ret;
// Wait up to 90 seconds for sysparse to finish
if (!NoSysparse && piSysparse.hProcess) {
ret = WaitForSingleObject( piSysparse.hProcess, 0);
if( ret != WAIT_OBJECT_0) {
DialogBox(
hInst,
MAKEINTRESOURCE(IDD_SYSPARSE),
GetBBhwnd(),
SysParseDlgProc
);
}
CloseHandle(piSysparse.hProcess);
CloseHandle(piSysparse.hThread);
piSysparse.hProcess = NULL;
}
#endif
//
// On upgrades we disable System Restore. This saves us space in GUI mode by cleaning out its cache.
// We do this only at the point where we reboot. In the /noreboot case we decide to ignore this
// Not many people would run into that as it is a commandline option. The routine chaecks for presence of
// srclient.dll and only does this on the platforms it is present in.
//
DisableSystemRestore();
// reset the screen saver to what we found when we entered winnt32
// This is in the reboot case
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, bScreenSaverOn, NULL,0);
if(ISNT()) {
HINSTANCE hAdvapi = GetModuleHandle(TEXT("advapi32.dll"));
PFNINITIATESYSTEMSHUTDOWNEX pfnShutdownEx = NULL;
LPCSTR lpProcName;
if (UnattendedOperation || DisplayExitWindowsWarnings(EWX_REBOOT))
{
#ifdef UNICODE
lpProcName = "InitiateSystemShutdownExW";
#else
lpProcName = "InitiateSystemShutdownExA";
#endif
LoadString(hInst,IDS_REBOOT_MESSAGE,Text,ARRAYSIZE(Text));
if (hAdvapi) {
pfnShutdownEx = (PFNINITIATESYSTEMSHUTDOWNEX)
GetProcAddress(hAdvapi,
lpProcName);
}
//
// We checked up front whether we have the privilege,
// so getting it should be no problem. If we can't,
// then just let shutdown fail -- it will tell us why it failed.
//
EnablePrivilege(SE_SHUTDOWN_NAME,TRUE);
if (pfnShutdownEx) {
b = pfnShutdownEx(NULL,
Text,
UnattendedShutdownTimeout,
UnattendedShutdownTimeout != 0,
TRUE,
SHTDN_REASON_FLAG_PLANNED |
SHTDN_REASON_MAJOR_OPERATINGSYSTEM |
(Upgrade ? SHTDN_REASON_MINOR_UPGRADE : SHTDN_REASON_MINOR_INSTALLATION)
);
//
// on 5.1, force a shutdown even if the machine was locked
// to maintain W2K compatibility
// only do this if an unattended install was in progress
//
if (!b && (GetLastError () == ERROR_MACHINE_LOCKED) && UnattendSwitchSpecified) {
b = pfnShutdownEx (
NULL,
Text,
0,
TRUE,
TRUE,
SHTDN_REASON_FLAG_PLANNED |
SHTDN_REASON_MAJOR_OPERATINGSYSTEM |
(Upgrade ? SHTDN_REASON_MINOR_UPGRADE : SHTDN_REASON_MINOR_INSTALLATION)
);
}
}
else {
b = InitiateSystemShutdown(NULL,
Text,
UnattendedShutdownTimeout,
UnattendedShutdownTimeout != 0,
TRUE);
}
}
} else {
b = ExitWindowsEx(EWX_REBOOT,0);
if(!b) {
b = ExitWindowsEx(EWX_REBOOT | EWX_FORCE,0);
}
}
if(!b) {
rc = 1;
MessageBoxFromMessageAndSystemError(
NULL,
MSG_REBOOT_FAILED,
GetLastError(),
AppTitleStringId,
MB_OK | MB_ICONWARNING | MB_TASKMODAL
);
goto c2;
}
}
} else {
if (CheckUpgradeOnly) {
//
// perform some DU cleanup here since the cleanup routine
// doesn't get called in /checkupgradeonly mode
//
if (g_DynUpdtStatus->ForceRemoveWorkingDir || !g_DynUpdtStatus->PreserveWorkingDir) {
if (g_DynUpdtStatus->WorkingDir[0] && !g_DynUpdtStatus->RestartWinnt32) {
MyDelnode (g_DynUpdtStatus->WorkingDir);
}
GetCurrentWinnt32RegKey (Text, ARRAYSIZE(Text));
if (ConcatenatePaths (Text, WINNT_U_DYNAMICUPDATESHARE, ARRAYSIZE(Text))) {
RegDeleteKey (HKEY_LOCAL_MACHINE, Text);
}
}
} else {
if (!g_DynUpdtStatus->RestartWinnt32 && !g_DynUpdtStatus->PrepareWinnt32) {
rc = 1;
}
}
}
c2:
CloseHandle(UiMutex);
c1:
//
// Destroy the mutex.
//
CloseHandle(Mutex);
c0:
// reset the screen saver to what we found when we entered winnt32
// This is if we don't reboot. e.g.: user canceled
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, bScreenSaverOn, NULL,0);
//
// destroy the welcome dialog if still active
//
if (Dlg) {
DestroyWindow (Dlg);
Dlg = NULL;
}
//
// and release the original process if launched over a network
//
if (WinNT32Stub) {
SetEvent (WinNT32Stub);
WinNT32Stub = NULL;
}
if (g_EncryptedPID)
{
GlobalFree(g_EncryptedPID);
g_EncryptedPID = NULL;
}
//
// SMS: report failure
//
if(!GlobalResult && !g_DynUpdtStatus->RestartWinnt32 && InstallStatusMIF) {
PSTR Buffer = NULL;
FormatMessageA(
FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_ARGUMENT_ARRAY,
hInst,
MSG_SMS_FAIL,
0,
(PSTR)&Buffer,
0,
(va_list *)&LastMessage
);
InstallStatusMIF(
"setupinf",
"Microsoft",
"Windows NT",
"5.1",
"",
"",
Buffer,
FALSE
);
LocalFree (Buffer);
}
if(SMSHandle) {
FreeLibrary( SMSHandle );
}
//
// Now clean up our debug log if we're only checking
// the upgrade scenario.
//
if( CheckUpgradeOnly ) {
GatherOtherLogFiles();
}
//
// Close the debug log.
//
CloseDebugLog();
TerminateBillBoard();
if (BackgroundWnd2)
{
DestroyWindow (BackgroundWnd2);
BackgroundWnd2 = NULL;
}
if (hinstBB)
{
FreeLibrary(hinstBB);
hinstBB = NULL;
}
if (RestartCmdLine) {
#ifdef UNICODE
if (g_DynUpdtStatus->RestartCmdLine) {
INT i = 0;
INT size = (lstrlenW (g_DynUpdtStatus->RestartCmdLine) + 1) * sizeof (g_DynUpdtStatus->RestartCmdLine[0]);
PSTR ansi = HeapAlloc (GetProcessHeap (), 0, size);
if (ansi) {
i = WideCharToMultiByte(
CP_ACP,
0,
g_DynUpdtStatus->RestartCmdLine,
size / sizeof (g_DynUpdtStatus->RestartCmdLine[0]),
ansi,
size,
NULL,
NULL
);
}
HeapFree (GetProcessHeap (), 0, g_DynUpdtStatus->RestartCmdLine);
if (i == 0 && ansi) {
HeapFree (GetProcessHeap (), 0, ansi);
ansi = NULL;
}
*RestartCmdLine = ansi;
} else {
*RestartCmdLine = NULL;
}
#else
*RestartCmdLine = g_DynUpdtStatus->RestartCmdLine;
#endif
g_DynUpdtStatus->RestartCmdLine = NULL;
} else {
if (g_DynUpdtStatus->RestartCmdLine) {
HeapFree (GetProcessHeap (), 0, g_DynUpdtStatus->RestartCmdLine);
}
}
//
// unload the upgrade dll, if it was loaded
//
if (UpgradeSupport.DllModuleHandle) {
FreeLibrary(UpgradeSupport.DllModuleHandle);
}
if (g_DynUpdtStatus) {
FREE (g_DynUpdtStatus);
g_DynUpdtStatus = NULL;
}
EXITNOW:
SetUnhandledExceptionFilter( pLastExceptionFilter);
return rc;
}
BOOLEAN
AdjustPrivilege(
PCTSTR Privilege
)
/*++
Routine Description:
This routine tries to adjust the priviliege of the current process.
Arguments:
Privilege - String with the name of the privilege to be adjusted.
Return Value:
Returns TRUE if the privilege could be adjusted.
Returns FALSE, otherwise.
--*/
{
HANDLE TokenHandle;
LUID_AND_ATTRIBUTES LuidAndAttributes;
TOKEN_PRIVILEGES TokenPrivileges;
BOOLEAN b = FALSE;
if( !OpenProcessToken( GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&TokenHandle ) ) {
return( FALSE );
}
if(LookupPrivilegeValue( NULL,
Privilege, // (LPWSTR)SE_SECURITY_NAME,
&( LuidAndAttributes.Luid ) ) ) {
LuidAndAttributes.Attributes = SE_PRIVILEGE_ENABLED;
TokenPrivileges.PrivilegeCount = 1;
TokenPrivileges.Privileges[0] = LuidAndAttributes;
if( AdjustTokenPrivileges( TokenHandle,
FALSE,
&TokenPrivileges,
0,
NULL,
NULL ) &&
GetLastError() == NO_ERROR ) {
b = TRUE;
}
}
CloseHandle (TokenHandle);
return b;
}
#if defined(_AMD64_) || defined(_X86_)
BOOL
IsNEC98(
VOID
)
{
#if defined(_X86_)
static BOOL Checked = FALSE;
static BOOL Is98;
if(!Checked) {
Is98 = ((GetKeyboardType(0) == 7) && ((GetKeyboardType(1) & 0xff00) == 0x0d00));
Checked = TRUE;
}
return(Is98);
#else
return FALSE;
#endif
}
#endif
#ifdef _X86_
//
// winnt32.exe Floppyless setup for PC-9800
// setting automatic bootselector main function
//
VOID
SetAutomaticBootselector(
VOID
)
{
//
// This function check System.
// If System is NT, call SetAutomaticBootselectorNT(),
// If System is 95, call SetAutomaticBootselector95(),
//
if (ISNT()){
SetAutomaticBootselectorNT();
} else {
// Now I run on Win95 or Memphis.
SetAutomaticBootselector95();
}
}
VOID
SetAutomaticBootselectorNT(
VOID
)
{
// must use WIN32 function.
ULONG i;
ULONG bps = 512;
PUCHAR pBuffer,pUBuffer;
WCHAR DevicePath[128];
HANDLE hDisk;
NTSTATUS Sts;
DISK_GEOMETRY MediaInfo;
DWORD DataSize;
struct _NEC98_partition_table {
BYTE BootableFlag;
BYTE SystemType;
BYTE Reserve[2];
BYTE IPLStartSector;
BYTE IPLStartHead;
WORD IPLStartCylinder;
BYTE StartSector;
BYTE StartHead;
WORD StartCylinder;
BYTE EndSector;
BYTE EndHead;
WORD EndCylinder;
CHAR SystemName[16];
} *PartitionTable;
LONG StartSector;
LONG HiddenSector;
BOOL b;
//
// Determine the number of hard disks attached to the system
// and allocate space for an array of Disk Descriptors.
// BUGBUG - the number of a maximum of 40 drives below
// seems to be arbitrary
//
for(i=0; i<40; i++){
swprintf(DevicePath,L"\\\\.\\PHYSICALDRIVE%u",i);
hDisk = CreateFileW( DevicePath,
0,
FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
if(hDisk == INVALID_HANDLE_VALUE) {
continue;
}
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&MediaInfo,
sizeof(DISK_GEOMETRY),
&DataSize,
NULL
);
CloseHandle(hDisk);
//
// It's really a hard disk.
//
if(b == 0){
continue;
}
if(MediaInfo.MediaType == RemovableMedia) {
continue;
}
hDisk = CreateFileW( DevicePath,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
if(hDisk == INVALID_HANDLE_VALUE) {
continue;
}
if (CheckATACardonNT4(hDisk)){
CloseHandle(hDisk);
continue;
}
bps = GetHDBps(hDisk);
if (!bps || bps < 8){
CloseHandle(hDisk);
continue;
}
pUBuffer = MALLOC(bps * 3);
pBuffer = ALIGN(pUBuffer, bps);
RtlZeroMemory(pBuffer, bps * 2);
Sts = SpReadWriteDiskSectors(hDisk,0,1,bps,pBuffer, NEC_READSEC);
if(!NT_SUCCESS(Sts)) {
FREE(pUBuffer);
CloseHandle(hDisk);
continue;
}
//
// If PC-AT HD, No action.
//
if (!(pBuffer[4] == 'I'
&& pBuffer[5] == 'P'
&& pBuffer[6] == 'L'
&& pBuffer[7] == '1')){
FREE(pUBuffer);
CloseHandle(hDisk);
continue;
}
if ((pBuffer[bps - 5] == 0) && pBuffer[bps - 6] == 0){
FREE(pUBuffer);
CloseHandle(hDisk);
continue;
}
//
// Clear BootRecord
//
pBuffer[bps - 5] = 0x00;
pBuffer[bps - 6] = 0x00;
SpReadWriteDiskSectors(hDisk,0,1,bps,pBuffer, NEC_WRITESEC);
FREE(pUBuffer);
CloseHandle(hDisk);
}
MYASSERT (SystemPartitionDriveLetter);
HiddenSector = CalcHiddenSector((TCHAR)SystemPartitionDriveLetter, (SHORT)bps);
if(GetSystemPosition(&hDisk, &MediaInfo ) != 0xff) {
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&MediaInfo,
sizeof(DISK_GEOMETRY),
&DataSize,
NULL
);
pUBuffer = MALLOC(bps * 3);
pBuffer = ALIGN(pUBuffer, bps);
RtlZeroMemory(pBuffer, bps * 2);
bps = MediaInfo.BytesPerSector;
Sts = SpReadWriteDiskSectors(hDisk,0,2,bps,pBuffer, NEC_READSEC);
PartitionTable = (struct _NEC98_partition_table *)(pBuffer + 512);
if(NT_SUCCESS(Sts)) {
//
// Update BootRecord
//
for (i = 0; i <16; i++, PartitionTable++){
if (((PartitionTable->SystemType) & 0x7f) == 0)
break;
StartSector =
(((PartitionTable->StartCylinder * MediaInfo.TracksPerCylinder)
+ PartitionTable->StartHead) * MediaInfo.SectorsPerTrack)
+ PartitionTable->StartSector;
if (StartSector == HiddenSector){
pBuffer[bps - 5] = (UCHAR)i;
pBuffer[bps - 6] = 0x80;
PartitionTable->BootableFlag |= 0x80;
Sts = SpReadWriteDiskSectors(hDisk,0,2,bps,pBuffer, NEC_WRITESEC);
}
}
}
FREE(pUBuffer);
CloseHandle(hDisk);
}
}
// I970721
VOID
SetAutomaticBootselector95(
VOID
)
{
int bBootDrvLtr;
if(!W95SetAutoBootFlag) {
//
// Entry points couldn't be found. The upgrade dll is corrupt.
//
MessageBoxFromMessage(
NULL,
MSG_UPGRADE_DLL_CORRUPT,
FALSE,
AppTitleStringId,
MB_OK | MB_ICONERROR | MB_TASKMODAL,
UpgradeSupport.DllPath
);
} else {
MYASSERT (SystemPartitionDriveLetter);
bBootDrvLtr = (int)SystemPartitionDriveLetter;
if (Upgrade)
W95SetAutoBootFlag(bBootDrvLtr);
else {
W95SetABFwFresh(bBootDrvLtr);
}
}
}
#endif
#if defined(_AMD64_) || defined(_X86_)
//
// disksectors read and write function
// I970721
//
NTSTATUS
SpReadWriteDiskSectors(
IN HANDLE Handle,
IN ULONG SectorNumber,
IN ULONG SectorCount,
IN ULONG BytesPerSector,
IN OUT PVOID AlignedBuffer,
IN BOOL ReadWriteSec
)
/*++
Routine Description:
Reads or writes one or more disk sectors.
Arguments:
Handle - supplies handle to open partition object from which
sectors are to be read or written. The handle must be
opened for synchronous I/O.
Return Value:
NTSTATUS value indicating outcome of I/O operation.
--*/
{
DWORD IoSize, IoSize2;
OVERLAPPED Offset;
IO_STATUS_BLOCK IoStatusBlock;
NTSTATUS Status;
//
// Calculate the large integer byte offset of the first sector
// and the size of the I/O.
//
Offset.Offset = SectorNumber * BytesPerSector;
Offset.OffsetHigh = 0;
Offset.hEvent = NULL;
IoSize = SectorCount * BytesPerSector;
//
// Perform the I/O.
//
if ( ReadWriteSec == NEC_READSEC){
(NTSTATUS)Status = ReadFile(
Handle,
AlignedBuffer,
IoSize,
&IoSize2,
&Offset
);
} else {
(NTSTATUS)Status = WriteFile(
Handle,
AlignedBuffer,
IoSize,
&IoSize2,
&Offset
);
}
return(Status);
}
//
// Get WindowsNT System Position
// I970721
//
UCHAR
GetSystemPosition(
PHANDLE phDisk,
PDISK_GEOMETRY pSystemMediaInfo
)
{
HANDLE Handle;
DWORD DataSize;
TCHAR HardDiskName[] = TEXT("\\\\.\\?:");
WCHAR Buffer[128];
WCHAR DevicePath[128];
WCHAR DriveName[3];
WCHAR DiskNo;
UCHAR Position = 0xff, i, errorpt=0;
PWCHAR p, stop;
STORAGE_DEVICE_NUMBER number;
DWORD ExtentSize, err_no;
BOOL b;
PVOLUME_DISK_EXTENTS Extent;
MYASSERT (SystemPartitionDriveLetter);
HardDiskName[4] = SystemPartitionDriveLetter;
DriveName[0] = SystemPartitionDriveLetter;
DriveName[1] = ':';
DriveName[2] = 0;
if(QueryDosDeviceW(DriveName,Buffer,ARRAYSIZE(Buffer))) {
//
// Get SystemPartition Harddisk Geometry
//
Handle = CreateFile(
HardDiskName,
GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
);
if(Handle != INVALID_HANDLE_VALUE) {
DeviceIoControl(
Handle,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
pSystemMediaInfo,
sizeof(DISK_GEOMETRY),
&DataSize,
NULL
);
//
// Get SystemPartition Potition
//
if (BuildNumber <= NT40){ //check NT Version
p = wcsstr(Buffer,L"\\Partition");
Position = (UCHAR)wcstol((p + LENGTHOF("\\Partition")) ,&stop ,10);
//
// QueryDosDevice in NT3.51 is buggy.
// This API return "\\Harddisk\...." or
// "\\harddisk\...."
// We need work around.
//
p = wcsstr(Buffer,L"arddisk");
DiskNo = (*(p + LENGTHOF("arddisk")) - L'0');
} else {
b = DeviceIoControl(Handle, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
&number, sizeof(number), &DataSize, NULL);
if (b) {
Position = (UCHAR) number.PartitionNumber;
DiskNo = (UCHAR) number.DeviceNumber;
} else {
Extent = malloc(1024);
ExtentSize = 1024;
if(!Extent) {
CloseHandle( Handle );
return(Position);
}
b = DeviceIoControl(Handle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
NULL, 0,
(PVOID)Extent, ExtentSize, &DataSize, NULL);
if (!b) {
free(Extent);
CloseHandle( Handle );
return(Position);
}
if (Extent->NumberOfDiskExtents != 1){
free(Extent);
CloseHandle( Handle );
return(Position);
}
DiskNo = (TCHAR)Extent->Extents->DiskNumber;
Position = 0;
free(Extent);
}
}
CloseHandle(Handle);
swprintf(DevicePath,L"\\\\.\\PHYSICALDRIVE%u",DiskNo);
*phDisk = CreateFileW( DevicePath, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL
);
}
}
return(Position);
}
VOID
LocateFirstFloppyDrive(
VOID
)
{
UINT rc;
TCHAR i;
if(!IsNEC98()) {
FirstFloppyDriveLetter = TEXT('A');
return;
}
//
// MyGetDriveType returns DRIVE_REMOVABLE, if drive is floppy.
//
for(i = TEXT('A'); i <= TEXT('Y'); i++) {
if((rc = MyGetDriveType(i)) == DRIVE_REMOVABLE) {
FirstFloppyDriveLetter = i;
return;
}
}
//
// None found yet, set it to Z
//
FirstFloppyDriveLetter = TEXT('Z');
}
#endif
#if defined(_X86_)
VOID
DeleteNEC98DriveAssignFlag(
VOID
)
{
TCHAR HiveName[MAX_PATH];
TCHAR tmp[256];
LONG res;
HKEY hhive;
if (FAILED (StringCchCopy (HiveName,ARRAYSIZE(HiveName),LocalBootDirectory)) ||
!ConcatenatePaths(HiveName,TEXT("setupreg.hiv"),ARRAYSIZE(HiveName))) {
MYASSERT(FALSE);
HiveName[0] = 0;
}
if(!AdjustPrivilege(SE_RESTORE_NAME)){
MYASSERT(FALSE);
//LOG((LOG_WARNING, "DeleteNEC98DriveAssignFlag: AdjustPrivilege(SE_RESTORE_NAME) failed"));
//return;
}
res = RegLoadKey(HKEY_LOCAL_MACHINE, TEXT("$WINNT32"), HiveName);
if (res != ERROR_SUCCESS){
return;
}
res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("$WINNT32\\setup"), 0, KEY_ALL_ACCESS, &hhive);
if (res != ERROR_SUCCESS){
RegUnLoadKey(HKEY_LOCAL_MACHINE, TEXT("$WINNT32"));
return;
}
res = RegDeleteValue(hhive, TEXT("DriveLetter"));
res = RegCloseKey(hhive);
res = RegUnLoadKey(HKEY_LOCAL_MACHINE, TEXT("$WINNT32"));
}
VOID
W95SetABFwFresh(
int bBootDrvLtr
)
{
//
// These items are used to call 98ptn32.dll.
//
//
// Almost below codes are copied from win95upg\w95upg\init9x\init9x.c
//
typedef BOOL (CALLBACK WIN95_PLUGIN_98PTN32_SETBOOTFLAG_PROTOTYPE)(int, WORD);
typedef WIN95_PLUGIN_98PTN32_SETBOOTFLAG_PROTOTYPE * PWIN95_PLUGIN_98PTN32_SETBOOTFLAG;
#define WIN95_98PTN32_SETBOOTFLAG_W L"SetBootable95ptn32"
#define WIN95_98PTN32_SETBOOTFLAG_A "SetBootable95ptn32"
#define NEC98_DLL_NAME_W L"98PTN32.DLL"
#define NEC98_DLL_NAME_A "98PTN32.DLL"
#ifdef UNICODE
#define WIN95_98PTN32_SETBOOTFLAG WIN95_98PTN32_SETBOOTFLAG_W
#define NEC98_DLL_NAME NEC98_DLL_NAME_W
#else
#define WIN95_98PTN32_SETBOOTFLAG WIN95_98PTN32_SETBOOTFLAG_A
#define NEC98_DLL_NAME NEC98_DLL_NAME_A
#endif
#define SB_BOOTABLE 0x0001
#define SB_UNBOOTABLE 0x0002
#define MSK_BOOTABLE 0x000f
#define SB_AUTO 0x0010
#define MSK_AUTO 0x00f0
TCHAR MyPath[MAX_PATH], *p;
HINSTANCE g_Pc98ModuleHandle = NULL;
PWIN95_PLUGIN_98PTN32_SETBOOTFLAG SetBootFlag16;
//
// Obtain PC-98 helper routine addresses
// Generate directory of WINNT32
//
if( !MyGetModuleFileName (NULL, MyPath, ARRAYSIZE(MyPath)) || (!(p =_tcsrchr(MyPath, TEXT('\\')))))
return;
*p= 0;
if (!ConcatenatePaths (MyPath, NEC98_DLL_NAME, ARRAYSIZE(MyPath))) {
return;
}
//
// Load library
//
g_Pc98ModuleHandle = LoadLibraryEx(
MyPath,
NULL,
LOAD_WITH_ALTERED_SEARCH_PATH
);
if(!g_Pc98ModuleHandle){
return;
}
//
// Get entry points
//
(FARPROC)SetBootFlag16 = GetProcAddress (g_Pc98ModuleHandle, (const char *)WIN95_98PTN32_SETBOOTFLAG);
if(!SetBootFlag16){
FreeLibrary(g_Pc98ModuleHandle);
return;
}
//
// Set auto boot flag on System drive use 16 bit DLL.
//
SetBootFlag16(bBootDrvLtr, SB_BOOTABLE | SB_AUTO);
FreeLibrary(g_Pc98ModuleHandle);
}
//
// Some NEC98 Windows NT4 system is installed DMITOOL
// This AP block the CreateFile API
// Setup need to check this AP
//
// Return
// TRUE ... DMITOOL is installed
// False .. DMITOOL is not installed
BOOL
NEC98CheckDMI()
{
HKEY hKey;
LONG Error;
TCHAR buf[100];
DWORD bufsize = sizeof(buf);
if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT("SOFTWARE\\NEC\\PcAssistant\\Common"),
0, KEY_READ, &hKey) != ERROR_SUCCESS ) {
return(FALSE);
}
if (RegQueryValueEx(hKey, TEXT("Ver"), NULL,
NULL, (unsigned char *)buf,
&bufsize ) != ERROR_SUCCESS ) {
RegCloseKey( hKey );
return(FALSE);
}
RegCloseKey( hKey );
//
// We need check major Version is '2.
//
if (bufsize >= sizeof (buf[0]) && (TCHAR)*buf != (TCHAR)'2')
return(FALSE);
return(TRUE);
}
#endif
typedef BOOL (WINAPI* INITBILLBOARD)(HWND , LPCTSTR, DWORD);
typedef BOOL (WINAPI* TERMBILLBOARD)();
void PrepareBillBoard(HWND hwnd)
{
TCHAR szPath[MAX_PATH];
INITBILLBOARD pinitbb;
BOOL bMagnifierRunning = FALSE;
// Check if Magnifier is running.
HANDLE hEvent = CreateEvent(NULL, TRUE, TRUE, TEXT("MSMagnifierAlreadyExistsEvent"));
bMagnifierRunning = (!hEvent || GetLastError() == ERROR_ALREADY_EXISTS);
if (hEvent)
{
CloseHandle(hEvent);
}
// If the Magnifier is not set yet, set it.
if (!AccessibleMagnifier)
{
AccessibleMagnifier = bMagnifierRunning;
}
if (!bMagnifierRunning && FindPathToWinnt32File (
#ifndef UNICODE
TEXT("winntbba.dll"),
#else
TEXT("winntbbu.dll"),
#endif
szPath,
ARRAYSIZE(szPath)
)) {
hinstBB = LoadLibrary (szPath);
if (hinstBB)
{
pinitbb = (INITBILLBOARD)GetProcAddress(hinstBB, "InitBillBoard");
if (pinitbb)
{
// Set no billboard text, just the background
if (!(*pinitbb)(hwnd, TEXT(""), ProductFlavor))
{
FreeLibrary(hinstBB);
hinstBB = NULL;
}
}
}
}
}
void TerminateBillBoard()
{
TERMBILLBOARD pTermBillBoard;
if (hinstBB)
{
if (pTermBillBoard = (TERMBILLBOARD)GetProcAddress(hinstBB, "TermBillBoard"))
pTermBillBoard ();
}
}
//
// This function is here so that when the wizard is hidden and the users
// task switches between other apps and setup, that we can handle the
// ESC key and forward it to the wizard dialog proc.
LRESULT
CALLBACK
MainBackgroundWndProc (
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch (uMsg)
{
case WM_CHAR:
if (wParam == VK_ESCAPE)
{
// Forward this to the wizard dlg proc.
SendMessage(WizardHandle, uMsg, wParam, lParam);
return 0;
}
break;
}
return DefWindowProc (hwnd, uMsg, wParam, lParam);
}
void CreateMainWindow()
{
RECT rect;
WNDCLASSEX wcx;
TCHAR Caption[512];
GetWindowRect (GetDesktopWindow(), &rect);
ZeroMemory (&wcx, sizeof (wcx));
wcx.cbSize = sizeof (wcx);
wcx.style = CS_HREDRAW | CS_VREDRAW| CS_NOCLOSE;
wcx.lpfnWndProc = MainBackgroundWndProc;
wcx.hInstance = hInst;
wcx.lpszClassName = TEXT("Winnt32Background");
RegisterClassEx (&wcx);
if (!LoadString (
hInst,
AppTitleStringId,
Caption,
ARRAYSIZE(Caption)
)) {
Caption[0] = 0;
}
BackgroundWnd2 = CreateWindowEx (
WS_EX_APPWINDOW,
TEXT("Winnt32Background"),
Caption,
WS_CLIPCHILDREN|WS_POPUP|WS_VISIBLE,
rect.left,
rect.top,
rect.right,
rect.bottom,
NULL,
NULL,
hInst,
0
);
}
VOID
DisableSystemRestore( void )
/*
Description:
Procedure to disable system restore on upgrades. This way we save a lot of space
as disabling system restore will clear out the old files under
System Volume Information\_restore.{guid}".
*/
{
HMODULE SRClient = NULL;
if( Upgrade ){
SRClient = LoadLibrary(TEXT("SRCLIENT.DLL"));
if( !SRClient )
return;
else{
if( ((FARPROC)SRClientDisableSR = GetProcAddress( SRClient, "DisableSR")) != NULL){
//Call the routine
SRClientDisableSR( NULL );
DebugLog(Winnt32LogInformation, TEXT("System Restore was disabled"), 0);
}
}
FreeLibrary( SRClient );
}
return;
}
#ifdef RUN_SYSPARSE
VOID
pCenterWindowOnDesktop (
HWND WndToCenter
)
/*++
Routine Description:
Centers a dialog relative to the 'work area' of the desktop.
Arguments:
WndToCenter - window handle of dialog to center
Return Value:
None.
--*/
{
RECT rcFrame, rcWindow;
LONG x, y, w, h;
POINT point;
HWND Desktop = GetDesktopWindow ();
point.x = point.y = 0;
ClientToScreen(Desktop, &point);
GetWindowRect(WndToCenter, &rcWindow);
GetClientRect(Desktop, &rcFrame);
w = rcWindow.right - rcWindow.left + 1;
h = rcWindow.bottom - rcWindow.top + 1;
x = point.x + ((rcFrame.right - rcFrame.left + 1 - w) / 2);
y = point.y + ((rcFrame.bottom - rcFrame.top + 1 - h) / 2);
//
// Get the work area for the current desktop (i.e., the area that
// the tray doesn't occupy).
//
if(!SystemParametersInfo (SPI_GETWORKAREA, 0, (PVOID)&rcFrame, 0)) {
//
// For some reason SPI failed, so use the full screen.
//
rcFrame.top = rcFrame.left = 0;
rcFrame.right = GetSystemMetrics(SM_CXSCREEN);
rcFrame.bottom = GetSystemMetrics(SM_CYSCREEN);
}
if(x + w > rcFrame.right) {
x = rcFrame.right - w;
} else if(x < rcFrame.left) {
x = rcFrame.left;
}
if(y + h > rcFrame.bottom) {
y = rcFrame.bottom - h;
} else if(y < rcFrame.top) {
y = rcFrame.top;
}
MoveWindow(WndToCenter, x, y, w, h, FALSE);
}
LRESULT
SysParseDlgProc(
IN HWND hdlg,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
static DWORD ElapsedTime = 0;
static UINT_PTR timer = 0;
DWORD ret;
switch(msg) {
case WM_INITDIALOG:
pCenterWindowOnDesktop( hdlg);
timer = SetTimer( hdlg, WMX_SYSPARSE_DONE, 1000, NULL);
if ( !timer) {
EndDialog(hdlg,TRUE);
}
return( TRUE );
case WM_TIMER:
ElapsedTime++;
ret = WaitForSingleObject( piSysparse.hProcess, 0);
if ( ret == WAIT_OBJECT_0) {
KillTimer (hdlg, timer);
EndDialog(hdlg,TRUE);
} else if ( ElapsedTime >= 90) {
KillTimer (hdlg, timer);
TerminateProcess( piSysparse.hProcess, ERROR_TIMEOUT);
EndDialog(hdlg,TRUE);
}
return( TRUE );
default:
break;
}
return( FALSE );
}
#endif