1832 lines
52 KiB
C
1832 lines
52 KiB
C
/*++
|
|
|
|
File Description:
|
|
|
|
This file contains all the functions required to add a registry entry
|
|
to force execution of the system clone worker upon reboot.
|
|
|
|
--*/
|
|
|
|
#include <stdio.h>
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <ntpoapi.h>
|
|
#include <ntdddisk.h>
|
|
#include <windows.h>
|
|
#include <shlwapi.h>
|
|
#include <stdlib.h>
|
|
#include <lmcons.h>
|
|
#include <lmerr.h>
|
|
#include <lmjoin.h>
|
|
#include <regstr.h>
|
|
#include "sysprep.h"
|
|
#include "msg.h"
|
|
#include "resource.h"
|
|
#include <tchar.h>
|
|
#include <opklib.h>
|
|
#include <ntverp.h>
|
|
#include <spsyslib.h>
|
|
#include <sysprep_.c>
|
|
#include <winbom.h>
|
|
|
|
|
|
// External functions
|
|
//
|
|
extern void uiDialogTopRight(HWND hwndDlg);
|
|
extern HWND ghwndOemResetDlg;
|
|
|
|
|
|
//
|
|
// Does the user want a new SID?
|
|
//
|
|
BOOL NoSidGen = FALSE;
|
|
BOOL SetupClPresent = TRUE;
|
|
|
|
//
|
|
// Does the user want confirmation?
|
|
//
|
|
BOOL QuietMode = FALSE;
|
|
|
|
//
|
|
// Do PnP re-enumeration?
|
|
//
|
|
BOOL PnP = FALSE;
|
|
|
|
//
|
|
// Do we shutdown when we're done?
|
|
//
|
|
BOOL NoReboot = FALSE;
|
|
|
|
//
|
|
// Instead of shutting down, do we reboot?
|
|
//
|
|
BOOL Reboot = FALSE;
|
|
|
|
//
|
|
// Clean out the critical devices database?
|
|
//
|
|
BOOL Clean = FALSE;
|
|
|
|
//
|
|
// Force the shutdown instead of trying to poweroff?
|
|
//
|
|
BOOL ForceShutdown = FALSE;
|
|
|
|
//
|
|
// Generating an Image for Factory Preinstallation.
|
|
//
|
|
BOOL Factory = FALSE;
|
|
|
|
//
|
|
// Reseal a machine after running FACTORY.EXE
|
|
//
|
|
BOOL Reseal = FALSE;
|
|
// Per/Pro SKUs defaults to OOBE, Server SKUs always use MiniSetup.
|
|
// Pro SKU can override OOBE with -mini to use MiniSetup also
|
|
// via sysprep.inf
|
|
BOOL bMiniSetup = FALSE;
|
|
|
|
//
|
|
// Just do an audit boot if this switch is passed in. ( '-audit' )
|
|
//
|
|
|
|
BOOL Audit = FALSE;
|
|
//
|
|
// Rollback
|
|
//
|
|
BOOL bActivated = FALSE;
|
|
|
|
//
|
|
// Build list of pnpids in [sysprepmassstorage] section in sysprep.inf
|
|
//
|
|
BOOL BuildMSD = FALSE;
|
|
|
|
|
|
//
|
|
// Internal Define(s):
|
|
//
|
|
#define SYSPREP_LOG _T("SYSPREP.LOG") // Sysprep log file
|
|
#define SYSPREP_MUTEX _T("SYSPREP-APP-5c9fbbd0-ee0e-11d2-9a21-0000f81edacc") // GUID used to determine if sysprep is currently running
|
|
#define SYSPREP_LOCK_SLEEP 100 // Number of miliseconds to sleep in LockApplication function
|
|
#define SYSPREP_LOCK_SLEEP_COUNT 10 // Number of times to sleep during LockApplication function
|
|
|
|
// Path to the sysprep directory.
|
|
//
|
|
TCHAR g_szSysprepDir[MAX_PATH] = NULLSTR;
|
|
|
|
// Path to the SYSPREP.EXE.
|
|
//
|
|
TCHAR g_szSysprepPath[MAX_PATH] = NULLSTR;
|
|
|
|
// Path to the Sysprep log file.
|
|
//
|
|
TCHAR g_szLogFile[MAX_PATH] = NULLSTR;
|
|
|
|
// Path to the Winbom file.
|
|
//
|
|
TCHAR g_szWinBOMPath[MAX_PATH] = NULLSTR;
|
|
|
|
// Public functions
|
|
//
|
|
BOOL FProcessSwitches();
|
|
|
|
// Local functions
|
|
static BOOL RenameWinbom();
|
|
static INT CleanupPhantomDevices();
|
|
static VOID CleanUpDevices();
|
|
|
|
#if !defined(_WIN64)
|
|
static BOOL SaveDiskSignature();
|
|
#endif // !defined(_WIN64)
|
|
|
|
|
|
//
|
|
// UI stuff...
|
|
//
|
|
HINSTANCE ghInstance;
|
|
UINT AppTitleStringId = IDS_APPTITLE;
|
|
HANDLE ghWaitEvent = NULL, ghWaitThread = NULL;
|
|
BOOL gbScreenSaver = FALSE;
|
|
|
|
void StartWaitThread();
|
|
void EndWaitThread();
|
|
void DisableScreenSaver(BOOL *pScreenSaver);
|
|
void EnableScreenSaver(BOOL *pScreenSaver);
|
|
|
|
int
|
|
MessageBoxFromMessageV(
|
|
IN DWORD MessageId,
|
|
IN DWORD CaptionStringId,
|
|
IN UINT Style,
|
|
IN va_list *Args
|
|
)
|
|
{
|
|
TCHAR Caption[512];
|
|
TCHAR Buffer[5000];
|
|
|
|
if(!LoadString(ghInstance,CaptionStringId,Caption,sizeof(Caption)/sizeof(TCHAR))) {
|
|
Caption[0] = 0;
|
|
}
|
|
|
|
if( !FormatMessage( FORMAT_MESSAGE_FROM_HMODULE,
|
|
ghInstance,
|
|
MessageId,
|
|
0,
|
|
Buffer,
|
|
sizeof(Buffer) / sizeof(TCHAR),
|
|
Args ) ) {
|
|
return GetLastError();
|
|
} else {
|
|
return(MessageBox(NULL,Buffer,Caption,Style));
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
MessageBoxFromMessage(
|
|
IN DWORD MessageId,
|
|
IN DWORD CaptionStringId,
|
|
IN UINT Style,
|
|
...
|
|
)
|
|
{
|
|
va_list arglist;
|
|
int i = IDOK; // Default return value of "OK".
|
|
|
|
// If we're in the middle of a Wait thread kill it
|
|
//
|
|
EndWaitThread();
|
|
|
|
if ( !QuietMode )
|
|
{
|
|
va_start(arglist,Style);
|
|
|
|
i = MessageBoxFromMessageV(MessageId,CaptionStringId,Style,&arglist);
|
|
|
|
va_end(arglist);
|
|
}
|
|
|
|
return(i);
|
|
}
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This routine will attempt to disjoin a user from a domain, if he
|
|
is already in a domain
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE - Everything is okay.
|
|
|
|
FALSE - Something bad happened.
|
|
|
|
===============================================================================
|
|
--*/
|
|
BOOL UnjoinNetworkDomain
|
|
(
|
|
void
|
|
)
|
|
{
|
|
if (IsDomainMember())
|
|
{
|
|
// He's a member of some domain. Let's try and remove him
|
|
// from the domain.
|
|
if (NO_ERROR != NetUnjoinDomain( NULL, NULL, NULL, 0 ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This routine will setup the setup for operation on the "factory floor"
|
|
The purpose here is to run a process which will facilitate the installation
|
|
of updated drivers for new devices, and to boot quickly into full GUI mode
|
|
for application pre-install/config, as well as to customize the system.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors, FALSE otherise
|
|
|
|
===============================================================================
|
|
--*/
|
|
BOOL SetupForFactoryFloor
|
|
(
|
|
void
|
|
)
|
|
{
|
|
TCHAR szFactory[MAX_PATH] = NULLSTR,
|
|
szSysprep[MAX_PATH] = NULLSTR,
|
|
szSystem[MAX_PATH] = NULLSTR;
|
|
LPTSTR lpFilePart = NULLSTR;
|
|
|
|
// Make sure we have the right privileges
|
|
//
|
|
pSetupEnablePrivilege(SE_RESTORE_NAME,TRUE);
|
|
pSetupEnablePrivilege(SE_BACKUP_NAME,TRUE);
|
|
|
|
// We need the path to sysprep.exe and factory.exe.
|
|
//
|
|
if ( !( GetModuleFileName(NULL, szSysprep, AS(szSysprep)) && szSysprep[0] &&
|
|
GetFullPathName(szSysprep, AS(szFactory), szFactory, &lpFilePart) && szFactory[0] && lpFilePart ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Replace the sysprep.exe filename with factory.exe.
|
|
//
|
|
StringCchCopy ( lpFilePart, AS ( szFactory ) - ( lpFilePart - szFactory ), TEXT( "factory.exe" ) );
|
|
|
|
// Make sure that sysprep.exe and factory.exe are on the system drive.
|
|
//
|
|
if ( ( ExpandEnvironmentStrings(TEXT("%SystemDrive%"), szSystem, AS(szSystem)) ) &&
|
|
( szSystem[0] ) &&
|
|
( szSystem[0] != szSysprep[0] ) )
|
|
{
|
|
// Well that sucks, we should try and copy the files over to the %SystemDrive%\sysprep folder.
|
|
//
|
|
AddPath(szSystem, TEXT("sysprep"));
|
|
lpFilePart = szSystem + lstrlen(szSystem);
|
|
CreateDirectory(szSystem, NULL);
|
|
|
|
// First copy factory locally.
|
|
//
|
|
AddPath(szSystem, TEXT("factory.exe"));
|
|
CopyFile(szFactory, szSystem, FALSE);
|
|
StringCchCopy ( szFactory, AS ( szFactory ), szSystem );
|
|
|
|
// Now try to copy sysprep.exe.
|
|
//
|
|
*lpFilePart = TEXT('\0');
|
|
AddPath(szSystem, TEXT("sysprep.exe"));
|
|
CopyFile(szSysprep, szSystem, FALSE);
|
|
//lstrcpy(szSysprep, szSystem);
|
|
}
|
|
|
|
if (!SetFactoryStartup(szFactory))
|
|
return FALSE;
|
|
|
|
// Clear out any previous Factory.exe state settings
|
|
RegDeleteKey(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Factory\\State");
|
|
|
|
// Remove any setting before Factory
|
|
//
|
|
NukeMruList();
|
|
|
|
// Rearm
|
|
//
|
|
if (!IsIA64() && !bActivated && (ERROR_SUCCESS != ReArm())) {
|
|
// Display warning that grace period limit has reached and cannot
|
|
// re-active grace period, and we continue thru.
|
|
//
|
|
MessageBoxFromMessage( MSG_REARM_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
INT_PTR WaitDlgProc
|
|
(
|
|
IN HWND hwndDlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
// Centers the wait dialog in parent or screen
|
|
//
|
|
HWND hwndParent = GetParent(hwndDlg);
|
|
CenterDialogEx(hwndParent, hwndDlg);
|
|
|
|
// If no parent then make sure this is visible
|
|
//
|
|
if (hwndParent == NULL)
|
|
SetForegroundWindow(hwndDlg);
|
|
|
|
// Play the animation
|
|
//
|
|
Animate_Open(GetDlgItem(hwndDlg,IDC_ANIMATE),MAKEINTRESOURCE(IDA_CLOCK_AVI));
|
|
Animate_Play(GetDlgItem(hwndDlg,IDC_ANIMATE),0,-1,-1);
|
|
}
|
|
break;
|
|
|
|
}
|
|
return (BOOL) FALSE;
|
|
}
|
|
|
|
DWORD WaitThread(LPVOID lpVoid)
|
|
{
|
|
HWND hwnd;
|
|
|
|
if ( hwnd = CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_WAIT), ghwndOemResetDlg, (DLGPROC) WaitDlgProc) )
|
|
{
|
|
MSG msg;
|
|
HANDLE hEvent = (HANDLE) lpVoid;
|
|
|
|
ShowWindow(hwnd, SW_SHOWNORMAL);
|
|
while ( MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT) == (WAIT_OBJECT_0 + 1) )
|
|
{
|
|
while ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
DestroyWindow(hwnd);
|
|
}
|
|
else
|
|
GetLastError();
|
|
|
|
return 0;
|
|
}
|
|
|
|
void StartWaitThread()
|
|
{
|
|
// Create a dialog to show progress is being made.
|
|
//
|
|
DWORD dwThread;
|
|
|
|
// Disable the toplevel Oemreset dialog
|
|
//
|
|
if (ghwndOemResetDlg)
|
|
EnableWindow(ghwndOemResetDlg, FALSE);
|
|
|
|
if ( ghWaitEvent = CreateEvent(NULL, TRUE, FALSE, TEXT("SYSPREP_EVENT_WAIT")))
|
|
ghWaitThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) WaitThread, (LPVOID) ghWaitEvent, 0, &dwThread);
|
|
}
|
|
|
|
void EndWaitThread()
|
|
{
|
|
// Kill the Status Dialog.
|
|
//
|
|
if ( ghWaitEvent )
|
|
SetEvent(ghWaitEvent);
|
|
|
|
// Try and let the thread terminate nicely.
|
|
//
|
|
if ( ghWaitThread )
|
|
WaitForSingleObject(ghWaitThread, 2000);
|
|
|
|
// Clear the handles
|
|
//
|
|
ghWaitEvent = NULL;
|
|
ghWaitThread = NULL;
|
|
|
|
// Enable the toplevel OemReset dialog
|
|
//
|
|
if (ghwndOemResetDlg)
|
|
EnableWindow(ghwndOemResetDlg, TRUE);
|
|
}
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This is the error callback handler for SetDefaultOEMApps()
|
|
|
|
===============================================================================
|
|
--*/
|
|
|
|
void ReportSetDefaultOEMAppsError(LPCTSTR pszAppName, LPCTSTR pszIniVar)
|
|
{
|
|
MessageBoxFromMessage( MSG_SETDEFAULTS_NOTFOUND,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL,
|
|
pszAppName, pszIniVar);
|
|
}
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This routine will perform the tasks necessary to reseal the machine,
|
|
readying it to be shipped to the end user.
|
|
|
|
Arguments:
|
|
|
|
BOOL fIgnoreFactory - ignores if factory floor was run
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors, FALSE otherwise
|
|
|
|
===============================================================================
|
|
--*/
|
|
BOOL ResealMachine
|
|
(
|
|
void
|
|
)
|
|
{
|
|
// Make sure privileges have been set
|
|
//
|
|
pSetupEnablePrivilege(SE_RESTORE_NAME,TRUE);
|
|
pSetupEnablePrivilege(SE_BACKUP_NAME,TRUE);
|
|
|
|
// Prepare the machine to be hardware independent.
|
|
//
|
|
if (!FPrepareMachine()) {
|
|
MessageBoxFromMessage( MSG_REGISTRY_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Cleanup registry no matter what since factorymode=yes can set this
|
|
// and winbom.ini can set this and sysprep -factory can set this, or else
|
|
// PnP will hang on FactoryPreInstallInProgress being set.
|
|
//
|
|
CleanupRegistry();
|
|
|
|
// Clean up the factory mess.
|
|
//
|
|
RegDelete(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon", L"AutoAdminLogon");
|
|
SHDeleteKey(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Factory");
|
|
|
|
// Rearm
|
|
//
|
|
if (!IsIA64() && !bActivated && (ERROR_SUCCESS != ReArm())) {
|
|
// Display warning that grace period limit has reached and cannot
|
|
// re-active grace period, and we continue thru.
|
|
//
|
|
MessageBoxFromMessage( MSG_REARM_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
}
|
|
|
|
#if defined(_WIN64)
|
|
|
|
//
|
|
// For EFI machines set the boot timeout to 5 seconds so that developers get a chance to see
|
|
// the boot menu and have the option to boot to the EFI shell, CD, or other menu options,
|
|
// for development purposes.
|
|
//
|
|
ChangeBootTimeout(5);
|
|
|
|
#else
|
|
|
|
ChangeBootTimeout(0); // reset the timeout to 0 secs
|
|
|
|
#endif // !defined(_WIN64)
|
|
|
|
|
|
//
|
|
// First part of reseal.
|
|
//
|
|
AdjustFiles();
|
|
|
|
//
|
|
// Second part of reseal.
|
|
//
|
|
// This is common reseal code used by both Riprep and Sysprep.
|
|
// These happen whether or not factory floor was run before.
|
|
//
|
|
if (!FCommonReseal()) {
|
|
MessageBoxFromMessage( MSG_COMMON_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
return FALSE;
|
|
}
|
|
|
|
// ISSUE-2000/06/06-DONALDM
|
|
// We need to handle the network configuration problem for factory more cleanly
|
|
// We need to define what the network state is when factory first comes up, and
|
|
// what the network state is for final customer delivery. Simply disjoining from
|
|
// a domain during reseal is probably not enough...
|
|
//
|
|
|
|
// if( !UnjoinNetworkDomain())
|
|
// {
|
|
// // We failed to disjoin. Our only option is to
|
|
// // inform the user and bail.
|
|
// MessageBoxFromMessage( MSG_DOMAIN_INCOMPATIBILITY,
|
|
// AppTitleStringId,
|
|
// MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
// return FALSE;
|
|
// }
|
|
|
|
//
|
|
// Set default middleware applications.
|
|
//
|
|
if (!SetDefaultOEMApps(g_szWinBOMPath))
|
|
{
|
|
// SetDefaultApplications will do its own MessageBoxFromMessage
|
|
// with more detailed information
|
|
return FALSE;
|
|
}
|
|
|
|
// Call functions in published SYSPREP_.C file that we skiped when the
|
|
// FACTORY option was selected
|
|
|
|
// ISSUE-2000/06/05-DONALDM - We need to really decide about how to handle network settings for
|
|
// the factory case. I think we don't need this call, becase we should have
|
|
// already dealt with networking settings when FACTORY.EXE ran.
|
|
//
|
|
|
|
// RemoveNetworkSettings(NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Macro for processing command line options.
|
|
// Setting bVar to 1 (not to 'TRUE') because we need it for mutually exclusive option checks below.
|
|
//
|
|
#define CHECK_PARAM(lpCmdLine, lpOption, bVar) if ( LSTRCMPI(lpCmdLine, lpOption) == 0 ) bVar = 1
|
|
|
|
//
|
|
// Parse command line parameters
|
|
//
|
|
static BOOL ParseCmdLine()
|
|
{
|
|
DWORD dwArgs;
|
|
LPTSTR *lpArgs;
|
|
BOOL bError = FALSE;
|
|
BOOL bHelp = FALSE;
|
|
|
|
if ( (dwArgs = GetCommandLineArgs(&lpArgs) ) && lpArgs )
|
|
{
|
|
LPTSTR lpArg;
|
|
DWORD dwArg;
|
|
|
|
// We want to skip over the first argument (it is the path
|
|
// to the command being executed.
|
|
//
|
|
if ( dwArgs > 1 )
|
|
{
|
|
dwArg = 1;
|
|
lpArg = *(lpArgs + dwArg);
|
|
}
|
|
else
|
|
lpArg = NULL;
|
|
|
|
// Loop through all the arguments.
|
|
//
|
|
while ( lpArg && !bError )
|
|
{
|
|
// Now we check to see if the first char is a dash or forward slash.
|
|
//
|
|
if ( *lpArg == _T('-') || *lpArg == _T('/'))
|
|
{
|
|
LPTSTR lpOption = CharNext(lpArg);
|
|
|
|
// This is where you add command line options that start with a dash (-).
|
|
//
|
|
CHECK_PARAM( lpOption, _T("quiet"), QuietMode);
|
|
CHECK_PARAM( lpOption, _T("nosidgen"), NoSidGen);
|
|
CHECK_PARAM( lpOption, _T("pnp"), PnP);
|
|
CHECK_PARAM( lpOption, _T("noreboot"), NoReboot);
|
|
CHECK_PARAM( lpOption, _T("reboot"), Reboot);
|
|
CHECK_PARAM( lpOption, _T("clean"), Clean);
|
|
CHECK_PARAM( lpOption, _T("forceshutdown"), ForceShutdown);
|
|
CHECK_PARAM( lpOption, _T("factory"), Factory);
|
|
CHECK_PARAM( lpOption, _T("reseal"), Reseal);
|
|
CHECK_PARAM( lpOption, _T("mini"), bMiniSetup);
|
|
CHECK_PARAM( lpOption, _T("audit"), Audit);
|
|
CHECK_PARAM( lpOption, _T("activated"), bActivated);
|
|
CHECK_PARAM( lpOption, _T("bmsd"), BuildMSD);
|
|
CHECK_PARAM( lpOption, _T("?"), bHelp);
|
|
}
|
|
else if ( *lpArg )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
|
|
// Setup the pointer to the next argument in the command line.
|
|
//
|
|
if ( ++dwArg < dwArgs )
|
|
lpArg = *(lpArgs + dwArg);
|
|
else
|
|
lpArg = NULL;
|
|
}
|
|
|
|
// Make sure to free the two buffers allocated by the GetCommandLineArgs() function.
|
|
//
|
|
FREE(*lpArgs);
|
|
FREE(lpArgs);
|
|
}
|
|
|
|
if (bError || bHelp)
|
|
{
|
|
// Set the quiet switch in this case so we display the error.
|
|
// Note that we return FALSE and exit the application following this.
|
|
//
|
|
QuietMode = FALSE;
|
|
MessageBoxFromMessage( MSG_USAGE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_TASKMODAL );
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Now look at the switches passed in and make sure that they are consistent.
|
|
// If they are not, display an error message and quit, unless we're in quiet
|
|
// mode where we do not display any error messages.
|
|
//
|
|
|
|
//
|
|
// Check that the shutdown options are not conflicting with each other.
|
|
if ( (NoReboot + Reboot + ForceShutdown) > 1 )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
// These top-level options are exclusive: -bmsd, -clean, -audit, -factory, -reseal.
|
|
//
|
|
else if ( (BuildMSD + Clean + Audit + Factory + Reseal) > 1 )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
// For Clean or BuildMSD none of the options except -quiet are valid.
|
|
//
|
|
else if ( Clean || BuildMSD )
|
|
{
|
|
if ( NoSidGen || PnP || NoReboot || Reboot || ForceShutdown || bMiniSetup || bActivated )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
}
|
|
else if ( Audit )
|
|
{
|
|
if ( NoSidGen || PnP || bMiniSetup || bActivated )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
}
|
|
else if ( Factory )
|
|
{
|
|
if ( PnP || bMiniSetup )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
}
|
|
else if ( Reseal )
|
|
{
|
|
// If -pnp is specified -mini must have been specified unless we're running on server or ia64 (because
|
|
// later we force bMiniSetup to be true on server and ia64.
|
|
//
|
|
if ( PnP && !bMiniSetup && !(IsServerSKU() || IsIA64()) )
|
|
{
|
|
bError = TRUE;
|
|
}
|
|
}
|
|
|
|
// If there was some inconsistency in the switches specified put up
|
|
// an error message.
|
|
if ( bError )
|
|
{
|
|
// Reset the quiet switch in this case so we display the error.
|
|
// Note that we return FALSE and exit the application following this.
|
|
//
|
|
QuietMode = FALSE;
|
|
MessageBoxFromMessage( MSG_USAGE_COMBINATIONS,
|
|
AppTitleStringId,
|
|
MB_OK | MB_TASKMODAL | MB_ICONERROR);
|
|
return FALSE;
|
|
}
|
|
// Force MiniSetup on IA64 and Servers.
|
|
//
|
|
if (IsIA64() || IsServerSKU())
|
|
{
|
|
bMiniSetup = TRUE;
|
|
}
|
|
else if ( IsPersonalSKU() )
|
|
{
|
|
if ( bMiniSetup )
|
|
{
|
|
// Can't specify mini-setup for personal sku
|
|
//
|
|
MessageBoxFromMessage( MSG_NO_MINISETUP,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
|
|
bMiniSetup = FALSE;
|
|
}
|
|
|
|
if ( PnP )
|
|
{
|
|
// Can't specify -pnp because we're not running mini-setup on personal sku.
|
|
//
|
|
MessageBoxFromMessage( MSG_NO_PNP,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
PnP = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we're cleaning up the critical device database,
|
|
// then we'll be wanting to set some additional flags.
|
|
//
|
|
if (Clean || BuildMSD)
|
|
{
|
|
QuietMode = TRUE;
|
|
NoReboot = TRUE;
|
|
}
|
|
return !bError;
|
|
}
|
|
|
|
|
|
BOOL
|
|
IsFactoryPresent(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This routine tests to see if FACTORY.EXE is present on the machine.
|
|
FACTORY.EXE will be required to run on reboot, so if it's not here,
|
|
we need to know.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE - FACTORY.EXE is present.
|
|
|
|
FALSE - FACTORY.EXE is not present.
|
|
|
|
===============================================================================
|
|
--*/
|
|
|
|
{
|
|
WCHAR FileName[MAX_PATH];
|
|
|
|
// Attempt to locate FACTORY.EXE
|
|
//
|
|
if (GetModuleFileName(NULL, FileName, MAX_PATH)) {
|
|
if (PathRemoveFileSpec(FileName)) {
|
|
OPKAddPathN(FileName, TEXT("FACTORY.EXE"), AS ( FileName ));
|
|
if (FileExists(FileName))
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void PowerOff(BOOL fForceShutdown)
|
|
{
|
|
SYSTEM_POWER_CAPABILITIES spc;
|
|
ULONG uiFlags = EWX_POWEROFF;
|
|
|
|
ZeroMemory(&spc, sizeof(spc));
|
|
|
|
// Make sure we have privilege to shutdown
|
|
//
|
|
pSetupEnablePrivilege(SE_SHUTDOWN_NAME,TRUE);
|
|
|
|
//
|
|
// Use flag else query system for power capabilities
|
|
//
|
|
if (fForceShutdown)
|
|
uiFlags = EWX_SHUTDOWN;
|
|
else if (NT_SUCCESS(NtPowerInformation(SystemPowerCapabilities,
|
|
NULL,
|
|
0,
|
|
&spc,
|
|
sizeof(spc))))
|
|
{
|
|
//
|
|
// spc.SystemS1 == sleep 1
|
|
// spc.SystemS2 == sleep 2
|
|
// spc.SystemS3 == sleep 3
|
|
// spc.SystemS4 == hibernate support
|
|
// spc.SystemS5 == poweroff support
|
|
//
|
|
if (spc.SystemS5)
|
|
{
|
|
// ACPI capable
|
|
uiFlags = EWX_POWEROFF;
|
|
}
|
|
else
|
|
{
|
|
// Non-ACPI
|
|
uiFlags = EWX_SHUTDOWN;
|
|
}
|
|
}
|
|
|
|
ExitWindowsEx(uiFlags|EWX_FORCE, SYSPREP_SHUTDOWN_FLAGS);
|
|
}
|
|
|
|
int APIENTRY WinMain( HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine,
|
|
int nCmdShow )
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
This routine is the main entry point for the program.
|
|
|
|
We do a bit of error checking, then, if all goes well, we update the
|
|
registry to enable execution of our second half.
|
|
|
|
===============================================================================
|
|
--*/
|
|
|
|
{
|
|
DWORD dwVal;
|
|
HKEY hKey;
|
|
LPTSTR lpFilePart = NULL;
|
|
INITCOMMONCONTROLSEX icex;
|
|
LPTSTR lpAppName = NULL;
|
|
|
|
ghInstance = hInstance;
|
|
|
|
SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
memset(&icex, 0, sizeof(icex));
|
|
icex.dwSize = sizeof(icex);
|
|
icex.dwICC = ICC_PROGRESS_CLASS|ICC_ANIMATE_CLASS;
|
|
InitCommonControlsEx(&icex);
|
|
|
|
// We need the path to sysprep.exe and where it is located.
|
|
//
|
|
GetModuleFileName(NULL, g_szSysprepPath, AS(g_szSysprepPath));
|
|
if ( GetFullPathName(g_szSysprepPath, AS(g_szSysprepDir), g_szSysprepDir, &lpFilePart) && g_szSysprepDir[0] && lpFilePart )
|
|
{
|
|
// Chop off the file name.
|
|
//
|
|
*lpFilePart = NULLCHR;
|
|
}
|
|
|
|
// If either of those file, we must quit (can't imagine that every happening).
|
|
//
|
|
if ( ( g_szSysprepPath[0] == NULLCHR ) || ( g_szSysprepDir[0] == NULLCHR ) )
|
|
{
|
|
// TODO: Log this failure.
|
|
//
|
|
// LogFile(WINBOM_LOGFILE, _T("\n"));
|
|
return 0;
|
|
}
|
|
|
|
// Need the full path to the log file.
|
|
//
|
|
StringCchCopy ( g_szLogFile, AS ( g_szLogFile ), g_szSysprepDir);
|
|
AddPath(g_szLogFile, SYSPREP_LOG);
|
|
|
|
// Attempt to aquire a lock on the application
|
|
//
|
|
if ( !LockApplication(TRUE) )
|
|
{
|
|
// Let the user know that we are busy
|
|
//
|
|
|
|
MessageBoxFromMessage( MSG_ALREADY_RUNNING,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONINFORMATION | MB_SYSTEMMODAL );
|
|
return 0;
|
|
|
|
}
|
|
|
|
//
|
|
// Check to see if we are allowed to run on this build of the OS
|
|
//
|
|
if ( !OpklibCheckVersion( VER_PRODUCTBUILD, VER_PRODUCTBUILD_QFE ) )
|
|
{
|
|
MessageBoxFromMessage( MSG_NOT_ALLOWED,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_SYSTEMMODAL );
|
|
return 0;
|
|
}
|
|
|
|
// Ensure that the user has privilege/access to run this app.
|
|
if(!pSetupIsUserAdmin()
|
|
|| !pSetupDoesUserHavePrivilege(SE_SHUTDOWN_NAME)
|
|
|| !pSetupDoesUserHavePrivilege(SE_BACKUP_NAME)
|
|
|| !pSetupDoesUserHavePrivilege(SE_RESTORE_NAME)
|
|
|| !pSetupDoesUserHavePrivilege(SE_SYSTEM_ENVIRONMENT_NAME))
|
|
{
|
|
|
|
MessageBoxFromMessage( MSG_NOT_AN_ADMINISTRATOR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
|
|
LockApplication(FALSE);
|
|
return 0;
|
|
}
|
|
|
|
// Check the command line
|
|
if( !ParseCmdLine() )
|
|
{
|
|
LockApplication(FALSE);
|
|
return 0;
|
|
}
|
|
|
|
// Determines whether we can run SidGen. If not quit the application
|
|
//
|
|
// Make sure setupcl.exe is present in the system32 directory, if we need
|
|
// to use it.
|
|
if( !(SetupClPresent = IsSetupClPresent()) && !NoSidGen )
|
|
{
|
|
MessageBoxFromMessage( MSG_NO_SUPPORT,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
|
|
LockApplication(FALSE);
|
|
return 1;
|
|
}
|
|
|
|
// Put up a dialog to identify ourselves and make sure the user
|
|
// really wants to do this.
|
|
|
|
if ( IDCANCEL == MessageBoxFromMessage( MSG_IDENTIFY_SYSPREP,
|
|
AppTitleStringId,
|
|
MB_OKCANCEL| MB_ICONEXCLAMATION | MB_SYSTEMMODAL )
|
|
)
|
|
{
|
|
LockApplication(FALSE);
|
|
return 0;
|
|
}
|
|
|
|
// Allocate memory for window
|
|
//
|
|
if ( (lpAppName = AllocateString(NULL, IDS_APPNAME)) && *lpAppName )
|
|
{
|
|
ghwndOemResetDlg = FindWindow(NULL, lpAppName);
|
|
|
|
// Free up the allocated memory
|
|
//
|
|
FREE(lpAppName);
|
|
}
|
|
|
|
DisableScreenSaver(&gbScreenSaver);
|
|
|
|
//
|
|
// Call RenameWinbom() once to initialize it. First time it is called it will check the factory
|
|
// state registry key for the current winbom.ini that we are using. The second time it gets called it
|
|
// will actually perform the rename if necessary. Make sure that the first time this gets called
|
|
// for intialization it is before LocateWinBom() because LocateWinBom() populates the registry with
|
|
// the winbom it finds.
|
|
//
|
|
RenameWinbom();
|
|
|
|
// Need full path to winbom too. It is not an error if the file is
|
|
// not found. (It is optional.)
|
|
//
|
|
LocateWinBom(g_szWinBOMPath, AS(g_szWinBOMPath), g_szSysprepDir, INI_VAL_WBOM_TYPE_FACTORY, LOCATE_NORMAL);
|
|
|
|
// Process switches
|
|
//
|
|
if ( !FProcessSwitches() && !ghwndOemResetDlg)
|
|
{
|
|
ShowOemresetDialog(hInstance);
|
|
}
|
|
|
|
EnableScreenSaver(&gbScreenSaver);
|
|
|
|
// Unlock application and free up memory
|
|
//
|
|
LockApplication(FALSE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Factory Preinstall now also prepares the machine
|
|
//
|
|
BOOL FDoFactoryPreinstall()
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwVal;
|
|
|
|
if (!IsFactoryPresent()) {
|
|
MessageBoxFromMessage( MSG_NO_FACTORYEXE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// Setup factory.exe for factory floor
|
|
//
|
|
if (!SetupForFactoryFloor())
|
|
{
|
|
MessageBoxFromMessage( MSG_SETUPFACTORYFLOOR_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// Prepare machine to be hardware independent for factory floor
|
|
//
|
|
if (!FPrepareMachine()) {
|
|
MessageBoxFromMessage( MSG_REGISTRY_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
return FALSE;
|
|
}
|
|
|
|
// Set the boot timeout for boot on factory floor
|
|
if (!ChangeBootTimeout( 1 ))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Prepares the machine to be hardware independent
|
|
//
|
|
BOOL FPrepareMachine()
|
|
{
|
|
TCHAR szSysprepInf[MAX_PATH] = TEXT("");
|
|
|
|
//
|
|
// Make sure we've got the required privileges to update the registry.
|
|
//
|
|
pSetupEnablePrivilege(SE_RESTORE_NAME,TRUE);
|
|
pSetupEnablePrivilege(SE_BACKUP_NAME,TRUE);
|
|
|
|
// Build path to sysprep.inf from where sysprep.exe is located
|
|
//
|
|
if (GetModuleFileName(NULL, szSysprepInf, MAX_PATH))
|
|
{
|
|
PathRemoveFileSpec(szSysprepInf);
|
|
OPKAddPathN(szSysprepInf, TEXT("sysprep.inf"), AS ( szSysprepInf ) );
|
|
}
|
|
|
|
// Disable System Restore
|
|
//
|
|
DisableSR();
|
|
|
|
// Make sure we're not a member of a domain. If we are, then try and
|
|
// force the unjoin.
|
|
//
|
|
|
|
if( !UnjoinNetworkDomain())
|
|
{
|
|
// We failed to disjoin. Our only option is to
|
|
// inform the user and bail.
|
|
MessageBoxFromMessage( MSG_DOMAIN_INCOMPATIBILITY,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
return FALSE;
|
|
}
|
|
|
|
#if !defined(_WIN64)
|
|
// Set the boot disk signature in the registry. The mount manager uses this
|
|
// to avoid a PNP pop-up after imaging.
|
|
//
|
|
if ( !SaveDiskSignature() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
#endif // !defined(_WIN64)
|
|
|
|
// Determine if we should set the BigLba support in registry
|
|
//
|
|
if ( !SetBigLbaSupport(szSysprepInf) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Determine if we should remove the tapi settings
|
|
//
|
|
if ( !RemoveTapiSettings(szSysprepInf) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Set OEMDuplicatorString
|
|
if (!SetOEMDuplicatorString(szSysprepInf))
|
|
return FALSE;
|
|
|
|
|
|
// If we want to regenerate the SID's on the next boot do it.
|
|
//
|
|
if ( NoSidGen )
|
|
{
|
|
// Remember that we didn't generate SIDs
|
|
//
|
|
RegSetDword(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_SIDGEN, 0);
|
|
}
|
|
else
|
|
{
|
|
if ( PrepForSidGen() )
|
|
{
|
|
// Write out registry value so that we know that we've regenerated SIDs.
|
|
//
|
|
RegSetDword(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_SIDGEN, 1);
|
|
|
|
// Set this registry key, only UpdateSecurityKeys can remove this key
|
|
//
|
|
RegSetDword(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_SIDGENHISTORY, 1);
|
|
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// If Mass Storage Devices were installed, clean up the ones not being used.
|
|
// Note: We only want to CleanUpDevices() if we are resealing. This is the equivalent of
|
|
// automatically running "sysprep -clean" on reseal if we know that we need to do it.
|
|
//
|
|
if ( RegCheck(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_MASS_STORAGE))
|
|
{
|
|
if ( Reseal )
|
|
{
|
|
// Clean the critical device database, since we might have put some
|
|
// HDC and network drivers in there during factory floor from PopulateDeviceDatabase()
|
|
CleanUpDevices();
|
|
|
|
// Remove this key because we just ran CleanUpDevices().
|
|
//
|
|
RegDelete(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_MASS_STORAGE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL fPopulated = FALSE;
|
|
|
|
// Set up Hardware independence for mass storage controllers.
|
|
//
|
|
BuildMassStorageSection(FALSE);
|
|
|
|
if (!PopulateDeviceDatabase(&fPopulated))
|
|
return FALSE;
|
|
|
|
// Write out signature value to know that we have built the mass-storage section.
|
|
//
|
|
if ( fPopulated && !RegSetDword(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_MASS_STORAGE, 1) )
|
|
return FALSE;
|
|
}
|
|
|
|
// Remove network settings/card last so any errors during Device Database won't loose
|
|
// networking.
|
|
//
|
|
if (!RemoveNetworkSettings(szSysprepInf))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Reseal and Factory should behave the same according to the shutdown path.
|
|
//
|
|
void DoShutdownTypes()
|
|
{
|
|
pSetupEnablePrivilege(SE_SHUTDOWN_NAME,TRUE);
|
|
|
|
if (Reboot)
|
|
ExitWindowsEx(EWX_REBOOT|EWX_FORCE, SYSPREP_SHUTDOWN_FLAGS);
|
|
else if (NoReboot)
|
|
PostQuitMessage(0);
|
|
else
|
|
PowerOff(ForceShutdown); // Default
|
|
}
|
|
|
|
// Process action switches return TRUE if processed
|
|
//
|
|
BOOL FProcessSwitches()
|
|
{
|
|
// There are currently 4 basic operating modes for SYSPREP:
|
|
|
|
// 1) Factory floor mode. This mode is new for Whistler and will not completly
|
|
// clone the system, but will prep the system for OEM factory floor installation
|
|
// 2) Clean mode. In this mode, sysprep will clean up the critical device database
|
|
// 3) Reseal mode. This is the complement to factory mode which will "complete" the
|
|
// cloning process after factory floor mode has been used.
|
|
// 4) "Audit" mode. The system just executes an audit boot. Used to restart the system
|
|
// at the end of factory.exe processing.
|
|
|
|
// These are just flags for reseal
|
|
//
|
|
if (Reseal)
|
|
{
|
|
StartWaitThread();
|
|
// Ensure that we're running on the right OS.
|
|
//
|
|
if( !CheckOSVersion() )
|
|
{
|
|
MessageBoxFromMessage( MSG_OS_INCOMPATIBILITY,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
return TRUE;
|
|
}
|
|
|
|
// Reseal the machine
|
|
//
|
|
if (!ResealMachine()) {
|
|
MessageBoxFromMessage( MSG_RESEAL_ERROR,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONSTOP | MB_TASKMODAL );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
// Rename the current winbom so we don't use it again.
|
|
//
|
|
RenameWinbom();
|
|
|
|
// Shutdown or reboot?
|
|
DoShutdownTypes();
|
|
|
|
EndWaitThread();
|
|
return TRUE;
|
|
}
|
|
else if (Factory)
|
|
{
|
|
StartWaitThread();
|
|
|
|
// Set Factory to start on next boot and prepare for imaging
|
|
//
|
|
if (!FDoFactoryPreinstall())
|
|
return TRUE;
|
|
|
|
// Rename the current winbom so we don't use it again.
|
|
//
|
|
RenameWinbom();
|
|
|
|
// Shutdown or reboot?
|
|
DoShutdownTypes();
|
|
|
|
EndWaitThread();
|
|
|
|
return TRUE;
|
|
}
|
|
else if (Clean)
|
|
{
|
|
CleanUpDevices();
|
|
|
|
// Remove this key because we just ran CleanUpDevices().
|
|
//
|
|
RegDelete(HKLM, REGSTR_PATH_SYSPREP, REGSTR_VAL_MASS_STORAGE);
|
|
return TRUE;
|
|
}
|
|
else if (Audit)
|
|
{
|
|
// Prepare for pseudo factory but get back to audit.
|
|
//
|
|
if ( RegCheck(HKLM, REGSTR_PATH_SYSTEM_SETUP, REGSTR_VALUE_AUDIT) )
|
|
{
|
|
TCHAR szFactoryPath[MAX_PATH] = NULLSTR;
|
|
// Going into Audit mode requires Factory.exe and winbom.ini
|
|
// to exist.
|
|
//
|
|
if (FGetFactoryPath(szFactoryPath)) {
|
|
SetFactoryStartup(szFactoryPath);
|
|
DoShutdownTypes();
|
|
}
|
|
else {
|
|
LogFile(g_szLogFile, MSG_NO_FACTORYEXE);
|
|
|
|
MessageBoxFromMessage( MSG_NO_FACTORYEXE,
|
|
IDS_APPTITLE,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogFile(g_szLogFile, IDS_ERR_FACTORYMODE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
else if (BuildMSD)
|
|
{
|
|
StartWaitThread();
|
|
BuildMassStorageSection(TRUE /* Force build */);
|
|
EndWaitThread();
|
|
return TRUE;
|
|
}
|
|
|
|
// Return False to show the UI
|
|
//
|
|
Reseal = Factory = Clean = Audit = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL LockApplication(BOOL bState)
|
|
{
|
|
static HANDLE hMutex;
|
|
BOOL bReturn = FALSE,
|
|
bBail = FALSE;
|
|
DWORD dwSleepCount = 0;
|
|
|
|
// We want to lock the application
|
|
//
|
|
if ( bState )
|
|
{
|
|
// Check to see if we can create the mutex and that the mutex did not
|
|
// already exist
|
|
//
|
|
while ( !bReturn && (dwSleepCount < SYSPREP_LOCK_SLEEP_COUNT) && !bBail)
|
|
{
|
|
SetLastError(ERROR_SUCCESS);
|
|
|
|
if ( hMutex = CreateMutex(NULL, FALSE, SYSPREP_MUTEX) )
|
|
{
|
|
if ( GetLastError() == ERROR_ALREADY_EXISTS )
|
|
{
|
|
CloseHandle(hMutex);
|
|
hMutex = NULL;
|
|
|
|
dwSleepCount++;
|
|
Sleep(SYSPREP_LOCK_SLEEP);
|
|
}
|
|
else
|
|
{
|
|
// Application successfully created lock
|
|
//
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bBail = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if ( hMutex )
|
|
{
|
|
CloseHandle(hMutex);
|
|
hMutex = NULL;
|
|
bReturn = TRUE;
|
|
}
|
|
|
|
// Return whether or not the lock/unlock was successful
|
|
//
|
|
return bReturn;
|
|
}
|
|
|
|
//
|
|
// Shutdown or Reboot the machine
|
|
//
|
|
VOID ShutdownOrReboot(UINT uFlags, DWORD dwReserved)
|
|
{
|
|
// Enable privileges for shutdown
|
|
//
|
|
EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
|
|
|
|
// Shutdown or Reboot the machine
|
|
//
|
|
ExitWindowsEx(uFlags|EWX_FORCE, dwReserved);
|
|
}
|
|
|
|
// Remember the Screen Saver state and to disable it during Sysprep
|
|
//
|
|
void DisableScreenSaver(BOOL *pScreenSaver)
|
|
{
|
|
SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, (PVOID)pScreenSaver, 0);
|
|
if (*pScreenSaver == TRUE)
|
|
{
|
|
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, 0, SPIF_SENDWININICHANGE);
|
|
}
|
|
}
|
|
|
|
// Remember the Screen Saver state and to re-enable it after Sysprep
|
|
//
|
|
void EnableScreenSaver(BOOL *pScreenSaver)
|
|
{
|
|
if (*pScreenSaver == TRUE)
|
|
{
|
|
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, 0, SPIF_SENDWININICHANGE);
|
|
}
|
|
}
|
|
|
|
// Rename the old winbom when going into factory or reseal so that we don't use it again by mistake.
|
|
static BOOL RenameWinbom()
|
|
{
|
|
BOOL bRet = TRUE;
|
|
static LPTSTR lpszWinbom = NULL;
|
|
static BOOL bInitialized = FALSE;
|
|
|
|
if ( !bInitialized )
|
|
{
|
|
// Only bother to try if we are in audit mode and there
|
|
// is a winbom in use.
|
|
//
|
|
if ( RegCheck(HKLM, _T("SYSTEM\\Setup"), _T("AuditInProgress")) )
|
|
{
|
|
lpszWinbom = RegGetExpand(HKLM, _T("SOFTWARE\\Microsoft\\Factory\\State"), _T("Winbom"));
|
|
}
|
|
|
|
bInitialized = TRUE;
|
|
}
|
|
else if ( lpszWinbom )
|
|
{
|
|
// Make sure the winbom in the registry exists.
|
|
//
|
|
if ( *lpszWinbom && FileExists(lpszWinbom) )
|
|
{
|
|
LPTSTR lpszExtension;
|
|
TCHAR szBackup[MAX_PATH];
|
|
DWORD dwExtra;
|
|
|
|
// At this point, if we don't rename the file then it
|
|
// means there was an error.
|
|
//
|
|
bRet = FALSE;
|
|
|
|
// Copy the full path to the winbom into our own buffer.
|
|
//
|
|
lstrcpyn(szBackup, lpszWinbom, AS(szBackup));
|
|
|
|
// Get a pointer to the extension of the file name.
|
|
//
|
|
if ( lpszExtension = StrRChr(szBackup, NULL, _T('.')) )
|
|
{
|
|
// Set the extension pointer to after the '.' character.
|
|
//
|
|
lpszExtension = CharNext(lpszExtension);
|
|
|
|
// See how many characters are in the current extension.
|
|
//
|
|
if ( (dwExtra = lstrlen(lpszExtension)) < 3 )
|
|
{
|
|
// There is less then a 3 character extension, so
|
|
// we need some extra space for our 3 digit one.
|
|
//
|
|
dwExtra = 3 - dwExtra;
|
|
}
|
|
else
|
|
{
|
|
// If there are already at least 3 characters in
|
|
// the exension, then no more space is required.
|
|
//
|
|
dwExtra = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No extension, so we need 4 characters extra for
|
|
// the '.' and the 3 digit extension.
|
|
//
|
|
dwExtra = 4;
|
|
}
|
|
|
|
// Make sure there is enough room for our extension to be
|
|
// added to our buffer.
|
|
//
|
|
if ( ( lstrlen(lpszWinbom) < AS(szBackup) ) &&
|
|
( lstrlen(szBackup) + dwExtra < AS(szBackup) ) )
|
|
{
|
|
DWORD dwNum = 0;
|
|
|
|
// If there is no extension, add the dot.
|
|
//
|
|
if ( NULL == lpszExtension )
|
|
{
|
|
// Add our '.' to the end of the string, and set the
|
|
// extension pointer past it.
|
|
//
|
|
lpszExtension = szBackup + lstrlen(szBackup);
|
|
*lpszExtension = _T('.');
|
|
lpszExtension = CharNext(lpszExtension);
|
|
}
|
|
|
|
// Try to find out new file name. Keep increasing our
|
|
// number from 000 until we find a name that doesn't exist.
|
|
//
|
|
do
|
|
{
|
|
StringCchPrintf ( lpszExtension, AS ( szBackup ) - ( szBackup - lpszExtension), _T("%3.3d"), dwNum);
|
|
}
|
|
while ( ( FileExists(szBackup) ) &&
|
|
( ++dwNum < 1000 ) );
|
|
|
|
// If we found a name that doesn't exist, rename
|
|
// the winbom.
|
|
//
|
|
if ( dwNum < 1000 )
|
|
{
|
|
// If the move works, then return success.
|
|
//
|
|
bRet = MoveFile(lpszWinbom, szBackup);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free the buffer allocated.
|
|
//
|
|
FREE(lpszWinbom);
|
|
}
|
|
|
|
// Return TRUE if we didn't need to rename the winbom,
|
|
// or we were able to do so successfully.
|
|
//
|
|
return bRet;
|
|
}
|
|
|
|
#if !defined(_WIN64)
|
|
|
|
static BOOL SaveDiskSignature()
|
|
{
|
|
BOOL bRet = FALSE;
|
|
WCHAR szBuf[MAX_PATH] = NULLSTR;
|
|
HANDLE hDisk;
|
|
DWORD dwBytesReturned = 0;
|
|
TCHAR cDriveLetter;
|
|
|
|
szBuf[0] = NULLCHR;
|
|
if ( GetWindowsDirectory(szBuf, AS(szBuf)) && szBuf[0] )
|
|
{
|
|
// We only need the drive letter from this.
|
|
cDriveLetter = szBuf[0];
|
|
StringCchPrintf ( szBuf, AS ( szBuf ), _T("\\\\.\\%c:"), cDriveLetter);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Attempt to open the file
|
|
//
|
|
hDisk = CreateFile( szBuf,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
// Check to see if we were able to open the disk
|
|
//
|
|
if ( INVALID_HANDLE_VALUE == hDisk )
|
|
{
|
|
bRet = FALSE;
|
|
DbgPrint("SaveDiskSignature(): Unable to open file on %ws. Error (%lx)\n", szBuf, GetLastError());
|
|
}
|
|
else
|
|
{
|
|
PDRIVE_LAYOUT_INFORMATION_EX pLayoutInfoEx = NULL;
|
|
ULONG lengthLayoutEx = 0;
|
|
|
|
DbgPrint("SaveDiskSignature(): Successfully opened file on %ws\n", szBuf);
|
|
|
|
lengthLayoutEx = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (sizeof(PARTITION_INFORMATION_EX) * 128);
|
|
pLayoutInfoEx = (PDRIVE_LAYOUT_INFORMATION_EX) MALLOC( lengthLayoutEx );
|
|
|
|
if ( pLayoutInfoEx )
|
|
{
|
|
// Attempt to get the drive layout
|
|
//
|
|
bRet = DeviceIoControl( hDisk,
|
|
IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
|
|
NULL,
|
|
0,
|
|
pLayoutInfoEx,
|
|
lengthLayoutEx,
|
|
&dwBytesReturned,
|
|
NULL
|
|
);
|
|
|
|
// Check the status of the drive layout
|
|
//
|
|
if ( bRet )
|
|
{ // Only do this on MBR disks
|
|
//
|
|
if ( PARTITION_STYLE_MBR == pLayoutInfoEx->PartitionStyle )
|
|
{
|
|
// Only set this value on MBR disks.
|
|
//
|
|
if ( !RegSetDword(HKEY_LOCAL_MACHINE, REGSTR_PATH_SYSTEM_SETUP, REGSTR_VAL_DISKSIG, pLayoutInfoEx->Mbr.Signature) )
|
|
{
|
|
DbgPrint("SaveDiskSignature(): Cannot write disk signature to registry\n.");
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{ // bRet = TRUE at this point.
|
|
DbgPrint("SaveDiskSignature(): Not supported on GPT disks.\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DbgPrint("SaveDiskSignature(): Unable to open IOCTL on %ws. Error (%lx)\n", szBuf, GetLastError());
|
|
}
|
|
|
|
// Clean up. Macro checks for NULL;
|
|
//
|
|
FREE( pLayoutInfoEx );
|
|
}
|
|
else
|
|
{
|
|
bRet = FALSE;
|
|
}
|
|
|
|
CloseHandle( hDisk );
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
#endif // !defined(_WIN64)
|
|
|
|
|
|
//
|
|
// Helper function for CleanupPhantomDevices. Decides whether it is ok to remove
|
|
// certain PNP devices.
|
|
//
|
|
BOOL
|
|
CanDeviceBeRemoved(
|
|
HDEVINFO DeviceInfoSet,
|
|
PSP_DEVINFO_DATA DeviceInfoData,
|
|
PTSTR DeviceInstanceId
|
|
)
|
|
{
|
|
BOOL bCanBeRemoved = TRUE;
|
|
|
|
if (_tcsicmp(DeviceInstanceId, TEXT("HTREE\\ROOT\\0")) == 0) {
|
|
//
|
|
// The device has the DeviceInstanceId of HTREE\ROOT\0 then it is the
|
|
// root of the device tree and can NOT be removed!
|
|
//
|
|
bCanBeRemoved = FALSE;
|
|
} else if (_tcsnicmp(DeviceInstanceId, TEXT("SW\\"), lstrlen(TEXT("SW\\"))) == 0) {
|
|
//
|
|
// If the DeviceInstanceId starts with SW\\ then it is a swenum (software
|
|
// enumerated) device and should not be removed.
|
|
//
|
|
bCanBeRemoved = FALSE;
|
|
} else if (IsEqualGUID(&(DeviceInfoData->ClassGuid), &GUID_DEVCLASS_LEGACYDRIVER)) {
|
|
//
|
|
// If the device is of class GUID_DEVCLASS_LEGACYDRIVER then do not
|
|
// uninstall it.
|
|
//
|
|
bCanBeRemoved = FALSE;
|
|
}
|
|
|
|
return bCanBeRemoved;
|
|
}
|
|
|
|
|
|
//
|
|
// Cleans up phantom PNP devices. This is useful for cleaning up devices that existed
|
|
// on the machine that was imaged but do not exist on the target machine.
|
|
//
|
|
static INT
|
|
CleanupPhantomDevices(
|
|
VOID
|
|
)
|
|
{
|
|
HDEVINFO DeviceInfoSet;
|
|
HDEVINFO InterfaceDeviceInfoSet;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
|
|
INT DevicesRemoved = 0;
|
|
INT MemberIndex, InterfaceMemberIndex;
|
|
DWORD Status, Problem;
|
|
CONFIGRET cr;
|
|
TCHAR DeviceInstanceId[MAX_DEVICE_ID_LEN];
|
|
|
|
//
|
|
// Get a list of all the devices on this machine, including present (live)
|
|
// and not present (phantom) devices.
|
|
//
|
|
DeviceInfoSet = SetupDiGetClassDevs(NULL,
|
|
NULL,
|
|
NULL,
|
|
DIGCF_ALLCLASSES
|
|
);
|
|
|
|
if (DeviceInfoSet != INVALID_HANDLE_VALUE) {
|
|
|
|
DeviceInfoData.cbSize = sizeof(DeviceInfoData);
|
|
MemberIndex = 0;
|
|
|
|
//
|
|
// Enumerate through the list of devices.
|
|
//
|
|
while (SetupDiEnumDeviceInfo(DeviceInfoSet,
|
|
MemberIndex++,
|
|
&DeviceInfoData
|
|
)) {
|
|
|
|
//
|
|
// Check if this device is a Phantom
|
|
//
|
|
cr = CM_Get_DevNode_Status(&Status,
|
|
&Problem,
|
|
DeviceInfoData.DevInst,
|
|
0
|
|
);
|
|
|
|
if ((cr == CR_NO_SUCH_DEVINST) ||
|
|
(cr == CR_NO_SUCH_VALUE)) {
|
|
|
|
//
|
|
// This is a phantom. Now get the DeviceInstanceId so we
|
|
// can display/log this as output.
|
|
//
|
|
if (SetupDiGetDeviceInstanceId(DeviceInfoSet,
|
|
&DeviceInfoData,
|
|
DeviceInstanceId,
|
|
sizeof(DeviceInstanceId)/sizeof(TCHAR),
|
|
NULL)) {
|
|
|
|
if (CanDeviceBeRemoved(DeviceInfoSet,
|
|
&DeviceInfoData,
|
|
DeviceInstanceId)) {
|
|
|
|
|
|
#ifdef DEBUG_LOGLOG
|
|
LOG_Write(L"CLEANUP: %s will be removed.\n", DeviceInstanceId);
|
|
#endif
|
|
//
|
|
// Call DIF_REMOVE to remove the device's hardware
|
|
// and software registry keys.
|
|
//
|
|
if (SetupDiCallClassInstaller(DIF_REMOVE,
|
|
DeviceInfoSet,
|
|
&DeviceInfoData
|
|
)) {
|
|
DevicesRemoved++;
|
|
|
|
} else {
|
|
#ifdef DEBUG_LOGLOG
|
|
LOG_Write(L"CLEANUP: Error 0x%X removing phantom\n", GetLastError());
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
|
|
}
|
|
|
|
return DevicesRemoved;
|
|
}
|
|
|
|
|
|
// Cleans unused services and phantom PNP devices.
|
|
//
|
|
static VOID CleanUpDevices()
|
|
{
|
|
// Cleanup the services that we installed in the [SysprepMassStorage] section.
|
|
//
|
|
CleanDeviceDatabase();
|
|
|
|
// Cleanup phantom devices.
|
|
//
|
|
CleanupPhantomDevices();
|
|
}
|