windows-server-2003/base/ntsetup/ocmanage/common/ocmanage.c

#include "precomp.h"
#pragma hdrstop


//
// Names of wizard page types, do not change order unless
// the WizardPagesType enum is changed.
//
LPCTSTR WizardPagesTypeNames[WizPagesTypeMax] = { TEXT("Welcome"), TEXT("Mode"),
                                                  TEXT("Early")  , TEXT("Prenet"),
                                                  TEXT("Postnet"), TEXT("Late"),
                                                  TEXT("Final")
                                                };

//
// Name of sections and keys in infs.
//
LPCTSTR szComponents = TEXT("Components");
LPCTSTR szOptionalComponents = TEXT("Optional Components");
LPCTSTR szExtraSetupFiles = TEXT("ExtraSetupFiles");
LPCTSTR szNeeds = TEXT("Needs");
LPCTSTR szExclude = TEXT("Exclude");
LPCTSTR szParent = TEXT("Parent");
LPCTSTR szIconIndex = TEXT("IconIndex");
LPCTSTR szModes = TEXT("Modes");
LPCTSTR szTip = TEXT("Tip");
LPCTSTR szOptionDesc = TEXT("OptionDesc");
LPCTSTR szInstalledFlag = TEXT("InstalledFlag");
LPCTSTR szHide = TEXT("HIDE");
LPCTSTR szOSSetupOnly = TEXT("OSSetupOnly");
LPCTSTR szStandaloneOnly = TEXT("StandaloneOnly");
LPCTSTR szPageTitle = TEXT("PageTitles");
LPCTSTR szSetupTitle = TEXT("SetupPage");
LPCTSTR szGlobal = TEXT("Global");
LPCTSTR szWindowTitle = TEXT("WindowTitle");
LPCTSTR szWindowTitleAlone = TEXT("WindowTitle.StandAlone");
LPCTSTR szSizeApproximation = TEXT("SizeApproximation");
LPCTSTR szWindowTitleInternal = TEXT("*");

//
// Key in registry where private component data is kept.
// We form a unique name within this key for the OC Manager
// instantiation.
//
LPCTSTR szOcManagerRoot   = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager");
LPCTSTR szPrivateDataRoot = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\TemporaryData");
LPCTSTR szMasterInfs      = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\MasterInfs");
LPCTSTR szSubcompList     = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\Subcomponents");
LPCTSTR szOcManagerErrors = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\Errors");

//
// Other string constants.
//
LPCTSTR szSetupDir = TEXT("Setup");

//
// locale information
//
LOCALE locale;

// Structure used for string table callback when
// building a subcomponent list.
//
typedef struct _BUILDSUBCOMPLIST_PARAMS {
    POC_MANAGER OcManager;
    UINT Pass;
} BUILDSUBCOMPLIST_PARAMS, *PBUILDSUBCOMPLIST_PARAMS;

//
// oc manager pointer for debugging/logging
//
POC_MANAGER gLastOcManager = NULL;

UINT
pOcQueryOrSetNewInf(
    IN  PCTSTR MasterOcInfName,
    OUT PTSTR  SuiteName,
    IN  DWORD  Operation
    );

VOID
pOcDestroyPerOcData(
    IN POC_MANAGER OcManager
    );

BOOL
pOcDestroyPerOcDataStringCB(
    IN PVOID               StringTable,
    IN LONG                StringId,
    IN PCTSTR              String,
    IN POPTIONAL_COMPONENT Oc,
    IN UINT                OcSize,
    IN LPARAM              Unused
    );

VOID
pOcClearAllErrorStates(
    IN POC_MANAGER OcManager
    );

BOOL
FileExists(
    IN  PCTSTR           FileName,
    OUT PWIN32_FIND_DATA FindData   OPTIONAL
    )

/*++

Routine Description:

    Determine if a file exists and is accessible.
    Errormode is set (and then restored) so the user will not see
    any pop-ups.

Arguments:

    FileName - supplies full path of file to check for existance.

    FindData - if specified, receives find data for the file.

Return Value:

    TRUE if the file exists and is accessible.
    FALSE if not. GetLastError() returns extended error info.

--*/

{
    WIN32_FIND_DATA findData;
    HANDLE FindHandle;
    UINT OldMode;
    DWORD Error;

    OldMode = SetErrorMode(SEM_FAILCRITICALERRORS);

    FindHandle = FindFirstFile(FileName,&findData);
    if(FindHandle == INVALID_HANDLE_VALUE) {
        Error = GetLastError();
    } else {
        FindClose(FindHandle);
        if(FindData) {
            *FindData = findData;
        }
        Error = NO_ERROR;
    }

    SetErrorMode(OldMode);

    SetLastError(Error);
    return (Error == NO_ERROR);
}

VOID
pOcFormSuitePath(
    IN  LPCTSTR SuiteName,
    IN  LPCTSTR FileName,   OPTIONAL
    OUT LPTSTR  FullPath
    )

/*++

Routine Description:

    Forms the name of the directory in the OS tree where per-suite
    infs and installation dlls are kept (system32\setup).

    Optionally also appends the name of a file to the path.

Arguments:

    SuiteName - shortname for the suite.

    FileName - optionally specifies the name of a file in the per-suite
        directory.

    FullPath - receives the full path of the per-suite directory (or the
        file within the directory). This buffer should be MAX_PATH TCHAR
        elements.

Return Value:

    None.

--*/

{
    UNREFERENCED_PARAMETER(SuiteName);

    GetSystemDirectory(FullPath,MAX_PATH);

    pSetupConcatenatePaths(FullPath,szSetupDir,MAX_PATH,NULL);

    //
    // We put all such files in a single flat directory.
    // This makes life easier for components that want to share
    // installation pieces, such as infs, dlls, etc.
    //
    // There are potential name conflict issues but we blow them off.
    //
    //pSetupConcatenatePaths(FullPath,SuiteName,MAX_PATH,NULL);

    if(FileName) {
        pSetupConcatenatePaths(FullPath,FileName,MAX_PATH,NULL);
    }
}


BOOL
pOcBuildSubcomponentListStringCB(
    IN PVOID                    StringTable,
    IN LONG                     StringId,
    IN PCTSTR                   String,
    IN POC_INF                  OcInf,
    IN UINT                     OcInfSize,
    IN PBUILDSUBCOMPLIST_PARAMS Params
    )

/*++

Routine Description:

    String table callback, worker routine for pOcBuildSubcomponentLists.

    This routine examines the loaded per-component infs and builds the
    subcomponent hierarchies that are described therein via the Parent=
    lines in the various per-component sections.

Arguments:

    Standard string table callback args.

Return Value:

    Boolean indicating outcome. If FALSE, an error will have been logged.
    FALSE also stops the string table enumeration and causes pSetupStringTableEnum()
    to return FALSE.

--*/

{
    OPTIONAL_COMPONENT OptionalComponent;
    OPTIONAL_COMPONENT AuxOc;
    INFCONTEXT LineContext;
    INFCONTEXT SublineContext;
    LPCTSTR SubcompName;
    LPCTSTR  ModuleFlags;
    LPCTSTR p;
    LONG l;
    LONG CurrentStringId;
    UINT u,n;
    INT IconIndex;
    POC_MANAGER OcManager = Params->OcManager;

    if(SetupFindFirstLine(OcInf->Handle,szOptionalComponents,NULL,&LineContext)) {

        do {
            if((SubcompName = pSetupGetField(&LineContext,1)) && *SubcompName) {

                l = pSetupStringTableLookUpStringEx(
                        Params->OcManager->ComponentStringTable,
                        (PTSTR)SubcompName,
                        STRTAB_CASE_INSENSITIVE,
                        &OptionalComponent,
                        sizeof(OPTIONAL_COMPONENT)
                        );

                if(Params->Pass == 0) {

                    //
                    // First pass. Add subcomponents listed in [Optional Components]
                    // to the string table. Each one has an associated OPTIONAL_COMPONENT
                    // structure. Top-level components already exist in the table,
                    // so we are careful here about how we overwrite existing entries.
                    //
                    if(l == -1) {
                        ZeroMemory(&OptionalComponent,sizeof(OPTIONAL_COMPONENT));

                        OptionalComponent.ParentStringId = -1;
                        OptionalComponent.FirstChildStringId = -1;
                        OptionalComponent.NextSiblingStringId = -1;
                        OptionalComponent.InfStringId = StringId;
                        OptionalComponent.Exists = FALSE;
                    }

                    if (OptionalComponent.Exists) {
                        _LogError(OcManager,
                                  OcErrLevError,
                                  MSG_OC_DUPLICATE_COMPONENT,
                                  SubcompName);
                        continue;
                    }

                    OptionalComponent.Exists = TRUE;

                    // Get the second Field of the Optional components line
                    // Determine if this component is hidden or not

                    ModuleFlags = pSetupGetField(&LineContext,2);
                    if (ModuleFlags) {
                        if (OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE)
                            p = szOSSetupOnly;
                        else
                            p = szStandaloneOnly;
                        if (!_tcsicmp(ModuleFlags, szHide) || !_tcsicmp(ModuleFlags, p))
                            OptionalComponent.InternalFlags |= OCFLAG_HIDE;
                    }

                    //
                    // Fetch the description, tip, and iconindex.
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szOptionDesc,&SublineContext)
                    && (p = pSetupGetField(&SublineContext,1))) {

                        lstrcpyn(OptionalComponent.Description,p,MAXOCDESC);
                    } else {
                        OptionalComponent.Description[0] = 0;
                    }

                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szTip,&SublineContext)
                    && (p = pSetupGetField(&SublineContext,1))) {

                        lstrcpyn(OptionalComponent.Tip,p,MAXOCTIP);
                    } else {
                        OptionalComponent.Tip[0] = 0;
                    }

                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szIconIndex,&SublineContext)
                    && (p = pSetupGetField(&SublineContext,1))) {

                        LPCTSTR p2,p3;

                        //
                        // If we have fields 2 and 3 then assume we've got a dll
                        // and resource name. Otherwise it's an index or *.
                        //
                        if((p2 = pSetupGetField(&SublineContext,2))
                        && (p3 = pSetupGetField(&SublineContext,3))) {

                            lstrcpyn(
                                OptionalComponent.IconDll,
                                p2,
                                sizeof(OptionalComponent.IconDll)/sizeof(TCHAR)
                                );

                            lstrcpyn(
                                OptionalComponent.IconResource,
                                p3,
                                sizeof(OptionalComponent.IconResource)/sizeof(TCHAR)
                                );

                            IconIndex = -2;

                        } else {
                            //
                            // If the icon index is * then stick -1 in there
                            // as a special marker value for later.
                            // Otherwise we call SetupGetIntField because it will
                            // validate the field for us.
                            //
                            if((p[0] == TEXT('*')) && (p[1] == 0)) {
                                IconIndex = -1;
                            } else {
                                if(!SetupGetIntField(&SublineContext,1,&IconIndex)) {
                                    IconIndex = DEFAULT_ICON_INDEX;
                                } else {
                                    // Setupapi will return DEFAULT_ICON_INDEX if out of range.
                                    if (IconIndex < 0) {
                                        IconIndex = DEFAULT_ICON_INDEX;
                                    }
                                }
                            }
                        }
                    } else {
                        //
                        // No icon index.
                        //
                        IconIndex = DEFAULT_ICON_INDEX;
                    }
                    OptionalComponent.IconIndex = IconIndex;

                    //
                    // if the InstalledFlag is specified, check it
                    // and set the original selection state accordingly
                    //
                    OptionalComponent.InstalledState = INSTSTATE_UNKNOWN;
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szInstalledFlag,&SublineContext)
                    && (p = pSetupGetField(&SublineContext,1))) {
                        TCHAR regkey[MAXOCIFLAG];
                        lstrcpyn(regkey,p,MAXOCIFLAG);
                        if (p = pSetupGetField(&SublineContext,2)) {
                            TCHAR regval[MAXOCIFLAG];
                            TCHAR buf[MAXOCIFLAG];
                            HKEY  hkey;
                            DWORD size;
                            DWORD type;
                            DWORD rc;
                            lstrcpyn(regval,p,MAXOCIFLAG);
                            if (RegOpenKey(HKEY_LOCAL_MACHINE, regkey, &hkey) == ERROR_SUCCESS) {
                                size = sizeof(buf);
                                rc = RegQueryValueEx(hkey,
                                                     regval,
                                                     NULL,
                                                     &type,
                                                     (LPBYTE)buf,
                                                     &size);
                                RegCloseKey(hkey);
                                if (rc == ERROR_SUCCESS) {
                                    OptionalComponent.InstalledState = INSTSTATE_YES;
                                } else {
                                    OptionalComponent.InstalledState = INSTSTATE_NO;
                                }
                            }
                        }
                    }

                    //
                    // Fetch the list of modes in which the subcomponent should be
                    // on by default. For future expandability, we'll accept any
                    // mode values up to 31, which is the number of bits we can fit
                    // in out UINT bitfield/
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szModes,&SublineContext)) {
                        n = SetupGetFieldCount(&SublineContext);
                        for(u=0; u<n; u++) {
                            if(SetupGetIntField(&SublineContext,u+1,&IconIndex)
                            && ((DWORD)IconIndex < 32)) {

                                OptionalComponent.ModeBits |= (1 << IconIndex);
                            }
                        }
                    }

                    //
                    // As an optimization, fetch the size approximation, if they
                    // supplied one.If they didn't supply this then we have to
                    // query them for disk space
                    //
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szSizeApproximation,&SublineContext)
                       && (p = pSetupGetField(&SublineContext,1))) {
                        //
                        // we have the text version of something that needs to be converted into
                        // a LONGLONG...
                        //
                        pConvertStringToLongLong(p,&OptionalComponent.SizeApproximation);
                        OptionalComponent.InternalFlags |= OCFLAG_APPROXSPACE;
                    }


                    // Find the The "TopLevelParent" for this Node
                    // Search the list if TopLevelComponent looking for
                    // the "INF string id" that matches the Inf String ID
                    // of this component.

                    for(u=0; u<OcManager->TopLevelOcCount; u++) {
                        pSetupStringTableGetExtraData(
                            OcManager->ComponentStringTable,
                            OcManager->TopLevelOcStringIds[u],
                            &AuxOc,
                            sizeof(OPTIONAL_COMPONENT)
                            );

                        if(AuxOc.InfStringId == StringId) {
                            // Found it and save to the current component
                             OptionalComponent.TopLevelStringId = OcManager->TopLevelOcStringIds[u];
                             u=(UINT)-1;
                             break;
                        }
                    }
                       // Check Found the Right String ID.
                    if(u != (UINT)-1) {
                        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                        return(FALSE);
                    }


                } else {

                    // Pass Two - Discover Needs and Parentage
                    // Two passs First to collect all the names second to
                    // create the needs and parent links

                    CurrentStringId = l;

                    //
                    // Deal with the needs.
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szNeeds,&SublineContext)) {

                        n = 0;
                        u = 0;
                        while(p = pSetupGetField(&SublineContext,n+1)) {
                            //
                            // Ignore unless the subcomponent is in the string table.
                            //
                            l = pSetupStringTableLookUpStringEx(
                                    Params->OcManager->ComponentStringTable,
                                    (PTSTR)p,
                                    STRTAB_CASE_INSENSITIVE,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );

                            if(l != -1) {
                                //
                                // Grow the needs array and put this item in it.
                                //
                                if(OptionalComponent.NeedsStringIds) {
                                    p = pSetupRealloc(
                                            OptionalComponent.NeedsStringIds,
                                            (OptionalComponent.NeedsCount+1) * sizeof(LONG)
                                            );
                                } else {
                                    OptionalComponent.NeedsCount = 0;
                                    p = pSetupMalloc(sizeof(LONG));
                                }

                                if(p) {
                                    OptionalComponent.NeedsStringIds = (PVOID)p;
                                    OptionalComponent.NeedsStringIds[OptionalComponent.NeedsCount++] = l;
                                } else {
                                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                                    return(FALSE);
                                }

                                //
                                // Insert this component in the needed component's neededby array.
                                //
                                if(AuxOc.NeededByStringIds) {
                                    p = pSetupRealloc(
                                            AuxOc.NeededByStringIds,
                                            (AuxOc.NeededByCount+1) * sizeof(LONG)
                                            );
                                } else {
                                    AuxOc.NeededByCount = 0;
                                    p = pSetupMalloc(sizeof(LONG));
                                }

                                if(p) {
                                    AuxOc.NeededByStringIds = (PVOID)p;
                                    AuxOc.NeededByStringIds[AuxOc.NeededByCount++] = CurrentStringId;
                                } else {
                                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                                    return(FALSE);
                                }

                                pSetupStringTableSetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    l,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );
                            }

                            n++;
                        }
                    }

                    //
                    // Deal with the excludes.
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szExclude,&SublineContext)) {

                        n = 0;
                        u = 0;
                        while(p = pSetupGetField(&SublineContext,n+1)) {
                            //
                            // Ignore unless the subcomponent is in the string table.
                            //
                            l = pSetupStringTableLookUpStringEx(
                                    Params->OcManager->ComponentStringTable,
                                    (PTSTR)p,
                                    STRTAB_CASE_INSENSITIVE,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );

                            if(l != -1) {
                                //
                                // Grow the exclude array and put this item in it.
                                //
                                if(OptionalComponent.ExcludeStringIds) {
                                    p = pSetupRealloc(
                                            OptionalComponent.ExcludeStringIds,
                                            (OptionalComponent.ExcludeCount+1) * sizeof(LONG)
                                            );
                                } else {
                                    OptionalComponent.ExcludeCount = 0;
                                    p = pSetupMalloc(sizeof(LONG));
                                }

                                if(p) {
                                    OptionalComponent.ExcludeStringIds = (PVOID)p;
                                    OptionalComponent.ExcludeStringIds[OptionalComponent.ExcludeCount++] = l;
                                } else {
                                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                                    return(FALSE);
                                }

                                //
                                // Insert this component in the excluded component's excludedby array.
                                //
                                if(AuxOc.ExcludedByStringIds) {
                                    p = pSetupRealloc(
                                            AuxOc.ExcludedByStringIds,
                                            (AuxOc.ExcludedByCount+1) * sizeof(LONG)
                                            );
                                } else {
                                    AuxOc.ExcludedByCount = 0;
                                    p = pSetupMalloc(sizeof(LONG));
                                }

                                if(p) {
                                    AuxOc.ExcludedByStringIds = (PVOID)p;
                                    AuxOc.ExcludedByStringIds[AuxOc.ExcludedByCount++] = CurrentStringId;
                                } else {
                                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                                    return(FALSE);
                                }

                                pSetupStringTableSetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    l,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );
                            }

                            n++;
                        }
                    }

                    //
                    // Figure out parentage. Ignore specified parent unless it exists
                    // in the string table. We also note in the parent that it has children.
                    //
                    if(SetupFindFirstLine(OcInf->Handle,SubcompName,szParent,&SublineContext)
                    && (p = (PVOID)pSetupGetField(&SublineContext,1))) {

                        l = pSetupStringTableLookUpStringEx(
                                Params->OcManager->ComponentStringTable,
                                (PTSTR)p,
                                STRTAB_CASE_INSENSITIVE,
                                &AuxOc,
                                sizeof(OPTIONAL_COMPONENT)
                                );

                        if(l != -1) {
                            //
                            // l is the string id of the parent, and AuxOc is filled with
                            // the parent's optional component data.
                            //
                            OptionalComponent.ParentStringId = l;

                            if(AuxOc.FirstChildStringId == -1) {
                                //
                                // This parent has no children yet.
                                // Set the current component as its (first) child.
                                // Note that in this case the current component does not yet
                                // have any siblings.
                                //
                                AuxOc.FirstChildStringId = CurrentStringId;
                                AuxOc.ChildrenCount = 1;

                                pSetupStringTableSetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    l,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );

                            } else {
                                //
                                // The parent already has children.
                                // Increment the parent's count of children, then
                                // walk the siblings list and add the new component to the end.
                                //
                                AuxOc.ChildrenCount++;

                                pSetupStringTableSetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    l,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );

                                l = AuxOc.FirstChildStringId;

                                pSetupStringTableGetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    AuxOc.FirstChildStringId,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );

                                while(AuxOc.NextSiblingStringId != -1) {

                                    l = AuxOc.NextSiblingStringId;

                                    pSetupStringTableGetExtraData(
                                        Params->OcManager->ComponentStringTable,
                                        l,
                                        &AuxOc,
                                        sizeof(OPTIONAL_COMPONENT)
                                        );
                                }

                                AuxOc.NextSiblingStringId = CurrentStringId;

                                pSetupStringTableSetExtraData(
                                    Params->OcManager->ComponentStringTable,
                                    l,
                                    &AuxOc,
                                    sizeof(OPTIONAL_COMPONENT)
                                    );
                            }

                        }
                    } else {    // a node with out a parent a new Top Level node

                        // Finally Add this String ID to the Component Strings list
                        //  UINT TopLevelParentOcCount;
                        //  PLONG TopLevelParentOcStringIds;

                         if(OcManager->TopLevelParentOcStringIds != NULL) {
                         p = pSetupRealloc(
                                OcManager->TopLevelParentOcStringIds,
                                (OcManager->TopLevelParentOcCount+1)
                                    * sizeof(OcManager->TopLevelParentOcStringIds)
                                );
                         } else {
                            OcManager->TopLevelParentOcCount = 0;
                            p = pSetupMalloc(sizeof(LONG));
                         }

                         if(p) {
                            OcManager->TopLevelParentOcStringIds = (PVOID)p;
                            OcManager->TopLevelParentOcStringIds[OcManager->TopLevelParentOcCount++] = CurrentStringId;

                         } else {
                            _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                            return(FALSE);

                        }

                    }
                }

                //
                // Now add the subcomponent to the string table.
                // We overwrite the extra data, which is not harmful since
                // we specifically fetched it earlier.
                //

                l = pSetupStringTableAddStringEx(
                        Params->OcManager->ComponentStringTable,
                        (PTSTR)SubcompName,
                        STRTAB_NEW_EXTRADATA | STRTAB_CASE_INSENSITIVE,
                        &OptionalComponent,
                        sizeof(OPTIONAL_COMPONENT)
                        );

                if(l == -1) {
                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                    return(FALSE);
                }
            }
        } while(SetupFindNextLine(&LineContext,&LineContext));
    }

    return(TRUE);
}


BOOL
pOcBuildSubcomponentLists(
    IN OUT POC_MANAGER OcManager,
    IN     PVOID       Log
    )

/*++

Routine Description:

    This routine examines the loaded per-component infs and builds the
    subcomponent hierarchies that are described therein via the Parent=
    lines in the various per-component sections.

Arguments:

    OcManager - supplies a pointer to the context data structure
        for the OC Manager.

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean indicating outcome. If FALSE, an error will have been logged.

--*/

{
    OC_INF OcInf;
    BOOL b;
    BUILDSUBCOMPLIST_PARAMS s;

    s.OcManager = OcManager;

    //
    // We make 2 passes. The first adds all the subcomponent names to
    // the string table. The second computes parentage. If we don't do
    // it this way then we might have ordering problems.
    //
    s.Pass = 0;
    b = pSetupStringTableEnum(
            OcManager->InfListStringTable,
            &OcInf,
            sizeof(OC_INF),
            (PSTRTAB_ENUM_ROUTINE)pOcBuildSubcomponentListStringCB,
            (LPARAM)&s
            );

    if(b) {
        s.Pass = 1;
        b = pSetupStringTableEnum(
                OcManager->InfListStringTable,
                &OcInf,
                sizeof(OC_INF),
                (PSTRTAB_ENUM_ROUTINE)pOcBuildSubcomponentListStringCB,
                (LPARAM)&s
                );
    }
    return(b);
}


BOOL
pOcInitPaths(
    IN OUT POC_MANAGER OcManager,
    IN     PCTSTR MasterInfName
    )
{
    TCHAR  path[MAX_PATH];
    TCHAR *p;

    //
    // 1. look for master INF in specified directory.
    // 2. look in %systemroot%\system32\Setup directory.
    // 3. look in %systemroot%\inf directory.
    //
    if (!FileExists(MasterInfName, NULL)) {
        pOcFormSuitePath(NULL, NULL, path);
        p = _tcsrchr(MasterInfName, TEXT('\\'));
        if (!p)
            p = (TCHAR *)MasterInfName;
        pSetupConcatenatePaths(path, p, MAX_PATH, NULL);
        if (!FileExists(path, NULL)) {
#ifdef UNICODE
            HMODULE hMod;
            FARPROC pGetSystemWindowsDirectory;
            hMod = LoadLibrary(L"kernel32.dll");
            if (hMod) {
                pGetSystemWindowsDirectory = GetProcAddress(hMod,"GetSystemWindowsDirectoryW");
                if (!pGetSystemWindowsDirectory) {
                    pGetSystemWindowsDirectory = GetProcAddress(hMod,"GetWindowsDirectoryW");
                }

                if (pGetSystemWindowsDirectory) {
                    pGetSystemWindowsDirectory( path, MAX_PATH );
                } else {
                    GetWindowsDirectory(path,MAX_PATH);
                }

                FreeLibrary(hMod);
            }

#else
            GetWindowsDirectory(path,MAX_PATH);
#endif
            pSetupConcatenatePaths(path,TEXT("INF"),MAX_PATH,NULL);
            pSetupConcatenatePaths(path,p,MAX_PATH,NULL);
            if (!FileExists(path, NULL))
                return FALSE;
        }
    } else {
        _tcscpy(path, MasterInfName);
    }

    _tcscpy(OcManager->MasterOcInfPath, path);
    return TRUE;
}

BOOL
pOcInstallSetupComponents(
    IN POPTIONAL_COMPONENT Oc,
    IN OUT POC_MANAGER OcManager,
    IN     PCTSTR      Component,
    IN     PCTSTR      DllName,         OPTIONAL
    IN     PCTSTR      InfName,         OPTIONAL
    IN     HWND        OwnerWindow,
    IN     PVOID       Log
    )

/*++

Routine Description:

    This routine makes sure that all files required for installation of
    a component listed in a master oc inf are properly installed in
    a well-known location.

    If the master OC inf is in the system inf directory, then we assume
    that all files are already in their proper locations and we do nothing.

    Otherwise we copy all installation files into system32\setup.
    Files copied include the per-component inf (if any), the installation dll,
    and all files listed on the ExtraSetupFiles= line in the [<component>]
    section in the master OC inf.

    Do not call this routine if the registry setting indicates that the
    master OC inf has been processed before.

Arguments:

    OcManager - supplies a pointer to the context data structure
        for the OC Manager.

    MasterOcInfName - supplies the full Win32 path of the master OC inf file.

    Component - supplies the shortname of the component we care about.

    DllName - supplies the name of the component's installation dll, if any.

    InfName - supplies the name of the component's per-component inf,
        if any.

    OwnerWindow - supplies the handle of the window to own any UI which may be
        popped up by this routine.

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean indicating outcome. If FALSE, an error will have been logged.

--*/

{
    TCHAR Path[MAX_PATH];
    TCHAR TargetPath[MAX_PATH];
    TCHAR InfPath[MAX_PATH];
    PTCHAR p;
    UINT u;
    HSPFILEQ FileQueue;
    PVOID QueueContext;
    INFCONTEXT InfLine;
    BOOL b;
    TCHAR FileName[MAX_PATH];
    DWORD n;

    b = FALSE;

    //
    // All of the installation files are expected to be sourced
    // in the same directory as the master oc inf itself.
    //
    // We'll stick all the installation files for the component
    // in %windir%\system32\setup so we know where to get at them later.
    //
    // If the master inf is in the inf directory, then we instead
    // assume that the the component is tightly integrated into
    // the system and that the installation files are already in
    // the system32 directory.
    //

    if (!GetWindowsDirectory(Path,MAX_PATH) ||
        !pSetupConcatenatePaths(Path,TEXT("INF"),MAX_PATH,NULL)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c0;
    }

    u = lstrlen(Path);

    pOcFormSuitePath(OcManager->SuiteName,NULL,TargetPath);

    lstrcpy(InfPath, OcManager->MasterOcInfPath);
    if (p = _tcsrchr(InfPath, TEXT('\\')))
        *p = 0;

    if (_tcsicmp(InfPath, Path) && _tcsicmp(InfPath, TargetPath)) {

        //
        // Inf is not in inf directory, so need to copy files.
        //
        FileQueue = SetupOpenFileQueue();
        if(FileQueue == INVALID_HANDLE_VALUE) {
            _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
            goto c0;
        }

        //
        // We will use the silent feature; no progress gauge but
        // we want errors to be displayed. Pass INVALID_HANDLE_VALUE
        // to get this behavior.
        //
        QueueContext = SetupInitDefaultQueueCallbackEx(OwnerWindow,INVALID_HANDLE_VALUE,0,0,0);
        if(!QueueContext) {
            _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
            goto c1;
        }

        //
        // Form source and target paths
        //
        lstrcpy(Path,OcManager->MasterOcInfPath);
        if(p = _tcsrchr(Path,TEXT('\\'))) {
            *p = 0;
        }

        //
        // Queue dll, and, if specified, inf
        //
        if (DllName && *DllName) {
            if ( (OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL ) {
                b = SetupQueueDelete(
                    FileQueue,      // handle to the file queue
                    TargetPath,     // path to the file to delete
                    DllName         // optional, additional path info
                );
            } else {

                BOOL bCopyFile = TRUE;
                // check if the file is present, it may not have to be for
                // defered installs, where the suite will provide the Exe usally on demand
                // via Web download

                if (Oc &&  Oc->InterfaceFunctionName[0] == 0 ) {

                    // No functin name means external setup

                    lstrcpy(FileName,Path);
                    pSetupConcatenatePaths(FileName, Oc->InstallationDllName, MAX_PATH, NULL);

                    bCopyFile = (GetFileAttributes(FileName)  == -1) ? FALSE: TRUE;
                    b=TRUE;

                    // bCopyFile=TRUE if we found the file

                }
                if( bCopyFile ) {
                    b = SetupQueueCopy(
                        FileQueue,
                        Path,
                        NULL,
                        DllName,
                        NULL,
                        NULL,
                        TargetPath,
                        NULL,
                        SP_COPY_SOURCEPATH_ABSOLUTE
                        );
                }
            }
            if(!b) {
                _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                goto c2;
            }
        }

        if(InfName && *InfName) {
            if ( (OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL ) {
                b = SetupQueueDelete(
                    FileQueue,      // handle to the file queue
                    TargetPath,     // path to the file to delete
                    InfName         // optional, additional path info
                );
            } else {
                b = SetupQueueCopy(
                    FileQueue,
                    Path,
                    NULL,
                    InfName,
                    NULL,
                    NULL,
                    TargetPath,
                    NULL,
                    SP_COPY_SOURCEPATH_ABSOLUTE
                    );
            }
            if(!b) {
                _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                goto c2;
            }
        }

        //
        // Queue each extra installation file.
        //
        if(SetupFindFirstLine(OcManager->MasterOcInf,Component,szExtraSetupFiles,&InfLine)) {
            n = 1;
            while(SetupGetStringField(&InfLine,n++,FileName,MAX_PATH,NULL)) {

                if ( (OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL ) {
                    b = SetupQueueDelete(
                        FileQueue,      // handle to the file queue
                        TargetPath,     // path to the file to delete
                        FileName        // optional, additional path info
                    );
                } else {
                     b = SetupQueueCopy(
                            FileQueue,
                            Path,
                            NULL,
                            FileName,
                            NULL,
                            NULL,
                            TargetPath,
                            NULL,
                            SP_COPY_SOURCEPATH_ABSOLUTE
                            );
                }

                if(!b) {
                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                    goto c2;
                }
            }
        }

        //
        // Commit the queue.
        //
        b = SetupCommitFileQueue(OwnerWindow,FileQueue,SetupDefaultQueueCallback,QueueContext);
        if(!b) {
            _LogError(OcManager,OcErrLevError,MSG_OC_CANT_COPY_SETUP_FILES,GetLastError());
            goto c2;
        }

        //
        // Make a note that this OC inf is now "known."
        //
        u = pOcQueryOrSetNewInf(OcManager->MasterOcInfPath,OcManager->SuiteName,infSet);
        if(u != NO_ERROR) {
            _LogError(OcManager,OcErrLevWarning,MSG_OC_CANT_WRITE_REGISTRY,u);
        }

c2:
        SetupTermDefaultQueueCallback(QueueContext);
c1:
        SetupCloseFileQueue(FileQueue);
c0:
        ;
    } else {
        b = TRUE;
    }

    return(b);
}


BOOL
pOcLoadMasterOcInf(
    IN OUT POC_MANAGER OcManager,
    IN     DWORD       Flags,
    IN     PVOID       Log
    )

/*++

Routine Description:

    This routine loads the master OC inf and builds up the list of
    top-level optional components and some of the associated data
    inclucing the name of the installation inf, dll and the entry point.
    The per-components infs and dlls are not actually loaded
    by this routine.

    The wizard page ordering stuff is also initialized in the
    OC Manager data structure.

Arguments:

    OcManager - supplies a pointer to the context data structure
        for the OC Manager.

    Flags - if OCINIT_FORCENEWINF, then behave as if the master OC inf is new.
            if OCINIT_KILLSUBCOMPS, then delete all applicable subcomponent
                entries from the registry before processing.

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean indicating outcome. If FALSE, an error will have been logged.

--*/

{
    BOOL b;
    INFCONTEXT InfContext;
    PCTSTR ComponentName;
    PCTSTR DllName;
    PCTSTR ModuleFlags;
    DWORD OtherFlags;
    PCTSTR EntryName;
    PCTSTR InfName;
    LPCTSTR chkflag;
    OPTIONAL_COMPONENT Oc;
    LONG Id;
    PVOID p;
    UINT i,j;
    UINT ActualCount;
    WizardPagesType ReplacePages[4] = {WizPagesWelcome,WizPagesMode,WizPagesFinal,-1},
                    AddPages[5] = {WizPagesEarly,WizPagesPrenet,WizPagesPostnet,WizPagesLate,-1};
    WizardPagesType *PageList;
    PCTSTR SectionName;
    BOOL NewInf;
    TCHAR ComponentsSection[100];
    TCHAR setupdir[MAX_PATH];


    // First check and see if the setup cache directory exists.
    // If not, then we should create it on this run.

    pOcFormSuitePath(NULL, NULL, setupdir);
    sapiAssert(*setupdir);
    if (!FileExists(setupdir, NULL))
        Flags |= OCINIT_FORCENEWINF;

    //
    // Always run pOcQueryOrSetNewInf in case it has side effects.
    //
    if (Flags & OCINIT_KILLSUBCOMPS)
        pOcQueryOrSetNewInf(OcManager->MasterOcInfPath, OcManager->SuiteName, infReset);
    NewInf = !pOcQueryOrSetNewInf(OcManager->MasterOcInfPath,OcManager->SuiteName,infQuery);
    if(Flags & OCINIT_FORCENEWINF) {
        NewInf = TRUE;
        OcManager->InternalFlags |= OCMFLAG_NEWINF;
    }
    if (Flags & OCINIT_KILLSUBCOMPS)
        OcManager->InternalFlags |= OCMFLAG_KILLSUBCOMPS;
    if (Flags & OCINIT_RUNQUIET)
        OcManager->InternalFlags |= OCMFLAG_RUNQUIET;
    if (Flags & OCINIT_LANGUAGEAWARE)
        OcManager->InternalFlags |= OCMFLAG_LANGUAGEAWARE;

    OcManager->MasterOcInf = SetupOpenInfFile(OcManager->MasterOcInfPath,NULL,INF_STYLE_WIN4,&i);
    if(OcManager->MasterOcInf == INVALID_HANDLE_VALUE) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_CANT_OPEN_INF,OcManager->MasterOcInfPath,GetLastError(),i);
        goto c0;
    }

    //
    // Get the number of lines in the [Components] section and allocate
    // arrays in the OC Manager context structure accordingly. This may
    // overallocate the arrays (in case of duplicates, invalid lines, etc)
    // but we won't worry about that here.
    //
    lstrcpy(ComponentsSection,szComponents);
    OcManager->TopLevelOcCount = (UINT)(-1);
#if defined(_AMD64_)
    lstrcat(ComponentsSection,TEXT(".amd64"));
#elif defined(_X86_)
    lstrcat(ComponentsSection,TEXT(".w95"));
    OcManager->TopLevelOcCount = SetupGetLineCount(OcManager->MasterOcInf,ComponentsSection);
    if(OcManager->TopLevelOcCount == (UINT)(-1)) {
        lstrcpy(ComponentsSection,szComponents);
        lstrcat(ComponentsSection,TEXT(".x86"));
    }
#elif defined(_IA64_)
    lstrcat(ComponentsSection,TEXT(".ia64"));
#else
#error Unknown platform!
#endif
    if(OcManager->TopLevelOcCount == (UINT)(-1)) {
        OcManager->TopLevelOcCount = SetupGetLineCount(OcManager->MasterOcInf,ComponentsSection);
    }
    if(OcManager->TopLevelOcCount == (UINT)(-1)) {
        lstrcpy(ComponentsSection,szComponents);
        OcManager->TopLevelOcCount = SetupGetLineCount(OcManager->MasterOcInf,ComponentsSection);
    }
    if(OcManager->TopLevelOcCount == (UINT)(-1)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_INF_INVALID_NO_SECTION,OcManager->MasterOcInfPath,szComponents);
        goto c1;
    }

    if (OcManager->TopLevelOcCount < 1) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c1;
    }

    if(p = pSetupRealloc(OcManager->TopLevelOcStringIds,OcManager->TopLevelOcCount*sizeof(LONG))) {

        OcManager->TopLevelOcStringIds = p;

        for(i=0; i<WizPagesTypeMax; i++) {

            if(p = pSetupRealloc(OcManager->WizardPagesOrder[i],OcManager->TopLevelOcCount*sizeof(LONG))) {
                OcManager->WizardPagesOrder[i] = p;
            } else {
                _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                goto c1;
            }
        }
    } else {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c1;
    }

    // get global info -
    if ((OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE) &&
        SetupFindFirstLine(
                  OcManager->MasterOcInf,
                  szGlobal,
                  szWindowTitleAlone,
                  &InfContext)) {
        // the main window title
        SetupGetStringField(
                    &InfContext,
                    1,                          // index of the field to get
                    OcManager->WindowTitle,     // optional, receives the field
                    sizeof(OcManager->WindowTitle)/sizeof(OcManager->WindowTitle[0]), // num char of the provided buffer
                    NULL);
        if( !lstrcmpi( OcManager->WindowTitle, szWindowTitleInternal)) {
            //This will happen when we load sysoc.inf For MUI.
            LoadString(MyModuleHandle,IDS_OCM_WINDOWTITLE,OcManager->WindowTitle,sizeof(OcManager->WindowTitle)/sizeof(TCHAR));
        }
    } else if(SetupFindFirstLine(
                  OcManager->MasterOcInf,
                  szGlobal,
                  szWindowTitle,
                  &InfContext)) {

        // the main window title
        SetupGetStringField(
                    &InfContext,
                    1,                          // index of the field to get
                    OcManager->WindowTitle,     // optional, receives the field
                    sizeof(OcManager->WindowTitle)/sizeof(OcManager->WindowTitle[0]), // num char of the provided buffer
                    NULL);
    } else {
        *OcManager->WindowTitle = 0;
    }

    //
    // Go through the [Components] section. Each line in there is a top-level
    // component spec, giving dll name, entry point name, and optionally
    // the name of the per-component inf.
    //
    if(!SetupFindFirstLine(OcManager->MasterOcInf,ComponentsSection,NULL,&InfContext)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_INF_INVALID_NO_SECTION,OcManager->MasterOcInfPath,ComponentsSection);
        goto c1;
    }

    ActualCount = 0;

    do {
        //
        // Get pointers to each field in each line. Ignore invalid lines.
        //
        if(ComponentName = pSetupGetField(&InfContext,0)) {

            DllName = pSetupGetField(&InfContext,1);
            if(DllName && !*DllName) {
                DllName = NULL;
            }
            EntryName = pSetupGetField(&InfContext,2);
            if(EntryName && !*EntryName) {
                EntryName = NULL;
            }

            //
            // An empty string for the inf name is the same as
            // not specifying the inf at all.
            //
            if((InfName = pSetupGetField(&InfContext,3)) && *InfName) {

                Id = pSetupStringTableAddString(
                        OcManager->InfListStringTable,
                        (PTSTR)InfName,
                        STRTAB_CASE_INSENSITIVE
                        );

                if(Id == -1) {
                    _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                    goto c1;
                }
            } else {
                Id = -1;
            }

            // Get the Flags Field
            ModuleFlags = pSetupGetField(&InfContext,4);
            if(ModuleFlags && !*ModuleFlags) {
                ModuleFlags = NULL;
            }

            OtherFlags = 0;
            SetupGetIntField(&InfContext,5,&OtherFlags);

            ZeroMemory(&Oc,sizeof(OPTIONAL_COMPONENT));

            //
            // These guys are top-level. Also remember the string id
            // of the inf name in the inf string table.
            //
            Oc.FirstChildStringId = -1;
            Oc.NextSiblingStringId = -1;
            Oc.ParentStringId = -1;
            Oc.InfStringId = Id;

            // Show flags allows up to have a component that is hidden
            // Only on one flags now so keep processing simple

            Oc.Exists = FALSE;
            Oc.InternalFlags |= OCFLAG_TOPLEVELITEM;

            if (ModuleFlags) {
                if (OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE)
                    chkflag = szOSSetupOnly;
                else
                    chkflag = szStandaloneOnly;
                if (!_tcsicmp(ModuleFlags, szHide) || !_tcsicmp(ModuleFlags, chkflag))
                    Oc.InternalFlags |= OCFLAG_HIDE;
            }

            if (OtherFlags & OCFLAG_NOWIZPAGES) {
                Oc.InternalFlags |= OCFLAG_NOWIZARDPAGES;
            }

            if (OtherFlags & OCFLAG_NOQUERYSKIP) {
                Oc.InternalFlags |= OCFLAG_NOQUERYSKIPPAGES;
            }

            if (OtherFlags & OCFLAG_NOEXTRAFLAGS) {
                Oc.InternalFlags |= OCFLAG_NOEXTRAROUTINES;
            }

            if(DllName) {
                lstrcpyn(Oc.InstallationDllName,DllName,MAX_PATH);
            } else {
                Oc.InstallationDllName[0] = 0;
            }

            //
            // Interface Function Name is always ANSI -- there's no
            // Unicode version of GetProcAddress.
            //
            if(EntryName) {
#ifdef UNICODE
                WideCharToMultiByte(CP_ACP,0,EntryName,-1,Oc.InterfaceFunctionName,MAX_PATH,NULL,NULL);
#else
                lstrcpyn(Oc.InterfaceFunctionName,EntryName,MAX_PATH);
#endif
            } else {
                Oc.InterfaceFunctionName[0] = 0;
            }

            Id = pSetupStringTableAddStringEx(
                    OcManager->ComponentStringTable,
                    (PTSTR)ComponentName,
                    STRTAB_CASE_INSENSITIVE | STRTAB_NEW_EXTRADATA,
                    &Oc,
                    sizeof(OPTIONAL_COMPONENT)
                    );

            if(Id == -1) {
                //
                // OOM adding string
                //
                _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
                goto c1;
            }

            OcManager->TopLevelOcStringIds[ActualCount++] = Id;

        }
    } while(SetupFindNextLine(&InfContext,&InfContext));

    //
    // Shrink down the various arrays.
    //
    OcManager->TopLevelOcStringIds = pSetupRealloc(OcManager->TopLevelOcStringIds,ActualCount*sizeof(LONG));
    for(i=0; i<WizPagesTypeMax; i++) {
        OcManager->WizardPagesOrder[i] = pSetupRealloc(OcManager->WizardPagesOrder[i],ActualCount*sizeof(LONG));
    }
    OcManager->TopLevelOcCount = ActualCount;

    //
    // Now for each wizard page type figure out the ordering.
    //
    for(i=0; i<2; i++) {

        SectionName = i ? TEXT("PageAdd") : TEXT("PageReplace");

        for(PageList = i ? AddPages : ReplacePages; *PageList != -1; PageList++) {

            b = SetupFindFirstLine(
                    OcManager->MasterOcInf,
                    SectionName,
                    WizardPagesTypeNames[*PageList],
                    &InfContext
                    );

            //
            // Check for the "default" string, which is the same as if the line
            // had not been specified at all.
            //
            if(b
            && (ComponentName = pSetupGetField(&InfContext,1))
            && !lstrcmpi(ComponentName,TEXT("Default"))) {

                b = FALSE;
            }

            if(b) {
                //
                // Make sure the array is padded with -1's,
                //
                FillMemory(
                    OcManager->WizardPagesOrder[*PageList],
                    OcManager->TopLevelOcCount * sizeof(LONG),
                    (BYTE)(-1)
                    );

                //
                // Now process each element on the line, but don't allow
                // overflowing the array.
                //
                j = 1;
                ActualCount = 0;

                while((ActualCount < OcManager->TopLevelOcCount)
                && (ComponentName = pSetupGetField(&InfContext,j)) && *ComponentName) {

                    Id = pSetupStringTableLookUpString(
                            OcManager->ComponentStringTable,
                            (PTSTR)ComponentName,
                            STRTAB_CASE_INSENSITIVE
                            );

                    if(Id == -1) {
                        //
                        // Invalid component. Log error and keep going.
                        //
                        _LogError(OcManager,
                            OcErrLevWarning,
                            MSG_OC_INVALID_COMP_IN_SECT,
                            OcManager->MasterOcInfPath,
                            SectionName,
                            ComponentName
                            );

                    } else {
                        //
                        // Remember the string id for this component.
                        //
                        OcManager->WizardPagesOrder[*PageList][ActualCount++] = Id;
                    }

                    j++;
                }

            } else {
                //
                // Default ordering, which is the order in which the components
                // were listed in the [Components] section
                //
                CopyMemory(
                    OcManager->WizardPagesOrder[*PageList],
                    OcManager->TopLevelOcStringIds,
                    OcManager->TopLevelOcCount * sizeof(LONG)
                    );
            }
        }
    }

    // get the caption for various pages

    if(SetupFindFirstLine(OcManager->MasterOcInf,szPageTitle,szSetupTitle,&InfContext)) {

        // Found it
        SetupGetStringField(
                    &InfContext,
                    1,                          // index of the field to get
                    OcManager->SetupPageTitle,  // optional, receives the field
                    sizeof(OcManager->SetupPageTitle)/sizeof(OcManager->SetupPageTitle[0]), // size of the provided buffer
                    NULL);

    }

    return(TRUE);

c1:
    sapiAssert(OcManager->MasterOcInf != INVALID_HANDLE_VALUE);
    SetupCloseInfFile(OcManager->MasterOcInf);
c0:
    return(FALSE);
}


BOOL
pOcSetOcManagerDirIds(
    IN HINF    InfHandle,
    IN LPCTSTR MasterOcInfName,
    IN LPCTSTR ComponentName
    )

/*++

Routine Description:

    This routine sets up the pre-defined OC Manager directory ids for
    per-component infs.

    DIRID_OCM_MASTERINF
    DIRID_OCM_MASTERINF_PLAT
    DIRID_OCM_MASTERINF_COMP
    DIRID_OCM_MASTERINF_COMP_PLAT

Arguments:

    InfHandle - supplies handle to open inf file

    MasterOcInfName - win32 path to master oc inf

    ComponentName - simple shortname for the component

Return Value:

    Boolean value indicating outcome. If FALSE, caller can assume OOM.

--*/

{
    TCHAR Path[MAX_PATH];
    TCHAR *p;
#if defined(_AMD64_)
    LPCTSTR Platform = TEXT("AMD64");
#elif defined(_X86_)
    LPCTSTR Platform = (IsNEC_98) ? TEXT("NEC98") : TEXT("I386");
#elif defined(_IA64_)
    LPCTSTR Platform = TEXT("IA64");
#else
#error "No Target Architecture"
#endif


    lstrcpy(Path,MasterOcInfName);
    if(p = _tcsrchr(Path,TEXT('\\'))) {
        *p = 0;
    } else {
        //
        // Something is very broken
        //
        return(FALSE);
    }

    if(!SetupSetDirectoryId(InfHandle,DIRID_OCM_MASTERINF,Path)) {
        return(FALSE);
    }

    if(!SetupSetDirectoryIdEx(InfHandle,DIRID_OCM_PLATFORM,Platform,SETDIRID_NOT_FULL_PATH,0,0)) {
        return(FALSE);
    }

    if(!SetupSetDirectoryIdEx(
        InfHandle,DIRID_OCM_PLATFORM_ALTERNATE,
#ifdef _X86_
        TEXT("X86"),
#else
        Platform,
#endif
        SETDIRID_NOT_FULL_PATH,0,0)) {

        return(FALSE);
    }

    if(!SetupSetDirectoryIdEx(InfHandle,DIRID_OCM_COMPONENT,ComponentName,SETDIRID_NOT_FULL_PATH,0,0)) {
        return(FALSE);
    }

    return(TRUE);
}


BOOL
pOcLoadInfsAndDlls(
    IN OUT POC_MANAGER OcManager,
    OUT    PBOOL       Canceled,
    IN     PVOID       Log
    )

/*++

Routine Description:

    Loads per-component INFs and installation DLLs.

    This includes invoking the preinitialization and initialization
    entry points in the DLLs.

Arguments:

    OcManager - supplies OC manager context structure

    Cancelled - receives a flag that is valid when this routine fails,
        indicating whether the failure was caused by a component
        canceling.

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean value indicating outcome

--*/

{
    UINT i;
    OPTIONAL_COMPONENT Oc;
    OC_INF OcInf;
    UINT ErrorLine;
    UINT Flags;
    UINT ErrorCode;
    PCTSTR InfName;
    PCTSTR ComponentName;
    TCHAR Library[MAX_PATH];
    BOOL b;
    INFCONTEXT Context;

    *Canceled = FALSE;

    //
    // The top-level component strctures have everything we need.
    // Spin through them.
    //
    for(i=0; i<OcManager->TopLevelOcCount; i++) {

        //
        // Get the OC data from the string table.
        //
        pSetupStringTableGetExtraData(
            OcManager->ComponentStringTable,
            OcManager->TopLevelOcStringIds[i],
            &Oc,
            sizeof(OPTIONAL_COMPONENT)
            );

        if(Oc.InfStringId == -1) {
            //
            // The master OC inf specified that this component has no per-component inf.
            //
            OcInf.Handle = INVALID_HANDLE_VALUE;

        } else {
            //
            // Load the per-component INF if it has not already been loaded.
            //
            pSetupStringTableGetExtraData(OcManager->InfListStringTable,Oc.InfStringId,&OcInf,sizeof(OC_INF));

            if(!OcInf.Handle) {

               InfName = pSetupStringTableStringFromId(OcManager->InfListStringTable,Oc.InfStringId);
               if (!InfName) {
                  _LogError(OcManager,OcErrLevError,MSG_OC_OOM);
                  return(FALSE);
               }

                if(OcManager->InternalFlags & OCMFLAG_NEWINF) {

                    // First try the directory the master inf is in

               lstrcpy(Library, OcManager->SourceDir);
                    pSetupConcatenatePaths(Library, InfName, MAX_PATH, NULL);

                } else {
                    pOcFormSuitePath(OcManager->SuiteName,InfName,Library);
                }

                if(FileExists(Library, NULL)) {
                   OcInf.Handle = SetupOpenInfFile(Library,NULL,INF_STYLE_WIN4,&ErrorLine);
               } else {
                   //
                   // Use standard inf search rules if the inf can't be found
                   // in the special suite directory.
                   //
                   OcInf.Handle = SetupOpenInfFile(InfName,NULL,INF_STYLE_WIN4,&ErrorLine);
               }

               if(OcInf.Handle == INVALID_HANDLE_VALUE) {
                   //
                   // Log error.
                   //
                   _LogError(OcManager,OcErrLevError,MSG_OC_CANT_OPEN_INF,InfName,GetLastError(),ErrorLine);
                   return(FALSE);
               } else {

                   // open the layout file

                   SetupOpenAppendInfFile(NULL, OcInf.Handle, NULL);

                   //
                   // Remember inf handle and set OC Manager DIRIDs.
                   //
                   pSetupStringTableSetExtraData(
                       OcManager->InfListStringTable,
                       Oc.InfStringId,
                       &OcInf,
                       sizeof(OC_INF)
                       );

                   b = pOcSetOcManagerDirIds(
                           OcInf.Handle,
                           OcManager->MasterOcInfPath,
                           pSetupStringTableStringFromId(OcManager->ComponentStringTable,OcManager->TopLevelOcStringIds[i])
                           );

                   if(!b) {
                       _LogError(OcManager,OcErrLevError,MSG_OC_OOM);
                       return(FALSE);
                   }
                   OcManager->SubComponentsPresent = TRUE;
               }
            }
        }

        //
        // Load the DLL and get the entry point address.
        // We make no attempt to track duplicates like we do for infs --
        // the underlying OS does that for us.
        //
        // The dll could be either in the special suite directory for this
        // master oc inf, or in a standard place. LoadLibraryEx does
        // exactly what we want.
        //
        if(Oc.InstallationDllName[0] && Oc.InterfaceFunctionName[0]) {

            if (OcManager->InternalFlags & OCMFLAG_NEWINF) {

                // First try the directory the master inf is in

                lstrcpy(Library, OcManager->SourceDir);
                pSetupConcatenatePaths(Library, Oc.InstallationDllName, MAX_PATH, NULL);
                Oc.InstallationDll = LoadLibraryEx(Library,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);

            }
            // Try the Setup Directory

            if (! Oc.InstallationDll ) {
                pOcFormSuitePath(OcManager->SuiteName,Oc.InstallationDllName,Library);
                Oc.InstallationDll = LoadLibraryEx(Library,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
            }

            // lastly try anywhere in the path
            if ( ! Oc.InstallationDll ) {
                Oc.InstallationDll = LoadLibraryEx(Oc.InstallationDllName,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
            }

            //
            // Failure is taken care of below....
            //
            if (Oc.InstallationDll) {
                Oc.InstallationRoutine = (POCSETUPPROC)GetProcAddress(
                                                Oc.InstallationDll,
                                                Oc.InterfaceFunctionName);
            } else {
                Oc.InstallationRoutine = NULL;
            }
        } else {
            Oc.InstallationDll = MyModuleHandle;
            Oc.InstallationRoutine = StandAloneSetupAppInterfaceRoutine;
        }

        if(Oc.InstallationDll && Oc.InstallationRoutine) {
            //
            // Success. Call the init-related entry points. Note that we can't call
            // any entry point except the preinit one until after we've stored
            // the ansi/unicode flag into the OPTIONAL_COMPONENT structure.
            //
            // Also note that before we do this we have to store the Oc structure,
            // otherwise the interface routine is NULL and we fault.
            //

            pSetupStringTableSetExtraData(
                OcManager->ComponentStringTable,
                OcManager->TopLevelOcStringIds[i],
                &Oc,
                sizeof(OPTIONAL_COMPONENT)
                );

            Oc.Flags = OcInterfacePreinitialize(OcManager,OcManager->TopLevelOcStringIds[i]);
            if(!Oc.Flags) {
                //
                // If this fails, then assume the DLL is written for a different
                // platform or version, for example a Unicode/ANSI problem.
                //
                _LogError(OcManager,
                    OcErrLevError,
                    MSG_OC_DLL_PREINIT_FAILED,
                    pSetupStringTableStringFromId(
                        OcManager->ComponentStringTable,
                        OcManager->TopLevelOcStringIds[i]
                        ),
                    Oc.InstallationDllName
                    );

                return(FALSE);
            }
        } else {

            //
            // Failure, log error.
            //
            _LogError(OcManager,
                OcErrLevError,
                MSG_OC_DLL_LOAD_FAIL,
                Oc.InstallationDllName,
                Oc.InterfaceFunctionName,
                GetLastError()
                );

            return(FALSE);
        }

        //
        // Set the OC data back into the string table.
        // After this we can call other interface entry points since
        // the ansi/unicode flag will now be stored in the OPTIONAL_COMPONENT
        // structure for the component.
        //
        pSetupStringTableSetExtraData(
            OcManager->ComponentStringTable,
            OcManager->TopLevelOcStringIds[i],
            &Oc,
            sizeof(OPTIONAL_COMPONENT)
            );

        ErrorCode = OcInterfaceInitComponent(
                        OcManager,
                        OcManager->TopLevelOcStringIds[i]
                        );

        if(ErrorCode == NO_ERROR) {
            // Send down extra helper routines.
            if ((Oc.InternalFlags & OCFLAG_NOEXTRAROUTINES)==0) {
                ErrorCode = OcInterfaceExtraRoutines(
                                OcManager,
                                OcManager->TopLevelOcStringIds[i]
                                );
            }
        }

        if(ErrorCode == NO_ERROR) {
            if (OcManager->InternalFlags & OCMFLAG_LANGUAGEAWARE) {
                //
                // Send down a set-language request.
                // Ignore the result.
                //
                OcInterfaceSetLanguage(
                    OcManager,
                    OcManager->TopLevelOcStringIds[i],
                    LANGIDFROMLCID(GetThreadLocale())
                    );
            }
        } else {
            if(ErrorCode == ERROR_CANCELLED) {
                // cancel will stop oc manager only if
                // we aren't running in gui-mode setup
                *Canceled = TRUE;
                if (OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE)
                    return FALSE;
            } else {
                _LogError(OcManager,
                    OcErrLevError,
                    MSG_OC_DLL_INIT_FAILED,
                    pSetupStringTableStringFromId(
                        OcManager->ComponentStringTable,
                        OcManager->TopLevelOcStringIds[i]
                        )
                    );
            }

            pOcRemoveComponent(OcManager, OcManager->TopLevelOcStringIds[i], pidLoadComponent);
        }
    }

    //
    // Now go gather additional information about subcomponents
    // (descriptions, parentage, needs=, etc).
    //
    return(pOcBuildSubcomponentLists(OcManager,Log));
}


BOOL
pOcUnloadInfsAndDlls(
    IN OUT POC_MANAGER OcManager,
    IN     PVOID       Log
    )

/*++

Routine Description:

    Unloads per-component INFs and installation DLLs that were
    previously loaded by pOcLoadInfsAndDlls().

    This routine does NOT call the interface entry points to
    uninitialize the installation DLLs.

Arguments:

    OcManager - supplies OC manager context structure

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean value indicating outcome.
    If FALSE, an error will have been logged to indicate what failed.

--*/

{
    OPTIONAL_COMPONENT Oc;
    OC_INF OcInf;
    UINT i;

    //
    // Unload Dlls.
    //
    for(i=0; i<OcManager->TopLevelOcCount; i++) {

        pSetupStringTableGetExtraData(
            OcManager->ComponentStringTable,
            OcManager->TopLevelOcStringIds[i],
            &Oc,
            sizeof(OPTIONAL_COMPONENT)
            );

        if(Oc.InstallationDll && (Oc.InstallationDll != MyModuleHandle)) {
            FreeLibrary(Oc.InstallationDll);
            Oc.InstallationDll = NULL;
        }

        Oc.InstallationRoutine = NULL;
        Oc.InstallationDllName[0] = 0;
        Oc.InterfaceFunctionName[0]= 0;

        if(Oc.InfStringId != -1) {

            pSetupStringTableGetExtraData(
                OcManager->InfListStringTable,
                Oc.InfStringId,
                &OcInf,
                sizeof(OC_INF)
                );

            if(OcInf.Handle && (OcInf.Handle != INVALID_HANDLE_VALUE)) {

                SetupCloseInfFile(OcInf.Handle);
                OcInf.Handle = INVALID_HANDLE_VALUE;

                pSetupStringTableSetExtraData(
                    OcManager->InfListStringTable,
                    Oc.InfStringId,
                    &OcInf,
                    sizeof(OC_INF)
                    );
            }

            Oc.InfStringId = -1;
        }

        pSetupStringTableSetExtraData(
            OcManager->ComponentStringTable,
            OcManager->TopLevelOcStringIds[i],
            &Oc,
            sizeof(OPTIONAL_COMPONENT)
            );
    }

    return(TRUE);
}


BOOL
pOcManagerInitPrivateDataStore(
    IN OUT POC_MANAGER OcManager,
    IN     PVOID       Log
    )

/*++

Routine Description:

    Initializes the private data store for components.
    The registry is used as the backing store for private data.
    We make use of volatile keys to help ensure that this data is temporary
    in nature.

Arguments:

    OcManager - supplies OC Manager context stucture.

    Log - supplies a handle to use to log errors.

Return Value:

    Boolean value indicating outcome. If FALSE an error will have
    been logged.

--*/

{
    LONG l;
    DWORD Disposition;

    //
    // Start out by forming a unique name for this instantiation
    // of the OC Manager.
    //
    wsprintf(OcManager->PrivateDataSubkey,TEXT("%x:%x"),GetCurrentProcessId(),OcManager);

    //
    // Open/create the private data root. Save the handle.
    //
    l = RegCreateKeyEx(
            HKEY_LOCAL_MACHINE,
            szPrivateDataRoot,
            0,
            NULL,
            REG_OPTION_VOLATILE,
            KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE | KEY_SET_VALUE,
            NULL,
            &OcManager->hKeyPrivateDataRoot,
            &Disposition
            );

    if(l != NO_ERROR) {
        OcManager->hKeyPrivateDataRoot = NULL;
        OcManager->hKeyPrivateData = NULL;
        _LogError(OcManager,OcErrLevWarning,MSG_OC_CREATE_KEY_FAILED,szPrivateDataRoot,l);
        return(FALSE);
    }

    //
    // Get rid of the private data tree if it already exists for some reason.
    //
    if(Disposition == REG_OPENED_EXISTING_KEY) {
        pSetupRegistryDelnode(OcManager->hKeyPrivateDataRoot,OcManager->PrivateDataSubkey);
    }

    //
    // Create the private data tree. Save the handle.
    //
    l = RegCreateKeyEx(
            OcManager->hKeyPrivateDataRoot,
            OcManager->PrivateDataSubkey,
            0,
            NULL,
            REG_OPTION_VOLATILE,
            KEY_CREATE_SUB_KEY | KEY_QUERY_VALUE | KEY_SET_VALUE,
            NULL,
            &OcManager->hKeyPrivateData,
            &Disposition
            );

    if(l != NO_ERROR) {
        RegCloseKey(OcManager->hKeyPrivateDataRoot);
        OcManager->hKeyPrivateDataRoot = NULL;
        OcManager->hKeyPrivateData = NULL;
        _LogError(OcManager,OcErrLevWarning,MSG_OC_CREATE_KEY_FAILED,OcManager->PrivateDataSubkey,l);
        return(FALSE);
    }

    return(TRUE);
}


VOID
pOcManagerTearDownPrivateDataStore(
    IN OUT POC_MANAGER OcManager
    )
{
    RegCloseKey(OcManager->hKeyPrivateData);
    pSetupRegistryDelnode(OcManager->hKeyPrivateDataRoot,OcManager->PrivateDataSubkey);
    RegCloseKey(OcManager->hKeyPrivateDataRoot);

    OcManager->hKeyPrivateDataRoot = NULL;
    OcManager->hKeyPrivateData = NULL;
}


UINT
pOcQueryOrSetNewInf(
    IN  PCTSTR MasterOcInfName,
    OUT PTSTR  SuiteName,
    IN  DWORD  operation
    )

/*++

Routine Description:

    Determine whether a master OC inf has been encountered before,
    or remember that a master inf has been encountered.

    This information is stored in the registry.

Arguments:

    MasterOcInfName - supplies the full Win32 path of the master OC inf.

    SuiteName - receives the filename part of the .inf, without any
        extension. This is suitable for use as a tag representing the
        suite that the master INF is for. This buffer should be
        MAX_PATH TCHAR elements.

    QueryOnly - if TRUE, then the routine is to query whether the
        master inf has been previously processed. If FALSE, then
        the routine is to remember that the inf has been processed.

Return Value:

    If QueryOnly is TRUE:

        TRUE if the INF has been encountered before, FALSE if not.

    If QueryOnly is FALSE:

        Win32 error code indicating outcome.

--*/

{
    PTCHAR p;
    HKEY hKey;
    LONG l;
    DWORD Type;
    DWORD Size;
    DWORD Data;

    //
    // Form the suite name. The MasterOcInfName is expected to be
    // a full path so this is pretty easy. We'll try to be at least
    // a little more robust.
    //
    if(p = _tcsrchr(MasterOcInfName,TEXT('\\'))) {
        p++;
    } else {
        p = (PTCHAR)MasterOcInfName;
    }
    lstrcpyn(SuiteName,p,MAX_PATH);
    if(p = _tcsrchr(SuiteName,TEXT('.'))) {
        *p = 0;
    }

    //
    // Look in the registry to see if there is a value entry
    // with the suite name in there.
    //

    l = RegCreateKeyEx(
            HKEY_LOCAL_MACHINE,
            szMasterInfs,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            (operation == infQuery) ? KEY_QUERY_VALUE : KEY_SET_VALUE,
            NULL,
            &hKey,
            &Type
            );

    if (l != NO_ERROR)
        return (operation == infQuery) ? 0 : l;

    // do the job

    switch (operation) {

    case infQuery:
        Size = sizeof(DWORD);
        l = RegQueryValueEx(hKey,SuiteName,NULL,&Type,(LPBYTE)&Data,&Size);
        if((l == NO_ERROR) && (Type == REG_DWORD) && Data)
            l = TRUE;
        else
            l = FALSE;
        break;

    case infSet:
        Data = 1;
        l = RegSetValueEx(hKey,SuiteName,0,REG_DWORD,(LPBYTE)&Data,sizeof(DWORD));
        break;

    case infReset:
        l = RegDeleteValue(hKey,SuiteName);
        break;
    }

    RegCloseKey(hKey);

    return l;
}


PVOID
OcInitialize(
    IN  POCM_CLIENT_CALLBACKS Callbacks,
    IN  LPCTSTR               MasterOcInfName,
    IN  UINT                  Flags,
    OUT PBOOL                 ShowError,
    IN  PVOID                 Log
    )

/*++

Routine Description:

    Initializes the OC Manager. The master OC INF is loaded and
    processed, which includes INFs, loading setup interface DLLs and
    querying interface entry points. A set of in-memory structures
    is built up.

    If the OC INF hasn't been processed before then we copy the
    installation files for the component(s) into %windir%\system32\setup.
    Files are expected to be in the same directory as the OC inf.

Arguments:

    Callbacks - supplies a set of routines used by the OC Manager
        to perform various functions.

    MasterOcInfName - supplies the full Win32 path of the master OC inf.

    Flags - supplies various flags that control operation.

    ShowError - receives a flag that is valid if this routine fails,
        advising the caller whether he should show an error message.

    Log - supplies a handle to use to log errors.

Return Value:

    Opaque pointer to internal context structure or NULL if failure.
    If NULL, an error will have been logged to indicate what failed.

--*/

{
    POC_MANAGER OcManager;
    UINT i;
    HKEY hKey;
    DWORD DontCare;
    LONG l;
    BOOL Canceled;
    BOOL rc;
    TCHAR *p;

    *ShowError = TRUE;

    // init the wizard handle

    WizardDialogHandle = NULL;

    //
    // Allocate a new OC MANAGER structure
    //
    OcManager = pSetupMalloc(sizeof(OC_MANAGER));
    if(!OcManager) {
        //
        // Make the callback work
        //
        OC_MANAGER ocm;
        ocm.Callbacks = *Callbacks;
        _LogError(&ocm,OcErrLevFatal,MSG_OC_OOM);
        goto c0;
    }
    ZeroMemory(OcManager,sizeof(OC_MANAGER));

    OcManager->Callbacks = *Callbacks;

    OcManager->CurrentComponentStringId = -1;
    OcManager->SetupMode = SETUPMODE_CUSTOM;
    OcManager->UnattendedInf = INVALID_HANDLE_VALUE;

    gLastOcManager = (POC_MANAGER) OcManager;

    if (!pOcInitPaths(OcManager, MasterOcInfName)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_MASTER_INF_LOAD_FAILED);
        goto c1;
    }

    sapiAssert(*OcManager->MasterOcInfPath);

#ifdef UNICODE
    OcFillInSetupDataW(&(OcManager->SetupData));
#else
    OcFillInSetupDataA(&(OcManager->SetupData));
#endif

    // Say the user canceled until we successfully complete an install
    // This will prevent Inf Files from being copied to system32\setup

    OcManager->InternalFlags |= OCMFLAG_USERCANCELED;

    // Make sure the OC Manager key exists in the registry as a non-volatile key.
    // Other parts of the code deal in volatile keys so some care is needed to
    // avoid getting a volatile key under which we want to create non-volatile entries.
    //
    l = RegCreateKeyEx(
            HKEY_LOCAL_MACHINE,
            szOcManagerRoot,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_CREATE_SUB_KEY | KEY_QUERY_VALUE | KEY_SET_VALUE,
            NULL,
            &hKey,
            &DontCare
            );

    if(l == NO_ERROR) {
        RegCloseKey(hKey);
    } else {
        _LogError(OcManager,OcErrLevWarning,MSG_OC_CREATE_KEY_FAILED,szOcManagerRoot,l);
    }

    // get the locale info

    locale.lcid = GetSystemDefaultLCID();
    GetLocaleInfo(locale.lcid,
                  LOCALE_SDECIMAL,
                  locale.DecimalSeparator,
                  sizeof(locale.DecimalSeparator)/sizeof(TCHAR));

    //
    // Initialize string tables.
    //
    OcManager->InfListStringTable = pSetupStringTableInitializeEx(sizeof(OC_INF),0);
    if(!OcManager->InfListStringTable) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c1;
    }

    OcManager->ComponentStringTable = pSetupStringTableInitializeEx(sizeof(OPTIONAL_COMPONENT),0);
    if(!OcManager->ComponentStringTable) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c2;
    }

    //
    // Initialize various arrays. We alloc 0-length blocks here to allow
    // realloc later without special casing.
    //
    OcManager->TopLevelOcStringIds = pSetupMalloc(0);
    if(!OcManager->TopLevelOcStringIds) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
        goto c3;
    }

    for(i=0; i<WizPagesTypeMax; i++) {
        OcManager->WizardPagesOrder[i] = pSetupMalloc(0);
        if(!OcManager->WizardPagesOrder[i]) {
            _LogError(OcManager,OcErrLevFatal,MSG_OC_OOM);
            goto c4;
        }
    }

    //
    // Initialize the private data store.
    //
    if(!pOcManagerInitPrivateDataStore(OcManager,Log)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_PRIVATEDATASTORE_INIT_FAILED);
        goto c4;
    }

    //
    // Load the master OC inf.
    //
    if(!pOcLoadMasterOcInf(OcManager, Flags, Log)) {
        _LogError(OcManager,OcErrLevFatal,MSG_OC_MASTER_INF_LOAD_FAILED);
        goto c5;
    }

    // set the source path

    lstrcpy(OcManager->SourceDir, OcManager->MasterOcInfPath);
    if (p = _tcsrchr(OcManager->SourceDir, TEXT('\\')))
        *p = 0;
    else
       GetCurrentDirectory(MAX_PATH, OcManager->SourceDir);

    //
    // Load the unattend file
    //
    if(OcManager->SetupData.UnattendFile[0]) {
        OcManager->UnattendedInf = SetupOpenInfFile(
                                        OcManager->SetupData.UnattendFile,
                                        NULL,
                                        INF_STYLE_WIN4,
                                        NULL
                                        );

        if (OcManager->UnattendedInf == INVALID_HANDLE_VALUE && GetLastError() == ERROR_WRONG_INF_STYLE) {
            OcManager->UnattendedInf = SetupOpenInfFile(
                                            OcManager->SetupData.UnattendFile,
                                            NULL,
                                            INF_STYLE_OLDNT,
                                            NULL
                                            );
        }

        if(OcManager->UnattendedInf == INVALID_HANDLE_VALUE) {
            _LogError(OcManager,OcErrLevFatal,MSG_OC_CANT_OPEN_INF,OcManager->SetupData.UnattendFile,GetLastError());
            goto c6;
        }
    }


    //
    // Load component infs and DLLs.
    //
    rc = pOcLoadInfsAndDlls(OcManager, &Canceled, Log);

    //
    // Error already logged if necessary
    //
    if (Canceled)
        *ShowError = FALSE;

    if (!rc)
        goto c6;

    pOcClearAllErrorStates(OcManager);

    if(!pOcFetchInstallStates(OcManager)) {
        //
        // Error already logged.
        //
        goto c6;
    }


   //
    // Ask the components to give up a rough estimate
    // of their sizes so we can say something meaningful in the list boxes.
    //

    pOcGetApproximateDiskSpace(OcManager);
    return(OcManager);

c6:
    sapiAssert(OcManager->MasterOcInf != INVALID_HANDLE_VALUE);
    SetupCloseInfFile(OcManager->MasterOcInf);
    if (OcManager->UnattendedInf != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(OcManager->UnattendedInf);
c5:
    //
    // Tear down private data store.
    //
    pOcManagerTearDownPrivateDataStore(OcManager);

c4:
    if(OcManager->TopLevelOcStringIds) {
        pSetupFree(OcManager->TopLevelOcStringIds);

        for(i=0; OcManager->WizardPagesOrder[i] && (i<WizPagesTypeMax); i++) {
            pSetupFree(OcManager->WizardPagesOrder[i]);
        }
    }

    // free up the list of aborted components

    if (OcManager->AbortedComponentIds) {
        pSetupFree(OcManager->AbortedComponentIds);
    }

c3:
    pOcDestroyPerOcData(OcManager);
    pSetupStringTableDestroy(OcManager->ComponentStringTable);
c2:
    pSetupStringTableDestroy(OcManager->InfListStringTable);
c1:
    pSetupFree(OcManager);
c0:
    return(NULL);
}

VOID
OcTerminate(
    IN OUT PVOID *OcManagerContext
    )

/*++

Routine Description:

    This routine shuts down the OC Manager, including calling the subcomponents
    to clean themselves up, release resources, etc.

Arguments:

    OcManagerContext - in input, supplies a pointer to a context value returned
        by OcInitialize. On output, receives NULL.

Return Value:

    None.

--*/

{
    POC_MANAGER OcManager;
    UINT u;
    BOOL b;
    OPTIONAL_COMPONENT Oc;
    OC_INF OcInf;
    LPCTSTR ComponentName;
    LPCTSTR InfName;

    sapiAssert(OcManagerContext && *OcManagerContext);
    OcManager = *OcManagerContext;
    *OcManagerContext = NULL;

    //
    // Run down the top-level OCs, calling the dlls to indicate that we're done.
    // We don't tear down any infrastructure until after we've told all the dlls
    // that we're done.
    //
    for(u=0; u<OcManager->TopLevelOcCount; u++) {
        OcInterfaceCleanup(OcManager,OcManager->TopLevelOcStringIds[u]);
    }

    // if the user did not cancel setup
    //
    if (!(OcManager->InternalFlags & OCMFLAG_USERCANCELED)){

        //
        // Remember persistent install state.
        //
        pOcRememberInstallStates(OcManager);

        // copy the master INF file over

        if ( OcManager->InternalFlags & OCMFLAG_NEWINF ) {
            b = pOcInstallSetupComponents(
                        NULL,
                        OcManager,
                        OcManager->SuiteName,
                        NULL,
                        _tcsrchr(OcManager->MasterOcInfPath,TEXT('\\')), //  InfName,
                        NULL,
                        NULL
                );
        }
    }
    //
    // Run down the top-level OCs and free DLLs and per-component infs.
    //
    for(u=0; u<OcManager->TopLevelOcCount; u++) {

        ComponentName =   pSetupStringTableStringFromId(      // ComponentName
                        OcManager->ComponentStringTable,
                        OcManager->TopLevelOcStringIds[u]);

        pSetupStringTableGetExtraData(
            OcManager->ComponentStringTable,
            OcManager->TopLevelOcStringIds[u],
            &Oc,
            sizeof(OPTIONAL_COMPONENT)
            );

        if(Oc.InstallationDll && (Oc.InstallationDll != MyModuleHandle)) {
            //FreeLibrary(Oc.InstallationDll);
        }

        if(Oc.InfStringId != -1) {

            pSetupStringTableGetExtraData(
                OcManager->InfListStringTable,
                Oc.InfStringId,
                &OcInf,
                sizeof(OC_INF)
                );

            if(OcInf.Handle && (OcInf.Handle != INVALID_HANDLE_VALUE)) {
                SetupCloseInfFile(OcInf.Handle);

                //
                // Mark the handle as closed, is to components are shareing
                // the same INF file, should only close the file once.
                //
                OcInf.Handle = INVALID_HANDLE_VALUE;
                pSetupStringTableSetExtraData(
                    OcManager->InfListStringTable,
                    Oc.InfStringId,
                    &OcInf,
                    sizeof(OC_INF)
                );
            }
        }
        // This is a new install and we did not cancel out of setup
        // copy the setup components to the setup dir otherwise a canceled
        // setup will leave an upgrade dead in the water.

        if ( ( (OcManager->InternalFlags & OCMFLAG_NEWINF )
               || ( (OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL ) )
             && (! (OcManager->InternalFlags & OCMFLAG_USERCANCELED))){

            if (Oc.InfStringId == -1) {
                InfName = NULL;
            } else {
                InfName = pSetupStringTableStringFromId(OcManager->InfListStringTable,
                                                  Oc.InfStringId);
            }

            b = pOcInstallSetupComponents(
                    &Oc,
                    OcManager,
                    ComponentName,
                    Oc.InstallationDllName,
                    InfName,
                    NULL,
                    NULL
            );
            if(!b) {
                _LogError(OcManager,OcErrLevFatal,MSG_OC_CANT_INSTALL_SETUP,ComponentName);
            }
        }


    }

    //
    // Free string tables.
    //
    pOcDestroyPerOcData(OcManager);
    pSetupStringTableDestroy(OcManager->ComponentStringTable);
    pSetupStringTableDestroy(OcManager->InfListStringTable);

    //
    // Free the wizard page ordering arrays.
    //
    for(u=0; u<WizPagesTypeMax; u++) {
        if(OcManager->WizardPagesOrder[u]) {
            pSetupFree(OcManager->WizardPagesOrder[u]);
        }
    }

    //
    // Tear down the private data store.
    //
    pOcManagerTearDownPrivateDataStore(OcManager);

    //
    // Free the master oc inf and finally the oc manager context structure itself.
    //
    sapiAssert(OcManager->MasterOcInf != INVALID_HANDLE_VALUE);
    SetupCloseInfFile(OcManager->MasterOcInf);
    if (OcManager->UnattendedInf && OcManager->UnattendedInf != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(OcManager->UnattendedInf);

    // If this is a remove all then Delete the master inf file too!
    if (    !(OcManager->InternalFlags & OCMFLAG_USERCANCELED)
        &&  ( (OcManager->SetupMode & SETUPMODE_PRIVATE_MASK)
                == SETUPMODE_REMOVEALL )) {

        TCHAR InFSuitePath[MAX_PATH];

        // Se do it this way, so if you run remove all from the
        // orginal source location we don't blow away that copy of the
        // suite inf file.

        pOcFormSuitePath(NULL,OcManager->MasterOcInfPath,InFSuitePath);
        DeleteFile(InFSuitePath);
    }

    // free up the list of aborted components

    if (OcManager->AbortedComponentIds) {
        pSetupFree(OcManager->AbortedComponentIds);
    }

    if (OcManager->TopLevelOcStringIds) {
        pSetupFree(OcManager->TopLevelOcStringIds);
    }

    if (OcManager->TopLevelParentOcStringIds) {
        pSetupFree(OcManager->TopLevelParentOcStringIds);
    }

    //
    // free the oc manager context structure itself.
    //
    pSetupFree(OcManager);

    gLastOcManager = NULL;
}


BOOL
OcSubComponentsPresent(
    IN PVOID OcManagerContext
   )

/*++

Routine Description:

    This routine tells the caller if there are any
    subcomponents available on the details page.

Arguments:

    OcManager - supplies pointer to OC Manager context structure.

Return Value:

    TRUE = yes, there are subcomponents
    FALSE = no way

--*/

{
    POC_MANAGER OcManager = (POC_MANAGER)OcManagerContext;

    if (!OcManagerContext) {
        return FALSE;
    }
    return OcManager->SubComponentsPresent;
}


VOID
pOcDestroyPerOcData(
    IN POC_MANAGER OcManager
    )

/*++

Routine Description:

    This routine frees all data allocated as part of the per-subcomponent
    data structures. The component list string table is enumerated;
    the OPTIONAL_COMPONENT structures have several pointers for arrays
    that must be freed.

Arguments:

    OcManager - supplies pointer to OC Manager context structure.

Return Value:

    None.

--*/

{
    OPTIONAL_COMPONENT OptionalComponent;

    pSetupStringTableEnum(
        OcManager->ComponentStringTable,
        &OptionalComponent,
        sizeof(OPTIONAL_COMPONENT),
        pOcDestroyPerOcDataStringCB,
        0
        );
}


BOOL
pOcDestroyPerOcDataStringCB(
    IN PVOID               StringTable,
    IN LONG                StringId,
    IN PCTSTR              String,
    IN POPTIONAL_COMPONENT Oc,
    IN UINT                OcSize,
    IN LPARAM              Unused
    )

/*++

Routine Description:

    String table callback routine that is the worker routine for
    pOcDestroyPerOcData.

Arguments:

    Standard string table callback arguments.

Return Value:

    Always returns TRUE to continue enumeration.

--*/

{
    UNREFERENCED_PARAMETER(StringTable);
    UNREFERENCED_PARAMETER(StringId);
    UNREFERENCED_PARAMETER(String);
    UNREFERENCED_PARAMETER(OcSize);
    UNREFERENCED_PARAMETER(Unused);

    if(Oc->NeedsStringIds) {
        pSetupFree(Oc->NeedsStringIds);
    }
    if(Oc->NeededByStringIds) {
        pSetupFree(Oc->NeededByStringIds);
    }

    if (Oc->ExcludeStringIds){
        pSetupFree(Oc->ExcludeStringIds);
    }
    if(Oc->ExcludedByStringIds){
        pSetupFree(Oc->ExcludedByStringIds);
    }
    if (Oc->HelperContext) {
        pSetupFree(Oc->HelperContext);
    }

    return(TRUE);
}


BOOL
pOcClearAllErrorStatesCB(
    IN PVOID               StringTable,
    IN LONG                StringId,
    IN PCTSTR              String,
    IN POPTIONAL_COMPONENT Oc,
    IN UINT                OcSize,
    IN LPARAM              OcManager
    )
{
    UNREFERENCED_PARAMETER(StringTable);
    UNREFERENCED_PARAMETER(StringId);
    UNREFERENCED_PARAMETER(String);
    UNREFERENCED_PARAMETER(OcSize);

    OcHelperClearExternalError ((POC_MANAGER)OcManager, StringId ,0);

    return(TRUE);
}

VOID
pOcClearAllErrorStates(
    IN POC_MANAGER OcManager
    )

/*++

Routine Description:

    This routine clears out the past registry entries for error reports
    for all components

Arguments:

    OcManagerContext - in input, supplies a pointer to a context value returned
        by OcInitialize. On output, receives NULL.

Return Value:

    None.

--*/
{
    OPTIONAL_COMPONENT OptionalComponent;

    pSetupStringTableEnum(
        OcManager->ComponentStringTable,
        &OptionalComponent,
        sizeof(OPTIONAL_COMPONENT),
        pOcClearAllErrorStatesCB,
        (LPARAM)OcManager
        );


}

BOOL
pOcRemoveComponent(
    IN POC_MANAGER OcManager,
    IN LONG        ComponentId,
    IN DWORD       PhaseId
    )

/*++

Routine Description:

    This routine adds a specified component to the list of aborted components,
    preventing it's entry function from being called any more.

Arguments:

    OcManager - in input, supplies a pointer to a context value returned
        by OcInitialize. On output, receives NULL.

    ComponentId - in input, this string names the faulty component to be removed

Return Value:

    None.

--*/
{
    PVOID p;
    OPTIONAL_COMPONENT Oc;

    // test for valid component to remove

    if (ComponentId <= 0)
        return FALSE;

    if (pOcComponentWasRemoved(OcManager, ComponentId))
        return FALSE;

    // add component to list of aborted components

    if (!OcManager->AbortedCount) {
        OcManager->AbortedComponentIds = pSetupMalloc(sizeof(UINT));
        if (!OcManager->AbortedComponentIds)
            return FALSE;
    }

    OcManager->AbortedCount++;
    p = pSetupRealloc(OcManager->AbortedComponentIds, sizeof(UINT) * OcManager->AbortedCount);
    if (!p) {
        OcManager->AbortedCount--;
        return FALSE;
    }

    OcManager->AbortedComponentIds = (UINT *)p;
    OcManager->AbortedComponentIds[OcManager->AbortedCount - 1] = ComponentId;

    // stop display of component in the listbox, if it isn't too late

    pSetupStringTableGetExtraData(
        OcManager->ComponentStringTable,
        ComponentId,
        &Oc,
        sizeof(OPTIONAL_COMPONENT)
        );

    Oc.InternalFlags |= OCFLAG_HIDE;

    pSetupStringTableSetExtraData(
        OcManager->ComponentStringTable,
        ComponentId,
        &Oc,
        sizeof(OPTIONAL_COMPONENT)
        );

    _LogError(OcManager,
              OcErrLevInfo | OcErrBatch,
              MSG_OC_REMOVE_COMPONENT,
              pSetupStringTableStringFromId(OcManager->ComponentStringTable,ComponentId),
              PhaseId
              );

    return TRUE;
}

BOOL
pOcComponentWasRemoved(
    IN POC_MANAGER OcManager,
    IN LONG        ComponentId
    )

/*++

Routine Description:

    This routine indicates if a components has been aborted.

Arguments:

    OcManager - in input, supplies a pointer to a context value returned
        by OcInitialize. On output, receives NULL.

    ComponentId - in input, this string names the component to check for

Return Value:

    BOOL - true if it was aborted - else false

--*/
{
    UINT i;

    for (i = 0; i < OcManager->AbortedCount; i++) {
        if (OcManager->AbortedComponentIds[i] == ComponentId) {
            return TRUE;
        }
    }

    return FALSE;
}