windows-xp/Source/XPSP1/NT/base/ntsetup/opktools/sysprep/sysprep.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();
}