windows-xp/Source/XPSP1/NT/base/ntsetup/opktools/factory/winbom.c

/*++

Copyright (c) 1995 Microsoft Corporation

Module Name:

    winbom.c

Abstract:

    Process the WinBOM (Windows Bill-of-Materials) file during OEM/SB pre-installation.
    
    Task performed will be:
        Download updated device drivers from NET
        Process OOBE info
        Process User/Customer specific settings
        Process OEM user specific customization
        Process Application pre-installations
    

Author:

    Donald McNamara (donaldm) 2/8/2000

Revision History:

    - Added preinstall support to ProcessWinBOM: Jason Lawrence (t-jasonl) 6/7/2000

--*/
#include "factoryp.h"


//
// Defined Value(s):
//

// Time out in milliseconds to wait for the dialog thread to finish.
//
#define DIALOG_WAIT_TIMEOUT     2000


//
// Internal Function Prototype(s):
//

static BOOL SetRunKey(BOOL bSet, LPDWORD lpdwTickCount);


/*++
===============================================================================
Routine Description:

    BOOL ProcessWinBOM
    
    This routine will process all sections of the WinBOM

Arguments:

    lpszWinBOMPath  -   Buffer containing the fully qualified path to the WINBOM
                        file
    lpStates        -   Array of states that will be processed.
    cbStates        -   Number of states in the states array.
    
Return Value:

    TRUE if no errors were encountered
    FALSE if there was an error

===============================================================================
--*/

BOOL ProcessWinBOM(LPTSTR lpszWinBOMPath, LPSTATES lpStates, DWORD cbStates)
{
    STATE           stateCurrent,
                    stateStart      = stateUnknown;
    LPSTATES        lpState;
    STATEDATA       stateData;
    BOOL            bQuit,
                    bErr            = FALSE,
                    bLoggedOn       = GET_FLAG(g_dwFactoryFlags, FLAG_LOGGEDON),
                    bServer         = IsServer(),
                    bPerf           = GET_FLAG(g_dwFactoryFlags, FLAG_LOG_PERF),
                    bStatus         = !GET_FLAG(g_dwFactoryFlags, FLAG_NOUI),
                    bInit;
    HKEY            hKey;
    HWND            hwndStatus      = NULL;
    DWORD           dwForReal,
                    dwStates,
                    dwStatus        = 0;
    LPSTATUSNODE    lpsnTemp        = NULL;

    // Get the current state from the registry.
    //
    if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_FACTORY_STATE, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS )
    {
        DWORD   dwType  = REG_DWORD,
                dwValue = 0,
                cbValue = sizeof(DWORD);

        if ( RegQueryValueEx(hKey, _T("CurrentState"), NULL, &dwType, (LPBYTE) &dwValue, &cbValue) == ERROR_SUCCESS )
        {
            stateStart = (STATE) dwValue;
        }
    
        RegCloseKey(hKey);
    }

    // Set the static state data.
    //
    stateData.lpszWinBOMPath = lpszWinBOMPath;

    // We loop through the states twice.  The first time is just
    // a quick run through to see what states to add to the status
    // dialog.  The second time is the "real" time when we actually
    // run each state.
    //
    for ( dwForReal = 0; dwForReal < 2; dwForReal++ )
    {
        // Reset these guys every time.
        //
        bInit           = TRUE;
        bQuit           = FALSE,
        dwStates        = cbStates;
        lpState         = lpStates;
        stateCurrent    = stateStart;

        // If this is the real thing we need to handle the status dialog stuff.
        //
        if ( dwForReal )
        {
            // Create the dialog if we want to display the UI.
            //
            if ( bStatus && dwStatus )
            {
                STATUSWINDOW swAppList;

                // Start by zeroing out the structure.
                //
                ZeroMemory(&swAppList, sizeof(swAppList));

                // Now copy the title into the structure.
                //
                if ( swAppList.lpszDescription = AllocateString(NULL, IDS_APPTITLE) )
                {
                    lstrcpyn(swAppList.szWindowText, swAppList.lpszDescription, AS(swAppList.szWindowText));
                    FREE(swAppList.lpszDescription);
                }

                // Get the description string.
                //
                swAppList.lpszDescription = AllocateString(NULL, IDS_STATUS_DESC);

                // Load the main icon for the status window.
                //
                swAppList.hMainIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_FACTORYPRE));

                // Set the screen cordinates for the status window.
                //
                swAppList.X = -10;
                swAppList.Y = 10;

                // Now actually create the status window.
                //
                hwndStatus = StatusCreateDialog(&swAppList, lpsnTemp);

                // Clean up any allocated memory.
                //
                FREE(swAppList.lpszDescription);
            }

            // Delete the node list as we don't need it anymore
            // because the status window is already displayed.
            //
            if ( lpsnTemp )
            {
                StatusDeleteNodes(lpsnTemp);
            }
        }

        // Process WINBOM states, until we reach the finished state.
        //
        do
        {
            // Set or advance to the next state.
            //
            if ( bInit )
            {
                // Now if we are logged on, we need to advance to that state.
                //
                if ( bLoggedOn )
                {
                    while ( dwStates && ( lpState->state != stateLogon ) )
                    {
                        lpState++;
                        dwStates--;
                    }
                }

                // If we don't know the current state, set it to the first one.
                //
                if ( stateCurrent == stateUnknown )
                {
                    stateCurrent = lpState->state;
                }

                // Make sure we don't do the init code again.
                //
                bInit = FALSE;
            }
            else
            {
                if ( stateCurrent == lpState->state )
                {
                    // Advance and save the current state.
                    //
                    stateCurrent = (++lpState)->state;

                    // Set the current state in the registry (only if doing this for real).
                    //
                    if ( dwForReal && ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_FACTORY_STATE, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS ) )
                    {
                        RegSetValueEx(hKey, _T("CurrentState"), 0, REG_DWORD, (LPBYTE) &stateCurrent, sizeof(DWORD));
                        RegCloseKey(hKey);
                    }
                }
                else
                {
                    // Just advanced to the next state.
                    //
                    lpState++;
                }
            }

            // Decrement our size counter to make sure we don't go past
            // the end of our array.
            //
            dwStates--;

            // Only execute this state if it isn't a one time only state or
            // our current state is the same one we are about to execute.
            //
            // Also don't execute this state if we are running on server and
            // it should not be.
            //
            if ( ( !GET_FLAG(lpState->dwFlags, FLAG_STATE_ONETIME) || ( stateCurrent == lpState->state ) ) &&
                 ( !GET_FLAG(lpState->dwFlags, FLAG_STATE_NOTONSERVER) || ( !bServer ) ) )
            {
                // First reset any state data in the structure
                // that might be left over from a previous state call.
                //
                stateData.state = lpState->state;
                stateData.bQuit = FALSE;

                // If this is for real, then do the state stuff.
                //
                if ( dwForReal )
                {
                    LPTSTR  lpStateText;
                    BOOL    bStateErr       = FALSE,
                            bSwitchCode     = TRUE;
                    DWORD   dwTickStart     = 0,
                            dwTickFinish    = 0;

                    // Get the friendly name for the state if there is one.
                    //
                    lpStateText = lpState->nFriendlyName ? AllocateString(NULL, lpState->nFriendlyName) : NULL;

                    // Log that we are starting this state (special case the log on case becase
                    // we don't want to log that we are starting it twice.
                    //
                    if ( ( lpStateText ) && 
                         ( !bLoggedOn || ( stateLogon != lpState->state ) ) )
                    {
                        FacLogFile(2, IDS_LOG_STARTINGSTATE, lpStateText);
                    }

                    // Get the starting tick count.
                    //
                    dwTickStart = GetTickCount();

                    // See if the state has a function.
                    //
                    if ( lpState->statefunc )
                    {                
                        // Run the state function.
                        //
                        bStateErr = !lpState->statefunc(&stateData);

                        // Get the finish tick count.
                        //
                        dwTickFinish = GetTickCount();
                    }

                    // Jump to the code for this state if there is one.  We should avoid
                    // putting code here.  For now just the logon and finish states are
                    // in the switch statement because they are very simple and crucial
                    // to how the state loop works.  All the other states just do some
                    // work that we don't care about or need to have any knowledge of.
                    //
                    switch ( lpState->state )
                    {
                        case stateLogon:

                            // If we haven't logged on yet, we need to quit when we get to this state.
                            //
                            if ( !bLoggedOn )
                            {
                                // Set the run key so we get kicked off again after we log on.
                                //
                                bStateErr = !SetRunKey(TRUE, &dwTickStart);
                                bQuit = TRUE;

                                // Don't want to log the perf yet, so set these to FALSE and zero.
                                //
                                bSwitchCode = FALSE;
                                dwTickFinish = 0;
                            }
                            else
                            {
                                // Clear the run keys and get the original tick count.
                                //
                                if ( ( bStateErr = !SetRunKey(FALSE, &dwTickStart) ) &&
                                     ( 0 == dwTickStart ) )
                                {
                                    // If for some reason we were not able to get the tick count
                                    // from the registry, just set these to FALSE and zero so
                                    // we don't try to log the perf.
                                    //
                                    bSwitchCode = FALSE;
                                    dwTickFinish = 0;
                                }
                            }
                            break;

                        case stateFinish:

                            // Nothing should ever really go in the finished state.  We just
                            // set bQuit to true so we exit out.
                            //
                            bQuit = TRUE;
                            break;

                        default:
                            bSwitchCode = FALSE;
                    }

                    // Check if code in the switch statement was run.
                    //
                    if ( bSwitchCode )
                    {
                        // Get the finish tick count again.
                        //
                        dwTickFinish = GetTickCount();
                    }

                    // Log that we are finished with this state.
                    //
                    if ( lpStateText )
                    {
                        // Write out that we have finished this state (unless this is the
                        // first time for the logon state, we don't want to log that it finished
                        // twice unless there is an error the first time).
                        //
                        if ( bStateErr )
                        {
                            FacLogFile(0 | LOG_ERR, IDS_ERR_FINISHINGSTATE, lpStateText);
                        }
                        else if ( bLoggedOn || ( stateLogon != lpState->state ) )
                        {
                            FacLogFile(2, IDS_LOG_FINISHINGSTATE, lpStateText);
                        }

                        // See if we actually ran any code.
                        //
                        if ( dwTickFinish && bPerf )
                        {
                            // Calculate the difference in milleseconds.
                            //
                            if ( dwTickFinish >= dwTickStart )
                            {
                                dwTickFinish -= dwTickStart;
                            }
                            else
                            {
                                dwTickFinish += ( 0xFFFFFFFF - dwTickStart );
                            }

                            // Write out to the log the time this state took.
                            //
                            FacLogFile(0, IDS_LOG_STATEPERF, lpStateText, dwTickFinish / 1000, dwTickFinish - ((dwTickFinish / 1000) * 1000));
                        }

                        // Free the friendly name.
                        //
                        FREE(lpStateText);
                    }

                    // If there is status text, we should increment past it.
                    //
                    if ( hwndStatus && GET_FLAG(lpState->dwFlags, FLAG_STATE_DISPLAYED) )
                    {
                        StatusIncrement(hwndStatus, !bStateErr);
                    }

                    // Check to see if the state failed.
                    //
                    if ( bStateErr )
                    {
                        // State function failed, set the error var and see if we need
                        // to quit proccessing states.
                        //
                        bErr = TRUE;
                        if ( GET_FLAG(lpState->dwFlags, FLAG_STATE_QUITONERR) ||
                             GET_FLAG(g_dwFactoryFlags, FLAG_STOP_ON_ERROR) )
                        {
                            bQuit = TRUE;
                        }
                    }
                }
                else
                {
                    // Always reset the displayed flag first.
                    //
                    RESET_FLAG(lpState->dwFlags, FLAG_STATE_DISPLAYED);

                    // Only need to do more if we want to display the UI.
                    //
                    if ( bStatus )
                    {
                        LPTSTR lpszDisplay;

                        // Only if there is a friendly name can we display it.
                        //
                        if ( lpState->nFriendlyName && ( lpszDisplay = AllocateString(NULL, lpState->nFriendlyName) ) )
                        {
                            BOOL bDisplay;

                            // First use the state display function (if there is one) to figure out
                            // if this item is to be displayed or not.
                            //
                            // The function can set bQuit in the state structure just like when it actually
                            // runs.  We will catch this below and make this the last item in the list.
                            //
                            bDisplay = lpState->displayfunc ? lpState->displayfunc(&stateData) : FALSE;

                            // Jump to the display code for this state to see if it is really displayed
                            // or should be the last item in the list.  We should avoid putting code
                            // here.  For now just the logon and finish states are in the switch
                            // statement because they are very simple and crucial to how the state
                            // loop works for the display dialog.  All the other states make their own
                            // determination if they should be displayed or not.
                            //
                            switch ( lpState->state )
                            {
                                case stateLogon:

                                    // If we haven't logged on yet, we need to quit when we get to this state.
                                    //
                                    if ( !bLoggedOn )
                                    {
                                        // Set the quit so this is the last item listed before logon.
                                        //
                                        bQuit = TRUE;
                                    }
                                    else
                                    {
                                        // Not going to show this state after logon, only before.  We can change
                                        // this if we think we should show it as the first item after logon, but
                                        // it doesn't really matter.
                                        //
                                        bDisplay = FALSE;
                                    }
                                    break;

                                case stateFinish:

                                    // We just set the quit so we make sure and exit out.
                                    //
                                    bQuit = TRUE;
                                    break;
                            }

                            // Now check to see if we really want to display this state.
                            //
                            if ( bDisplay )
                            {
                                StatusAddNode(lpszDisplay, &lpsnTemp);
                                SET_FLAG(lpState->dwFlags, FLAG_STATE_DISPLAYED);
                                dwStatus++;
                            }

                            // Free the friendly name.
                            //
                            FREE(lpszDisplay);
                        }
                    }
                }

                // If they want to quit, set bQuit.
                //
                if ( stateData.bQuit )
                {
                    bQuit = TRUE;
                }
            }
        }
        while ( !bQuit && dwStates );
    }

    // If we created the status window, end it now.
    //
    if ( hwndStatus )
    {
        StatusEndDialog(hwndStatus);
    }

    return !bErr;
}

BOOL DisplayAlways(LPSTATEDATA lpStateData)
{
    return TRUE;
}

static BOOL SetRunKey(BOOL bSet, LPDWORD lpdwTickCount)
{
    HKEY    hKey;
    BOOL    bRet = FALSE;
    DWORD   dwDis;

    // First need to open the key either way.
    //
    if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_RUN, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwDis) == ERROR_SUCCESS )
    {
        if ( bSet )
        {
            TCHAR szCmd[MAX_PATH + 32];

            // Set us to run after we get logged on.
            //
            lstrcpyn(szCmd, g_szFactoryPath, AS ( szCmd ) );

            if ( FAILED ( StringCchCat ( szCmd, AS ( szCmd ), _T(" -logon") ) ) )
            {
                FacLogFileStr(3, _T("StringCchCat failed %s  %s\n"), szCmd, _T(" -logon") );
            }
            if ( RegSetValueEx(hKey, _T("AuditMode"), 0, REG_SZ, (CONST LPBYTE) szCmd, ( lstrlen(szCmd) + 1 ) * sizeof(TCHAR)) == ERROR_SUCCESS )
                bRet = TRUE;
        }
        else
        {
            // Delete the run key so we aren't left there.
            //
            if ( RegDeleteValue(hKey, _T("AuditMode")) == ERROR_SUCCESS )
                bRet = TRUE;
        }
        RegCloseKey(hKey);
    }

    // Open the key where we save some state info.
    //
    if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE, REG_FACTORY_STATE, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwDis) == ERROR_SUCCESS )
    {
        if ( bSet )
        {
            // Set the tick count so we know how long the logon takes.
            //
            if ( RegSetValueEx(hKey, _T("TickCount"), 0, REG_DWORD, (CONST LPBYTE) lpdwTickCount, sizeof(DWORD)) != ERROR_SUCCESS )
                bRet = FALSE;
        }
        else
        {
            DWORD   dwType,
                    cbValue = sizeof(DWORD);

            // Read and delete the run key so it isn't left there.
            //
            if ( ( RegQueryValueEx(hKey, _T("TickCount"), NULL, &dwType, (LPBYTE) lpdwTickCount, &cbValue) != ERROR_SUCCESS ) ||
                 ( REG_DWORD != dwType ) )
            {
                *lpdwTickCount = 0;
                bRet = FALSE;
            }
            else
                RegDeleteValue(hKey, _T("TickCount"));
        }
        RegCloseKey(hKey);
    }

    return bRet;
}