windows-xp/Source/XPSP1/NT/net/config/upgrade/netupgrd/netreg.cpp

// ----------------------------------------------------------------------
//
//  Microsoft Windows NT
//  Copyright (C) Microsoft Corporation, 1997.
//
//  File:      N E T R E G . C P P
//
//  Contents:  Windows NT4.0 & 3.51 Network Registry Info Dumper
//
//  Notes:
//
//  Author:    kumarp 22-December-97
//
// ----------------------------------------------------------------------

#include "pch.h"
#pragma hdrstop
#include <ntsecapi.h>

#include "afilestr.h"
#include "conflict.h"
#include "infmap.h"
#include "kkcwinf.h"
#include "kkenet.h"
#include "kkreg.h"
#include "kkstl.h"
#include "kkutils.h"
#include "ncipaddr.h"
#include "ncmisc.h"
#include "ncreg.h"
#include "ncsetup.h"
#include "netreg.h"
#include "netupgrd.h"
#include "nustrs.h"
#include "nuutils.h"
#include "oemupg.h"
#include "resource.h"
#include "ipafval.h"
#include "winsock2.h"
#include "ws2spi.h"
#include "dhcpupg.h"

// for WLBS stuff
#include "wlbsparm.h"

// ----------------------------------------------------------------------
// external string constants

extern const WCHAR c_szAfWins[];
extern const WCHAR c_szAfForceStrongEncryption[];
extern const WCHAR c_szDrives[];
extern const WCHAR c_szInfId_MS_AppleTalk[];
extern const WCHAR c_szInfId_MS_Isotpsys[];
extern const WCHAR c_szInfId_MS_MSClient[];
extern const WCHAR c_szInfId_MS_NWIPX[];
extern const WCHAR c_szInfId_MS_NWNB[];
extern const WCHAR c_szInfId_MS_NWSPX[];
extern const WCHAR c_szInfId_MS_NetBIOS[];
extern const WCHAR c_szInfId_MS_NetBT[];
extern const WCHAR c_szInfId_MS_NwSapAgent[];
extern const WCHAR c_szInfId_MS_RasCli[];
extern const WCHAR c_szInfId_MS_RasSrv[];
extern const WCHAR c_szInfId_MS_Streams[];
extern const WCHAR c_szInfId_MS_TCPIP[];
extern const WCHAR c_szInfId_MS_WLBS[];
extern const WCHAR c_szNdisWan[];
extern const WCHAR c_szNo[];
extern const WCHAR c_szParameters[];
extern const WCHAR c_szRegKeyComponentClasses[];
extern const WCHAR c_szRegKeyServices[];
extern const WCHAR c_szRegValDependOnGroup[];
extern const WCHAR c_szRegValDependOnService[];
extern const WCHAR c_szRegValServiceName[];
extern const WCHAR c_szRegValStart[];
extern const WCHAR c_szShares[];
extern const WCHAR c_szSvcBrowser[];
extern const WCHAR c_szSvcDhcpRelayAgent[];
extern const WCHAR c_szSvcDhcpServer[];
extern const WCHAR c_szSvcLmServer[];
extern const WCHAR c_szSvcNWCWorkstation[];
extern const WCHAR c_szSvcNetBIOS[];
extern const WCHAR c_szSvcNetLogon[];
extern const WCHAR c_szSvcRasAuto[];
extern const WCHAR c_szSvcRipForIp[];
extern const WCHAR c_szSvcRipForIpx[];
extern const WCHAR c_szSvcRouter[];
extern const WCHAR c_szSvcSapAgent[];
extern const WCHAR c_szSvcWorkstation[];
extern const WCHAR c_szYes[];


// ----------------------------------------------------------------------
// string constants

const WCHAR c_szRAS[]    = L"RAS";
const WCHAR c_szRasMan[] = L"RasMan";
const WCHAR c_szRouter[] = L"Router";
const WCHAR c_szServer[] = L"Server";
const WCHAR sz_DLC[]     = L"DLC";
const WCHAR sz_MS_DLC[]  = L"MS_DLC";

// WLBS:
const WCHAR c_szWLBS[]    = L"WLBS";
const WCHAR c_szConvoy[]  = L"Convoy";
const WCHAR c_szMSWLBS[]  = L"MS_WLBS";
const WCHAR c_szMSTCPIP[] = L"MS_TCPIP";
// end WLBS:

// ----------------------------------------------------------------------
// variables

//Global

// Novell Client32 upgrades
BOOL g_fForceNovellDirCopy = FALSE;

//File scope
static TStringList *g_pslNetCard, *g_pslNetCardInstance, *g_pslNetCardAFileName;
static PCWInfSection g_pwisBindings;

// WLBS:
static WCHAR pszWlbsClusterAdapterName[16], pszWlbsVirtualAdapterName[16];
// end WLBS:

// static PCWInfSection g_pwisMSNetClient;
// static PCWInfSection g_pwisNetClients;

// used by WriteRASParams
static BOOL g_fAtLeastOneDialIn=FALSE;
static BOOL g_fAtLeastOneDialOut=FALSE;
static BOOL g_fAtLeastOneDialInUsingNdisWan=FALSE;
static BOOL g_fAtLeastOneDialOutUsingNdisWan=FALSE;


static PCWSTR g_pszServerOptimization[] =
{
    c_szAfUnknown,
    c_szAfMinmemoryused,
    c_szAfBalance,
    c_szAfMaxthroughputforfilesharing,
    c_szAfMaxthrouputfornetworkapps
};

static PCWSTR g_szNetComponentSectionName[] =
{
    c_szAfUnknown,
    c_szAfSectionNetAdapters,
    c_szAfSectionNetProtocols,
    c_szAfSectionNetServices,
    c_szAfSectionNetClients
};

// ----------------------------------------------------------------------
// Forward Declarations


BOOL WriteIdentificationInfo(IN CWInfFile *pwifAnswerFile);

BOOL WriteNetAdaptersInfo(IN CWInfFile *pwifAnswerFile);

HRESULT HrWriteNetComponentsInfo(IN CWInfFile* pwifAnswerFile);

//Protocols
BOOL WriteTCPIPParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisTCPIPGlobalParams,
                      OUT TStringList& slAdditionalParamsSections);
BOOL WriteTCPIPAdapterParams(PCWInfFile pwifAnswerFile, PCWSTR pszAdapterDriver,
                             OUT TStringList& slAdditionalParamsSections,
                             BOOL fDisabledToDhcpServer,
                             BOOL fDisableNetbios);

BOOL WriteIPXParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisIPXGlobalParams,
                    OUT TStringList& slAdditionalParamsSections);

BOOL WriteAppleTalkParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisGlobalParams,
                          OUT TStringList& slAdditionalParamsSections);

BOOL WritePPTPParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);

//Services
BOOL WriteRASParams(PCWInfFile pwifAnswerFile,
                    PCWInfSection pwisNetServices,
                    PCWInfSection pwisRASParams);
HRESULT HrWritePreSP3ComponentsToSteelHeadUpgradeParams(
        IN CWInfFile* pwifAnswerFile);

BOOL WriteNWCWorkstationParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteDhcpServerParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteTp4Params(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteWLBSParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteConvoyParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);

// the following four actually write into [params.MS_NetClient] section
BOOL WriteNetBIOSParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteBrowserParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteLanmanServerParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteLanmanWorkstationParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);
BOOL WriteRPCLocatorParams(PCWInfFile pwifAnswerFile, PCWInfSection pwisParams);

//Bindings
BOOL WriteBindings(IN PCWSTR pszComponentName);

//Helper Functions

inline WORD SwapHiLoBytes(WORD w)
{
    return ((w & 0xff) << 8) | (w >> 8);
}

BOOL
FIsDontExposeLowerComponent (
    IN PCWSTR pszInfId)
{
    return ((0 == lstrcmpiW(pszInfId, c_szInfId_MS_NWIPX) ||
        (0 == lstrcmpiW(pszInfId, c_szInfId_MS_NWNB) ||
        (0 == lstrcmpiW(pszInfId, c_szInfId_MS_NWSPX)))));
}

BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN HKEY hKey,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType = REG_SZ,
    IN PCWSTR pszValueNewName = NULL,
    IN BOOL fDefaultProvided = FALSE,
    IN ...);

BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN HKEY hKey,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    IN va_list arglist);

BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN CORegKey& rk,
    IN PCWSTR pszValueName,
    IN WORD wValueType = REG_SZ,
    IN PCWSTR pszValueNewName = NULL,
    IN BOOL fDefaultProvided = FALSE,
    ...);

BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN CORegKey& rk,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    IN va_list arglist);

BOOL
WriteServiceRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN PCWSTR pszServiceKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType = REG_SZ,
    IN PCWSTR pszValueNewName = NULL,
    IN BOOL fDefaultProvided = FALSE,
    ...);

//PCWSTR GetBusTypeName(DWORD dwBusType);
PCWSTR GetBusTypeName(INTERFACE_TYPE eBusType);
void AddToNetCardDB(IN PCWSTR pszAdapterName,
                    IN PCWSTR pszProductName,
                    IN PCWSTR pszAdapterDriver);
BOOL IsNetCardProductName(IN PCWSTR pszName);
BOOL IsNetCardInstance(IN PCWSTR pszName);
PCWSTR MapNetCardInstanceToAFileName(IN PCWSTR pszNetCardInstance);
void MapNetCardInstanceToAFileName(IN PCWSTR pszNetCardInstance,
                                   OUT tstring& strMappedName);

OUT BOOL IsNetworkComponent(IN CORegKey *prkSoftwareMicrosoft,
                            IN const tstring strComponentName);
BOOL GetServiceKey(IN PCWSTR pszServiceName, OUT PCORegKey &prkService);
BOOL GetServiceParamsKey(IN PCWSTR pszServiceName, OUT PCORegKey &prkServiceParams);
BOOL GetServiceSubkey(IN PCWSTR pszServiceName,
                      IN PCWSTR pszSubKeyName,
                      OUT PCORegKey &prkServiceSubkey);
BOOL GetServiceSubkey(IN const PCORegKey prkService,
                      IN PCWSTR pszSubKeyName,
                      OUT PCORegKey &prkServiceSubkey);
void ConvertRouteToStringList (PCWSTR pszRoute,
                               TStringList &slRoute );
BOOL StringListsIntersect(const TStringList& sl1, const TStringList& sl2);

QWORD ConvertToQWord(TByteArray ab);
VOID ConvertToByteList(TByteArray ab, tstring& str);
void ReplaceCharsInString(IN OUT PWSTR szString,
                          IN PCWSTR szFindChars, IN WCHAR chReplaceWith);
HRESULT HrNetRegSaveKey(IN HKEY hkeyBase, IN PCWSTR szSubKey,
                        IN PCWSTR szComponent,
                        OUT tstring* pstrFileName);
HRESULT HrNetRegSaveKeyAndAddToSection(IN HKEY hkeyBase, IN PCWSTR szSubKey,
                                       IN PCWSTR szComponent,
                                       IN PCWSTR szKeyName,
                                       IN CWInfSection* pwisSection);
HRESULT HrNetRegSaveServiceSubKeyAndAddToSection(IN PCWSTR szServiceName,
                                                 IN PCWSTR szServiceSubKeyName,
                                                 IN PCWSTR szKeyName,
                                                 IN CWInfSection* pwisSection);

HRESULT HrProcessOemComponentAndUpdateAfSection(
        IN  CNetMapInfo* pnmi,
        IN  HWND      hParentWindow,
        IN  HKEY      hkeyParams,
        IN  PCWSTR   szPreNT5InfId,
        IN  PCWSTR   szPreNT5Instance,
        IN  PCWSTR   szNT5InfId,
        IN  PCWSTR   szDescription,
        IN  CWInfSection* pwisParams);

HRESULT HrGetNumPhysicalNetAdapters(OUT UINT* puNumAdapters);
HRESULT HrHandleMiscSpecialCases(IN CWInfFile* pwifAnswerFile);
VOID WriteWinsockOrder(IN CWInfFile* pwifAnswerFile);

// ----------------------------------------------------------------------


static const WCHAR c_szCleanMainSection[]       = L"Clean";
static const WCHAR c_szCleanAddRegSection[]     = L"Clean.AddReg";
static const WCHAR c_szCleanDelRegSection[]     = L"Clean.DelReg";
static const WCHAR c_szCleanServicesSection[]   = L"Clean.Services";
static const WCHAR c_szAddReg[]                 = L"AddReg";
static const WCHAR c_szDelReg[]                 = L"DelReg";
static const WCHAR c_szDelService[]             = L"DelService";
static const WCHAR c_szDelRegFromSoftwareKey[]  = L"HKLM, \"Software\\Microsoft\\";
static const WCHAR c_szDelRegFromServicesKey[]  = L"HKLM, \"SYSTEM\\CurrentControlSet\\Services\\";
static const WCHAR c_szTextModeFlags[]          = L"TextModeFlags";
static const WCHAR c_szDelRegNCPA[]             = L"HKLM, \"Software\\Microsoft\\NCPA\"";

//
// List of software key names that are optional components. These are either
// new names OR old names of optional components.
//
static const PCWSTR c_aszOptComp[] =
{
    L"SNMP",
    L"WINS",
    L"SFM",
    L"DNS",
    L"SimpTcp",
    L"LPDSVC",
    L"DHCPServer",
    L"ILS",
    L"TCPUTIL",
    L"NETMONTOOLS",
    L"DSMIGRAT",
    L"MacPrint",
    L"MacSrv"
};

static const WCHAR c_szBloodHound[]  = L"Bh";
static const WCHAR c_szInfOption[]   = L"InfOption";
static const WCHAR c_szNetMonTools[] = L"NETMONTOOLS";

static const WCHAR  c_szIas[]               = L"IAS";
static const WCHAR  c_szIasVersion[]        = L"Version";


// ----------------------------------------------------------------------
//
// Function:  HrInitNetUpgrade
//
// Purpose:   Initialize netupgrd data structures.
//
// Arguments: None
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 02-December-97
//
HRESULT HrInitNetUpgrade()
{
    DefineFunctionName("HrInitNetUpgrade");

    HRESULT hr;
    DWORD   dwErrorMessageCode = IDS_E_SetupCannotContinue;

    hr = HrInitNetMapInfo();
    if (S_OK != hr)
    {
        dwErrorMessageCode = IDS_E_NetMapInfError;
    }

    //
    //  Detect presence of Novell client to trigger special-case upgrade actions
    //
    if (S_OK == hr)
    {
        if (g_NetUpgradeInfo.From.dwBuildNumber > wWinNT4BuildNumber)
        {
            // now see if client32 is installed.

            static const WCHAR c_szNovell[] = L"NetWareWorkstation";

            HKEY hkeyServices, hkeyNovell;

            hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyServices, KEY_READ, &hkeyServices);
            if (S_OK == hr)
            {
                // CONSIDER: is it better to check to see if some service is running?
                // see if Services\NetwareWorkstation key exists
                if (S_OK == HrRegOpenKeyEx(hkeyServices, c_szNovell, KEY_READ, &hkeyNovell))
                {
                    RegCloseKey(hkeyNovell);
                    g_fForceNovellDirCopy = TRUE;
                }
                RegCloseKey(hkeyServices);
            }
            else
            {
                hr = S_OK;      // no NetWare.
            }
        }
    }

    if (S_OK == hr)
    {
        UINT cNumConflicts;

        hr = HrGenerateConflictList(&cNumConflicts);

        if (S_OK == hr)
        {
            if ((cNumConflicts > 0) || g_fForceNovellDirCopy)
            {
                hr = HrInitAndProcessOemDirs();
                if (FAILED(hr))
                {
                    dwErrorMessageCode = IDS_E_InitAndProcessOemDirs;
                }
            }
        }
        else
        {
            dwErrorMessageCode = IDS_E_GenUpgradeConflictList;
        }
    }

    if( S_OK == hr )
    {
        //
        // Handle special-cased DHCP upgrade code to convert from
        // old format databases to current ESE format.
        //

        dwErrorMessageCode = DhcpUpgConvertDhcpDbToTemp();
        hr = HRESULT_FROM_WIN32(dwErrorMessageCode);
        TraceError( "DhcpUpgConvertDhcpDbToTemp", hr );

        if( FAILED(hr) )
        {
            dwErrorMessageCode = IDS_E_DhcpServerUpgradeError;
        }
    }
            
        
    if (FAILED(hr))
    {
        AbortUpgradeId(DwWin32ErrorFromHr(hr), dwErrorMessageCode);
    }

    TraceError(__FUNCNAME__, hr);
    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  MapNetComponentNameForBinding
//
// Purpose:   Map component name to proper answerfile token so that it can
//            be used in a binding path
//            (e.g. IEEPRO3 --> Adapter02)
//
// Arguments:
//    pszComponentName [in]  constTString object name of name of
//    strMappedName    [out] name of name of
//
// Returns:   None
//
// Author:    kumarp 17-December-97
//
VOID
MapNetComponentNameForBinding (
    IN PCWSTR pszComponentName,
    OUT tstring &strMappedName)
{
    if (IsNetCardInstance(pszComponentName))
    {
        MapNetCardInstanceToAFileName(pszComponentName, strMappedName);
    }
    else
    {
        HRESULT hr;

        hr = HrMapPreNT5NetComponentServiceNameToNT5InfId(
                pszComponentName,
                &strMappedName);
        if (S_OK != hr)
        {
            strMappedName = c_szAfUnknown;
        }
    }
}

// ----------------------------------------------------------------------
//
// Function:  FIsOptionalComponent
//
// Purpose:   Determine if a component is an optional component
//
// Arguments:
//    pszName [in]  name of component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 02-December-97
//
BOOL FIsOptionalComponent(
    PCWSTR pszName)
{
    BOOL    fIsOc;

    fIsOc = FIsInStringArray(c_aszOptComp, celems(c_aszOptComp), pszName);
    if (!fIsOc)
    {
        // BUG #148890 (danielwe) 13 Mar 1998: Special case check for NetMon
        // (bloodhound). If component name is "Bh", open its NetRules key (if
        // it exists) and see if it was installed as NETMONTOOLS which means
        // it was the NetMon tools optional component

        if (!lstrcmpiW (pszName, c_szBloodHound))
        {
            tstring strNetRules;
            HKEY    hkeyBh;

            strNetRules = L"Software\\Microsoft\\";
            strNetRules += pszName;
            strNetRules += L"\\CurrentVersion\\NetRules";

            if (SUCCEEDED(HrRegOpenKeyEx(HKEY_LOCAL_MACHINE,
                                         strNetRules.c_str(), KEY_READ,
                                         &hkeyBh)))
            {
                tstring     strOption;

                if (SUCCEEDED(HrRegQueryString(hkeyBh, c_szInfOption,
                                               &strOption)))
                {
                    if (!lstrcmpiW(strOption.c_str(), c_szNetMonTools))
                    {
                        fIsOc = TRUE;
                    }
                }

                RegCloseKey(hkeyBh);
            }
        }
    }

    return fIsOc;
}

static const WCHAR c_szRegKeyOc[]           = L"Software\\Microsoft\\Windows\\CurrentVersion\\Setup\\OptionalComponents";
static const WCHAR c_szInstalled[]          = L"Installed";
static const WCHAR c_szOcIsInstalled[]      = L"1";
extern const WCHAR c_szOcMainSection[];

static const WCHAR c_szSfm[]                = L"SFM";
static const WCHAR c_szMacSrv[]             = L"MacSrv";
static const WCHAR c_szMacPrint[]           = L"MacPrint";
static const WCHAR c_szRegKeyOcmSubComp[]   = L"Software\\Microsoft\\Windows\\CurrentVersion\\Setup\\OC Manager\\Subcomponents";
static const WCHAR c_szRegKeyCmak[]         = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\CMAK.EXE";
static const WCHAR c_szRegValueCpsSrv[]     = L"CPSSRV";
static const WCHAR c_szRegValueCpsAd[]      = L"CPSAD";
static const WCHAR c_szNetCm[]              = L"NETCM";

static const TCHAR c_szRegKeyIAS[]          = TEXT("SYSTEM\\CurrentControlSet\\Services\\AuthSrv\\Parameters");

//+---------------------------------------------------------------------------
//
//  Function:   WriteNt5OptionalComponentList
//
//  Purpose:    Writes the list of optional components that were installed
//              prior to upgrading from an NT5 build.
//
//  Arguments:
//      pwifAnswerFile [in]     Answer file object
//
//  Returns:    TRUE if success, FALSE if not.
//
//  Author:     danielwe   8 Jan 1998
//
//  Notes:
//
BOOL WriteNt5OptionalComponentList(IN CWInfFile *pwifAnswerFile)
{
    HRESULT         hr = S_OK;
    PCWInfSection   pwisMain;

    // Add section "[OldOptionalComponents]"
    pwisMain = pwifAnswerFile->AddSectionIfNotPresent(c_szOcMainSection);
    if (!pwisMain)
    {
        hr = E_FAIL;
    }

    if (SUCCEEDED(hr))
    {
        CORegKey        rkOc(HKEY_LOCAL_MACHINE, c_szRegKeyOc, KEY_READ);
        CORegKeyIter    rkOcIter(rkOc);
        tstring         strOcName;

        // loop over each subkey in the OptionalComponents tree
        while (!rkOcIter.Next(&strOcName))
        {
            if (!FIsOptionalComponent(strOcName.c_str()))
            {
                continue;
            }

            HKEY    hkeyOc;
            hr = HrRegOpenKeyEx(rkOc.HKey(), strOcName.c_str(),
                                KEY_READ, &hkeyOc);
            if (SUCCEEDED(hr))
            {
                ULONG   fInstalled;

                hr = HrRegQueryStringAsUlong(hkeyOc, c_szInstalled, 10,
                                             &fInstalled);
                if (SUCCEEDED(hr) ||
                    HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
                {
                    hr = S_OK;

                    if (fInstalled)
                    {
                        if (!lstrcmpiW(strOcName.c_str(), c_szSfm))
                        {
                            // Special case the SFM component because
                            // it got split into 2
                            pwisMain->AddKey(c_szMacSrv,
                                             c_szOcIsInstalled);
                            pwisMain->AddKey(c_szMacPrint,
                                             c_szOcIsInstalled);
                        }
                        else
                        {
                            pwisMain->AddKey(strOcName.c_str(),
                                             c_szOcIsInstalled);
                        }
                    }
                }

                RegCloseKey(hkeyOc);
            }
        }
    }

    TraceError("WriteNt5OptionalComponentList", hr);
    return SUCCEEDED(hr);
}

//+---------------------------------------------------------------------------
//
//  Function:   HandlePostConnectionsSfmOcUpgrade
//
//  Purpose:    Handles the upgrade of the SFM optional component which was
//              split into 2 different components. This only applies to
//              post connections builds (1740+).
//
//  Arguments:
//      pwifAnswerFile [in]      Answer file object
//
//  Returns:    TRUE
//
//  Author:     danielwe   3 Feb 1998
//
//  Notes:      If SFM was previously installed, write out MacSrv and MacPrint
//              to the answer file in its place.
//
BOOL HandlePostConnectionsSfmOcUpgrade(IN CWInfFile *pwifAnswerFile)
{
    HKEY    hkeyOc;

    if (SUCCEEDED(HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyOcmSubComp,
                                 KEY_READ, &hkeyOc)))
    {
        DWORD   dwSfm;

        if (SUCCEEDED(HrRegQueryDword(hkeyOc, c_szSfm, &dwSfm)))
        {
            if (dwSfm == 1)
            {
                PCWInfSection   pwisMain;

                pwisMain = pwifAnswerFile->AddSectionIfNotPresent(c_szOcMainSection);
                if (pwisMain)
                {
                    pwisMain->AddKey(c_szMacSrv, c_szOcIsInstalled);
                    pwisMain->AddKey(c_szMacPrint, c_szOcIsInstalled);
                }
            }
        }

        RegCloseKey(hkeyOc);
    }

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Function:   HrWriteConfigManagerOptionalComponents
//
//  Purpose:    Special case for writing config manager components to the
//              answer file.
//
//  Arguments:
//      pwifAnswerFile [in]      Answer file object
//
//  Returns:    S_OK if success, otherwise an error code
//
//  Author:     danielwe   1 May 1998
//
//  Notes:
//
HRESULT HrWriteConfigManagerOptionalComponents(CWInfFile *pwifAnswerFile)
{
    HRESULT         hr = S_OK;
    HKEY            hkeyCmak;
    HKEY            hkeyOcm;
    PCWInfSection   pwisMain;
    BOOL            fFoundCmComponent = FALSE;

    pwisMain = pwifAnswerFile->FindSection(c_szOcMainSection);

    if (SUCCEEDED(HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyCmak, KEY_READ,
                                 &hkeyCmak)))
    {
        fFoundCmComponent = TRUE;
        RegCloseKey(hkeyCmak);
    }

    if (SUCCEEDED(HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyOcmSubComp,
                                 KEY_READ, &hkeyOcm)))
    {
        DWORD   dwValue;

        if (SUCCEEDED(HrRegQueryDword(hkeyOcm, c_szRegValueCpsSrv, &dwValue)))
        {
            if (dwValue)
            {
                fFoundCmComponent = TRUE;
            }
        }

        if (SUCCEEDED(HrRegQueryDword(hkeyOcm, c_szRegValueCpsAd, &dwValue)))
        {
            if (dwValue)
            {
                fFoundCmComponent = TRUE;
            }
        }

        RegCloseKey(hkeyOcm);
    }

    //  If we found any one of the three CM components, then we want to install the suite of
    //  all three components.
    //
    if (fFoundCmComponent)
    {
        pwisMain->AddKey(c_szNetCm, c_szOcIsInstalled);
    }

    TraceError("HrWriteConfigManagerOptionalComponents", hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   HrWriteIASOptionalComponents
//
//  Purpose:    Special case for writing IAS component to the
//              answer file.
//
//  Arguments:
//      pwifAnswerFile [in]      Answer file object
//
//  Returns:    S_OK if success, otherwise an error code
//
//  Author:     tperraut (T.P. comments) Feb 22 1999
//
//  Notes:      03/31/2000 tperraut: do not check the content of the Version 
//              string anymore: all NT4 IAS should get upgraded
//
HRESULT HrWriteIASOptionalComponents(CWInfFile *pwifAnswerFile)
{
    HRESULT         hr;
    HKEY            hkeyIAS;

    PCWInfSection pwisMain = pwifAnswerFile->FindSection(c_szOcMainSection);

    if (SUCCEEDED(HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyIAS, KEY_READ,
                                 &hkeyIAS)))
    {
        tstring     strVersion;
        hr = HrRegQueryString(hkeyIAS, c_szIasVersion, &strVersion);

        if (S_OK == hr)
        {
            pwisMain->AddKey(c_szIas, c_szOcIsInstalled);
        }

        RegCloseKey(hkeyIAS);
    }
    else
    {
        hr = E_FAIL;
    }

    TraceError("HrWriteIASOptionalComponents", hr);
    return      hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrWriteNt4OptionalComponentList
//
// Purpose:   Writes the list of optional components that were installed
//            if upgrading from NT4.
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//    slNetOcList    [in]  list of optional components
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 02-December-97
//
HRESULT
HrWriteNt4OptionalComponentList (
    IN CWInfFile *pwifAnswerFile,
    IN const TStringList &slNetOcList)
{
    HRESULT         hr = S_OK;
    PCWInfSection   pwisMain;

    pwisMain = pwifAnswerFile->AddSectionIfNotPresent(c_szOcMainSection);
    if (!pwisMain)
    {
        hr = E_FAIL;
    }
    if (SUCCEEDED(hr))
    {
        TStringListIter     iter;
        tstring             strTemp;

        for (iter = slNetOcList.begin(); iter != slNetOcList.end(); iter++)
        {
            strTemp = **iter;
            if (!lstrcmpiW(strTemp.c_str(), c_szSfm))
            {
                // Special case the SFM component because it got split into 2
                pwisMain->AddKey(c_szMacSrv, c_szOcIsInstalled);
            }
            else if (!lstrcmpiW(strTemp.c_str(), c_szBloodHound))
            {
                // Special case NetMon. If tools were installed via the "Bh"
                // component of NT4, write this out as NETMONTOOLS=1 in the
                // answer file.
                pwisMain->AddKey(c_szNetMonTools, c_szOcIsInstalled);
            }
            else
            {
                pwisMain->AddKey(strTemp.c_str(), c_szOcIsInstalled);
            }
        }
        // tperraut
        hr = HrWriteIASOptionalComponents(pwifAnswerFile);

        hr = HrWriteConfigManagerOptionalComponents(pwifAnswerFile);
    }

    TraceError("HrWriteNt4OptionalComponentList", hr);
    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrWriteMainCleanSection
//
// Purpose:   Write [Clean] section in the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 02-December-97
//
// Notes:     The [Clean] section holds data that controls what is deleted
//            at the start of GUI mode setup
//
HRESULT
HrWriteMainCleanSection (
    IN CWInfFile *pwifAnswerFile)
{
    HRESULT         hr = S_OK;
    PCWInfSection   pwisMain;

    // Add section "[Clean]"
    pwisMain = pwifAnswerFile->AddSection(c_szCleanMainSection);
    if (!pwisMain)
    {
        hr = E_FAIL;
    }

    if (SUCCEEDED(hr))
    {
        pwisMain->AddKey(c_szDelReg, c_szCleanDelRegSection);
    }

    TraceError("HrWriteMainCleanSection", hr);
    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrGetListOfServicesNotToBeDeleted
//
// Purpose:   Generate list of services that should not be deleted
//            during upgrade.
//
// Arguments:
//    pmszServices [out] pointer to multisz list of services
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 02-December-97
//
// Notes:     This info is read from netupg.inf file
//
HRESULT
HrGetListOfServicesNotToBeDeleted (
    OUT PWSTR* pmszServices)
{
    AssertValidWritePtr(pmszServices);

    HRESULT hr;
    HINF hinf;

    *pmszServices = NULL;

    hr = HrOpenNetUpgInfFile(&hinf);
    if (S_OK == hr)
    {
        INFCONTEXT ic;

        hr = HrSetupFindFirstLine(
                hinf,
                L"UpgradeData",
                L"ServicesNotToBeDeletedDuringUpgrade",
                &ic);

        if (S_OK == hr)
        {
            hr = HrSetupGetMultiSzFieldWithAlloc(ic, 1, pmszServices);
        }

        SetupCloseInfFile(hinf);
    }

    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  GetNetworkServicesList
//
// Purpose:   Generate list of net services
//
// Arguments:
//    slNetServices           [out] list of net services
//    slNetOptionalComponents [out] list of optional components found
//
// Returns:   None
//
// Author:    kumarp 02-December-97
//
void
GetNetworkServicesList (
    OUT TStringList& slNetServices,
    OUT TStringList& slNetOptionalComponents)
{
    DefineFunctionName("GetNetworkServicesList");

    HRESULT hr=S_OK;

    tstring strNetComponentName;
    tstring strServiceName;

    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    if (g_NetUpgradeInfo.From.dwBuildNumber <= wWinNT4BuildNumber)
    {
        // found Pre-NT5 networking, collect list by enumerating over
        // the registry

        CORegKey rkSoftwareMicrosoft(HKEY_LOCAL_MACHINE, c_szRegKeySoftwareMicrosoft,
                                     KEY_READ);
        if (!rkSoftwareMicrosoft.HKey())
        {
            TraceTag(ttidError, "%s: Error reading HKLM\\%S", __FUNCNAME__,
                     c_szRegKeySoftwareMicrosoft);
            hr = E_FAIL;
            goto return_from_function;
        }

        CORegKeyIter* prkiNetComponents = new CORegKeyIter(rkSoftwareMicrosoft);

        if(prkiNetComponents) {
            // mbend - this is not great, but it should get Prefix to shutup

            while (!prkiNetComponents->Next(&strNetComponentName))
            {
                if (FIsOptionalComponent(strNetComponentName.c_str()))
                {
                    AddAtEndOfStringList(slNetOptionalComponents, strNetComponentName);
                }

                // any software that has a NetRules key under the CurrentVersion
                // key is a network component
                if (!IsNetworkComponent(&rkSoftwareMicrosoft, strNetComponentName))
                {
                    continue;
                }

                CORegKey rkNetComponent(rkSoftwareMicrosoft,
                                        (strNetComponentName +
                                         L"\\CurrentVersion").c_str());
                if (!((HKEY) rkNetComponent))
                {
                    continue;
                }

                strServiceName.erase();
                rkNetComponent.QueryValue(c_szRegValServiceName, strServiceName);

                if (!strServiceName.empty())
                {
                    AddAtEndOfStringList(slNetServices, strServiceName);
                }
            }
        }
        hr = S_OK;
    }

    // with the above algorithm we do not catch all networking components
    // because there are certain networking servies such as NetBIOSInformation
    // that have entry under service but not under software\microsoft
    // for such components, we use the following rule
    // if a serice under CurrentControlSet\Sevices has a Linkage sub key
    // then it is considered as a networking service
    //
    HKEY hkeyServices;
    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyServices,
                        KEY_READ, &hkeyServices);
    if (S_OK == hr)
    {
        WCHAR szBuf[MAX_PATH];
        FILETIME time;
        DWORD dwSize;
        DWORD dwRegIndex;
        HKEY hkeyService;
        HKEY hkeyLinkage;
        BOOL fHasLinkageKey;

        for (dwRegIndex = 0, dwSize = celems(szBuf);
             S_OK == HrRegEnumKeyEx(hkeyServices, dwRegIndex, szBuf,
                        &dwSize, NULL, NULL, &time);
             dwRegIndex++, dwSize = celems(szBuf))
        {
            Assert(*szBuf);

            hr = HrRegOpenKeyEx(hkeyServices, szBuf, KEY_READ, &hkeyService);
            if (hr == S_OK)
            {
                //
                // 399641: instead of using Linkage, we use Linkage\Disabled.
                //
                hr = HrRegOpenKeyEx(hkeyService, c_szLinkageDisabled, KEY_READ, &hkeyLinkage);
                fHasLinkageKey = (S_OK == hr);
                RegSafeCloseKey(hkeyLinkage);

                if (fHasLinkageKey && !FIsInStringList(slNetServices, szBuf))
                {
                    slNetServices.push_back(new tstring(szBuf));
                }

                RegCloseKey (hkeyService);
            }
        }

        RegCloseKey(hkeyServices);
    }

return_from_function:
    TraceError(__FUNCNAME__, hr);
}

// REVIEW$ (shaunco)
// This is a list of drivers/services that were disabled (via TextModeFlags)
// but not deleted.  Thus, the purpose was just to prevent these from
// starting during GUI mode.  That is now handled automatically by the
// service controller, so the only things from this list which we might have
// an issue with are those that are system-start.
//
static const PCWSTR c_aszServicesToDisable[] =
{
    L"Afd",
    L"CiFilter",
    L"ClipSrv",
    L"DHCP",
    L"DigiFEP5",
    L"IpFilterDriver"
    L"LicenseService",
    L"NdisTapi",
    L"NetDDE",
    L"NetDDEdsdm",
    L"Pcimac",
    L"RasAcd",
    L"RasArp",
    L"Telnet",
    L"ftpsvc",
    L"gophersvc",
    L"msftpsvc",
    L"ntcx",
    L"ntepc",
    L"ntxall",
    L"ntxem",
    L"raspptpf",
    L"w3svc",
    L"wuser32",
};

HRESULT
HrPrepareServiceForUpgrade (
    IN PCWSTR pszServiceName,
    IN PCWSTR pmszServicesNotToBeDeleted,
    IN CWInfSection* pwisDelReg,
    IN CWInfSection* pwisDelService,
    IN CWInfSection* pwisStartTypes)
{
    Assert (pszServiceName);
    Assert (pmszServicesNotToBeDeleted);
    Assert (pwisDelReg);
    Assert (pwisDelService);
    Assert (pwisStartTypes);

    HRESULT hr;
    HKEY hkey;
    DWORD dwValue;
    WCHAR szBuf [_MAX_PATH];
    BOOL fDelete;

    fDelete = !FIsSzInMultiSzSafe (pszServiceName, pmszServicesNotToBeDeleted) &&
              FCanDeleteOemService (pszServiceName);

    if (fDelete)
    {
        // Remove from the software hive if present.
        //
        wcscpy (szBuf, c_szDelRegFromSoftwareKey);
        wcscat (szBuf, pszServiceName);
        wcscat (szBuf, L"\"");
        pwisDelReg->AddRawLine (szBuf);
    }

    hr = HrRegOpenServiceKey (pszServiceName, KEY_READ_WRITE, &hkey);
    if (S_OK == hr)
    {
        // Save the start type so that we can restore it after we reinstall
        // the service for Windows 2000.
        //
        hr = HrRegQueryDword (hkey, c_szRegValStart, &dwValue);
        if (S_OK == hr)
        {
            pwisStartTypes->AddKey (pszServiceName, dwValue);
        }

        if (fDelete)
        {
            hr = HrRegQueryDword (hkey, c_szType, &dwValue);
            if (S_OK == hr)
            {
                if (dwValue & SERVICE_ADAPTER)
                {
                    // Pseudo service on NT4.  We have to delete this with
                    // a DelReg, not a DelService.
                    //
                    wcscpy (szBuf, c_szDelRegFromServicesKey);
                    wcscat (szBuf, pszServiceName);
                    wcscat (szBuf, L"\"");
                    pwisDelReg->AddRawLine (szBuf);
                }
                else
                {
                    pwisDelService->AddKey(c_szDelService, pszServiceName);
                }

                // Since we will be deleting it during GUI mode, we need to
                // ensure that it gets set to disabled during text mode so
                // that (in the event it is a SYSTEM_START driver) it does
                // not get started during GUI mode before we can delete it.
                //
                (VOID) HrRegSetDword (hkey, c_szTextModeFlags, 0x4);
            }
        }

        RegCloseKey (hkey);
    }
    else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
    {
        // Not a service.  We'll remove from the software key.
        //
        hr = S_OK;
    }

    TraceHr (ttidError, FAL, hr, FALSE, "HrPrepareServiceForUpgrade");
    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  WriteDisableServicesList
//
// Purpose:   Determine which services need to be disabled during ugprade and
//            write proper info to the answerfile to make that happen.
//            The set of such services consists of
//            - network component services AND
//            - services that depend of atleast one net-service
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteDisableServicesList (
    IN CWInfFile *pwifAnswerFile)
{
    HRESULT hr = S_OK;
    TStringList slNetServices;
    TStringList slNetOcList;
    TStringListIter iter;
    tstring* pstrServiceName;
    CWInfSection* pwisDelReg;
    CWInfSection* pwisDelService;
    CWInfSection* pwisStartTypes;
    PWSTR pmszServicesNotToBeDeleted;

    // We should only be here if we are upgrading from from NT4 or earlier.
    //
    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    Assert (g_NetUpgradeInfo.From.dwBuildNumber <= wWinNT4BuildNumber)

    // First, collect all network services and optional components.
    //
    GetNetworkServicesList(slNetServices, slNetOcList);

    hr = HrWriteNt4OptionalComponentList(pwifAnswerFile, slNetOcList);
    if (FAILED(hr))
    {
        goto finished;
    }

    pwisDelReg     = pwifAnswerFile->AddSectionIfNotPresent(c_szCleanDelRegSection);
    pwisDelService = pwifAnswerFile->AddSectionIfNotPresent(c_szCleanServicesSection);
    pwisStartTypes = pwifAnswerFile->AddSectionIfNotPresent(c_szAfServiceStartTypes);

    if (!pwisDelReg || !pwisDelService || !pwisStartTypes)
    {
        hr = E_OUTOFMEMORY;
        goto finished;
    }

    hr = HrGetListOfServicesNotToBeDeleted(&pmszServicesNotToBeDeleted);

    if (S_OK == hr)
    {
        pwisDelReg->AddRawLine(c_szDelRegNCPA);

        for (iter =  slNetServices.begin();
             iter != slNetServices.end();
             iter++)
        {
            pstrServiceName = *iter;
            Assert (pstrServiceName);

            hr = HrPrepareServiceForUpgrade (
                    pstrServiceName->c_str(),
                    pmszServicesNotToBeDeleted,
                    pwisDelReg,
                    pwisDelService,
                    pwisStartTypes);

            if (S_OK != hr)
            {
                break;
            }
        }

        MemFree (pmszServicesNotToBeDeleted);
    }

finished:
    EraseAndDeleteAll(&slNetOcList);
    EraseAndDeleteAll(&slNetServices);

    TraceError("WriteDisableServicesList", hr);
    return SUCCEEDED(hr);
}

extern const DECLSPEC_SELECTANY WCHAR c_szRegNetKeys[] = L"System\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}";
extern const DECLSPEC_SELECTANY WCHAR c_szRegKeyConFmt[] = L"System\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection";
extern const DECLSPEC_SELECTANY WCHAR c_szafNICsWithIcons[] = L"NetworkAdaptersWithIcons";
static const WCHAR c_szShowIcon[]  = L"ShowIcon";


// ----------------------------------------------------------------------
//
// Function:  WritePerAdapterInfoForNT5
//
// Purpose:   Determine which services need to be disabled during ugprade from 
//            Windows 2000 and write proper info to the answerfile to make that happen.
//            The set of such services consists of
//            - network component services
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    deonb  10-July-2000
//
BOOL
WritePerAdapterInfoForNT5 (
    IN CWInfFile *pwifAnswerFile)
{
    HRESULT hr = S_OK;
    HKEY    hkey;
    
    // Check for the existence of the connection sub-key
    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegNetKeys, KEY_READ, &hkey);
    if (SUCCEEDED(hr))
    {
        DWORD    dwIndex(0);
        TCHAR    szName[MAX_PATH+1];
        DWORD    dwSize(MAX_PATH);
        FILETIME ftLastWriteTime;
        DWORD    dwRetVal(0);

        do
        {
            dwRetVal = RegEnumKeyEx(hkey, dwIndex, szName, &dwSize, NULL, NULL, NULL, &ftLastWriteTime);
            if ( ERROR_SUCCESS == dwRetVal )
            {
                TCHAR szRegKey[MAX_PATH+1];
                swprintf(szRegKey, c_szRegKeyConFmt, szName);

                HKEY hkeyConnection;
                hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, szRegKey, KEY_READ, &hkeyConnection);
                if (SUCCEEDED(hr))
                {
                    DWORD dwValue;
                    HRESULT hr = HrRegQueryDword(hkeyConnection, c_szShowIcon, &dwValue);
                    if (SUCCEEDED(hr) && dwValue)
                    {
                        CWInfSection* pwisStartTypes;
                        pwisStartTypes = pwifAnswerFile->AddSectionIfNotPresent(c_szafNICsWithIcons);
                        if (!pwisStartTypes)
                        {
                            hr = E_OUTOFMEMORY;
                        }
                        else
                        {
                            pwisStartTypes->AddKey (szName, 1);
                        }
                        
                    }
                    RegSafeCloseKey(hkeyConnection);
                }
            }
        } while ( (ERROR_SUCCESS == dwRetVal) && (SUCCEEDED(hr)) );


        RegSafeCloseKey(hkey);
    }

    TraceError("WritePerAdapterInfoForNT5", hr);
    return SUCCEEDED(hr);
}

// ----------------------------------------------------------------------
//
// Function:  WriteDisableServicesListForNT5
//
// Purpose:   Determine which services need to be disabled during ugprade from 
//            Windows 2000 and write proper info to the answerfile to make that happen.
//            The set of such services consists of
//            - network component services
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    deonb  10-July-2000
//
BOOL
WriteDisableServicesListForNT5 (
    IN CWInfFile *pwifAnswerFile)
{
    static PCWSTR c_aszNT5UpgrdCheckComponents[] =
    {
        L"Browser",
        L"LanmanServer",
        c_szSvcDhcpServer
    };

    HRESULT hr = S_OK;

    PCWSTR pstrServiceName;
    CWInfSection* pwisStartTypes;
    PWSTR pmszServicesNotToBeDeleted;

    // We should only be here if we are upgrading from NT5 or later.
    //
    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    Assert (g_NetUpgradeInfo.From.dwBuildNumber > wWinNT4BuildNumber)

    // First, collect all network services and optional components.
    //
    pwisStartTypes = pwifAnswerFile->AddSectionIfNotPresent(c_szAfServiceStartTypes);
    if (!pwisStartTypes)
    {
        hr = E_OUTOFMEMORY;
        goto finished;
    }

    if (S_OK == hr)
    {
        DWORD x;
        for (x = 0, pstrServiceName = c_aszNT5UpgrdCheckComponents[0];
                   x < sizeof(c_aszNT5UpgrdCheckComponents)/sizeof(c_aszNT5UpgrdCheckComponents[0]); 
                   x++, pstrServiceName = c_aszNT5UpgrdCheckComponents[x])
        {
            Assert (pstrServiceName);

            HKEY hkey;
            hr = HrRegOpenServiceKey (pstrServiceName, KEY_READ, &hkey);
            if (S_OK == hr)
            {
                // Save the start type (only if disabled) so that we can restore it after we install
                // the service for Windows 2000.
                DWORD dwValue;
                hr = HrRegQueryDword (hkey, c_szRegValStart, &dwValue);
                if ( (S_OK == hr) && (SERVICE_DISABLED == dwValue) )
                {
                    pwisStartTypes->AddKey (pstrServiceName, dwValue);
                }
                
                RegCloseKey (hkey);
            }
        }
    }

finished:
    TraceError("WriteDisableServicesListNT5", hr);
    return SUCCEEDED(hr);
}


// ----------------------------------------------------------------------
//
// Function:  GetProductTypeStr
//
// Purpose:   Get string representation of PRODUCTTYPE
//
// Arguments:
//    pt [in]  Product type
//
// Returns:   pointer to string representation of PRODUCTTYPE
//
// Author:    kumarp 03-December-97
//
PCWSTR
GetProductTypeStr (
    IN PRODUCTTYPE pt)
{
    PCWSTR szProductType;

    switch(pt)
    {
    case NT_WORKSTATION:
        szProductType = c_szAfNtWorkstation;
        break;

    case NT_SERVER:
        szProductType = c_szAfNtServer;
        break;

    default:
        szProductType = NULL;
        break;
    }

    return szProductType;
}

// ----------------------------------------------------------------------
//
// Function:  WriteNetComponentsToRemove
//
// Purpose:   Write the network components in the answerfile
//            that will be removed.
//
// Arguments:
//    pwisNetworking [in]  pointer to [Networking] section
//
// Returns:   none
//
// Author:    asinha 29-March-2001
//
void WriteNetComponentsToRemove (IN CWInfSection* pwisNetworking)
{

    DefineFunctionName("WriteNetComponentsToRemove");
    TraceFunctionEntry(ttidNetUpgrade);

    TraceTag(ttidNetUpgrade, "netupgrd.dll: WriteNetComponentsToRemove");

    if ( ShouldRemoveDLC(NULL, NULL) )
    {
        PCWInfKey  pwisKey;
        TStringList slNetComponentsToRemove;

        pwisKey = pwisNetworking->FindKey(c_szAfNetComponentsToRemove,
                                          ISM_FromBeginning);

        if ( pwisKey )
        {
            // Read the old value of NetComponentsToRemove

            pwisKey->GetStringListValue(slNetComponentsToRemove);
        }
        else
        {
            pwisKey = pwisNetworking->AddKey(c_szAfNetComponentsToRemove);
        }

        // Make sure to write the new infId/PnpId.

        AddAtEndOfStringList(slNetComponentsToRemove,
                             sz_MS_DLC);

        pwisKey->SetValue( slNetComponentsToRemove );
    }

    return;
}



// ----------------------------------------------------------------------
//
// Function:  WriteProductTypeInfo
//
// Purpose:   Write product-type info to the answerfile
//
// Arguments:
//    pwisNetworking [in]  pointer to [Networking] section
//
// Returns:   none
//
// Author:    kumarp 03-December-97
//
void
WriteProductTypeInfo (
    IN CWInfSection* pwisNetworking)
{
    PCWSTR pszProduct;

    pszProduct = GetProductTypeStr(g_NetUpgradeInfo.From.ProductType);

    Assert(pszProduct);

    //UpgradeFromProduct
    pwisNetworking->AddKey(c_szAfUpgradeFromProduct, pszProduct);

    //BuildNumber
    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    pwisNetworking->AddKey(c_szAfBuildNumber, g_NetUpgradeInfo.From.dwBuildNumber);
}

// ----------------------------------------------------------------------
//
// Function:  WriteNetworkInfoToAnswerFile
//
// Purpose:   Write information about current network components
//            to the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteNetworkInfoToAnswerFile (
    IN CWInfFile *pwifAnswerFile)
{
    DefineFunctionName("WriteNetworkInfoToAnswerFile");

    BOOL status=FALSE;

    g_pslNetCard = new TStringList;
    g_pslNetCardInstance = new TStringList;
    g_pslNetCardAFileName = new TStringList;

    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    if ((g_NetUpgradeInfo.From.dwBuildNumber <= wWinNT4BuildNumber) &&
        !FIsPreNT5NetworkingInstalled())
    {
        // this is NT4 or earlier and networking is not installed
        // dont need to dump answerfile

        TraceTag(ttidNetUpgrade, "%s: Networking is not installed, "
                 "answerfile will not be dumped", __FUNCNAME__);

        goto return_from_function;
    }

    CWInfSection* pwisNetworking;

    pwisNetworking =
        pwifAnswerFile->AddSectionIfNotPresent(c_szAfSectionNetworking);

    //The order in which these functions are called is important
    //DO NOT change it
    WriteProductTypeInfo(pwisNetworking);
    status = WriteNt5OptionalComponentList(pwifAnswerFile);
    status = HandlePostConnectionsSfmOcUpgrade(pwifAnswerFile);

    WriteNetComponentsToRemove(pwisNetworking);

    if (g_NetUpgradeInfo.From.dwBuildNumber > wWinNT4BuildNumber)
    {
        status = WriteDisableServicesListForNT5(pwifAnswerFile);
        status = WritePerAdapterInfoForNT5(pwifAnswerFile);

        // we dont want netsetup to process other sections
        //
        pwisNetworking->AddBoolKey(c_szAfProcessPageSections, FALSE);

        //for NT5 to NT5 upgrade, no need to dump other info
        //
        goto return_from_function;
    }

    //  we want netsetup to process other sections
    //
    pwisNetworking->AddBoolKey(c_szAfProcessPageSections, TRUE);

    (void) HrWriteMainCleanSection(pwifAnswerFile);

    status = WriteIdentificationInfo(pwifAnswerFile);
    status = WriteNetAdaptersInfo(pwifAnswerFile);

    pwifAnswerFile->GotoEnd();

    g_pwisBindings = pwifAnswerFile->AddSection(c_szAfSectionNetBindings);
    g_pwisBindings->AddComment(L"Only the disabled bindings are listed");

    HrWriteNetComponentsInfo(pwifAnswerFile);

    status = WriteDisableServicesList(pwifAnswerFile);

    (void) HrHandleMiscSpecialCases(pwifAnswerFile);

    WriteWinsockOrder(pwifAnswerFile);

return_from_function:
    EraseAndDeleteAll(g_pslNetCard);
    EraseAndDeleteAll(g_pslNetCardInstance);
    EraseAndDeleteAll(g_pslNetCardAFileName);

    DeleteIfNotNull(g_pslNetCard);
    DeleteIfNotNull(g_pslNetCardInstance);
    DeleteIfNotNull(g_pslNetCardAFileName);

    return status;
}

//+---------------------------------------------------------------------------
//
//  Function:   WriteWinsockOrder
//
//  Purpose:    Records the order of winsock providers in NT4 so that they
//              can be restored after upgrade.
//
//  Arguments:
//      pwifAnswerFile [in]     Answer file structure
//
//  Returns:    Nothing
//
//  Author:     danielwe   1 Jun 1999
//
//  Notes:
//
VOID WriteWinsockOrder (
    IN CWInfFile* pwifAnswerFile)
{
    AssertValidReadPtr(pwifAnswerFile);
    DefineFunctionName("WriteWinsockOrder");

    CWInfSection* pwisWinsock;

    pwisWinsock = pwifAnswerFile->AddSection(c_szAfSectionWinsock);
    if (pwisWinsock)
    {
        tstring             strWinsockOrder;
        INT                 nErr;
        ULONG               ulRes;
        DWORD               cbInfo = 0;
        WSAPROTOCOL_INFO*   pwpi = NULL;
        WSAPROTOCOL_INFO*   pwpiInfo = NULL;
        LPWSCENUMPROTOCOLS  pfnWSCEnumProtocols = NULL;
        HMODULE             hmod;

        if (SUCCEEDED(HrLoadLibAndGetProc(L"ws2_32.dll",
                                 "WSCEnumProtocols",
                                 &hmod,
                                 reinterpret_cast<FARPROC *>(&pfnWSCEnumProtocols))))
        {
            // First get the size needed
            //
            ulRes = pfnWSCEnumProtocols(NULL, NULL, &cbInfo, &nErr);
            if ((SOCKET_ERROR == ulRes) && (WSAENOBUFS == nErr))
            {
                pwpi = reinterpret_cast<WSAPROTOCOL_INFO*>(new BYTE[cbInfo]);
                if (pwpi)
                {
                    // Find out all the protocols on the system
                    //
                    ulRes = pfnWSCEnumProtocols(NULL, pwpi, &cbInfo, &nErr);

                    if (SOCKET_ERROR != ulRes)
                    {
                        ULONG   cProt;
                        WCHAR   szCatId[64];

                        for (pwpiInfo = pwpi, cProt = ulRes;
                             cProt;
                             cProt--, pwpiInfo++)
                        {
                            wsprintfW(szCatId, L"%lu", pwpiInfo->dwCatalogEntryId);
                            if (cProt < ulRes)
                            {
                                // prepend a semicolon if not first time through
                                // we can't use a comma because setup will munge
                                // this string into separate strings and we don't
                                // want that
                                //
                                strWinsockOrder.append(L".");
                            }
                            strWinsockOrder.append(szCatId);
                        }
                    }

                    delete pwpi;
                }
            }

            pwisWinsock->AddKey(c_szAfKeyWinsockOrder, strWinsockOrder.c_str());

            FreeLibrary(hmod);
        }
    }
}

//+---------------------------------------------------------------------------
//
// Function:  HrHandleMiscSpecialCases
//
// Purpose:   Handle misc. special cases for upgrade
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 28-January-99
//
HRESULT
HrHandleMiscSpecialCases (
    IN CWInfFile* pwifAnswerFile)
{
    AssertValidReadPtr(pwifAnswerFile);
    DefineFunctionName("HrHandleMiscSpecialCases");

    HRESULT hr=S_OK;

    CWInfSection* pwisMiscUpgradeData;
    pwisMiscUpgradeData = pwifAnswerFile->AddSection(c_szAfMiscUpgradeData);

    // -------------------------------------------------------
    // Tapi server upgrade
    //
    static const WCHAR c_szRegKeyTapiServer[] =
        L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Server";
    static const WCHAR c_szDisableSharing[] = L"DisableSharing";
    HKEY hkeyTapiServer;
    DWORD dwDisableSharing;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyTapiServer,
                        KEY_READ, &hkeyTapiServer);
    if (S_OK == hr)
    {
        hr = HrRegQueryDword(hkeyTapiServer, c_szDisableSharing,
                             &dwDisableSharing);
        if ((S_OK == hr) && !dwDisableSharing)
        {
            pwisMiscUpgradeData->AddBoolKey(c_szAfTapiSrvRunInSeparateInstance,
                                            TRUE);
        }

        RegCloseKey(hkeyTapiServer);
    }
    // -------------------------------------------------------

    TraceErrorOptional(__FUNCNAME__, hr,
                       (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)));

    return hr;
}

// ----------------------------------------------------------------------
// Computer Identification Page
// ----------------------------------------------------------------------


// ----------------------------------------------------------------------
//
// Function:  GetDomainMembershipInfo
//
// Purpose:   Determine domain membership status
//
// Arguments:
//    fDomainMember [out]  pointer to
//    strName       [out]  name of name of
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
// Notes:     Information on the APIs used in this function is in the file:
//            public\spec\se\lsa\lsaapi.doc
//
BOOL
GetDomainMembershipInfo (
    OUT BOOL* fDomainMember,
    OUT tstring& strName)
{
    BOOL status=FALSE;
    LSA_HANDLE h=0;
    POLICY_PRIMARY_DOMAIN_INFO* ppdi;

    LSA_OBJECT_ATTRIBUTES loa;
    ZeroMemory (&loa, sizeof(loa));
    loa.Length = sizeof(LSA_OBJECT_ATTRIBUTES);

    NTSTATUS ntstatus;
    ntstatus = LsaOpenPolicy(NULL, &loa, POLICY_VIEW_LOCAL_INFORMATION, &h);
    if (FALSE == LSA_SUCCESS(ntstatus))
        return FALSE;

    ntstatus = LsaQueryInformationPolicy(h, PolicyPrimaryDomainInformation,
                                         (VOID **) &ppdi);
    if (LSA_SUCCESS(ntstatus))
    {
        *fDomainMember = ppdi->Sid > 0;
        strName = ppdi->Name.Buffer;
        status = TRUE;
    }

    LsaClose(h);

    return status;
}


// ----------------------------------------------------------------------
//
// Function:  WriteIdentificationInfo
//
// Purpose:   Write computer identification info to the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteIdentificationInfo (
    IN CWInfFile *pwifAnswerFile)
{
    DefineFunctionName("WriteIdentificationInfo");

    TraceFunctionEntry(ttidNetUpgrade);

    BOOL fStatus=FALSE;

    PCWInfSection pwisIdentification =
    pwifAnswerFile->AddSectionIfNotPresent(c_szAfSectionIdentification);
    CORegKey *prkComputerName =
        new CORegKey(HKEY_LOCAL_MACHINE, c_szRegValComputerName);

    tstring strValue, strComment;

    if(!prkComputerName) 
    {
        goto error_cleanup;
    }

    //ComputerName
    prkComputerName->QueryValue(c_szComputerName, strValue);
    strComment = L"Computer '" + strValue + L"' is a member of the ";

    BOOL fDomainMember;
    fStatus = GetDomainMembershipInfo(&fDomainMember, strValue);
    if (!fStatus)
        goto error_cleanup;

    strComment = strComment + L"'" + strValue + L"' ";

    if (fDomainMember)
    {
        strComment = strComment + L"domain ";
    }
    else
    {
        strComment = strComment + L"workgroup ";
    }

    pwisIdentification->AddComment(strComment.c_str());

    fStatus=TRUE;
    goto cleanup;

  error_cleanup:
    fStatus = FALSE;

  cleanup:
    DeleteIfNotNull(prkComputerName);

    return fStatus;
}


// ----------------------------------------------------------------------
// Net Cards Page
// ----------------------------------------------------------------------

//$ REVIEW  kumarp 10-September-97
//  this is a temporary fix only
//
//  we want to avoid queryin the mac addr for these drivers because
//  the drivers are faulty. the query never returns and it hangs netupgrd.dll
//
static const PCWSTR c_aszDriversToIgnoreWhenGettingMacAddr[] =
{
    L"Diehl_ISDNSDI",
};

static const PCWSTR c_aszIrq[] =
{
    L"IRQ",
    L"INTERRUPT",
    L"InterruptNumber",
    L"IRQLevel"
};

static const PCWSTR c_aszIoAddr[] =
{
    L"IOADDRESS",
    L"IoBaseAddress",
    L"BaseAddr"
};

static const PCWSTR c_aszMem[] =
{
    L"Mem",
    L"MemoryMappedBaseAddress"
};

static const PCWSTR c_aszDma[] =
{
    L"DMA",
    L"DMALevel"
};

static const PCWSTR c_aszAdapterParamsToIgnore[] =
{
    L"BusType"
};


// ----------------------------------------------------------------------
//
// Function:  WriteNetAdaptersInfo
//
// Purpose:   Write information about installed net-adapters to the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteNetAdaptersInfo (
    IN CWInfFile *pwifAnswerFile)
{
    DefineFunctionName("WriteNetAdaptersInfo");

    TraceFunctionEntry(ttidNetUpgrade);

    HRESULT hr=E_FAIL;
    BOOL fStatus=FALSE;
    UINT cNumPhysicalAdapters=0;

    // ignore the errror, it is a non-error if we cannot find
    // the cNumPhysicalAdapters
    (void) HrGetNumPhysicalNetAdapters(&cNumPhysicalAdapters);

    CORegKey *prkNetworkCards = NULL;
    tstring strNetAdapterInstance;
    tstring strUnsupportedMessage;
    CORegKeyIter *prkiNetAdapters = NULL;
    CORegKey *prkNetAdapterInstance=NULL, *prkNetRules=NULL;

    CWInfSection *pwisNetAdapters;
    CWInfSection *pwisNetAdapterParams=NULL;
    CWInfSection *pwisNetAdapterAdditionalParams=NULL;

    tstring strNT5InfId;
    tstring strAdapterType;

    // WLBS: find out which netcard WLBS is bound to

    pszWlbsClusterAdapterName[0] = pszWlbsVirtualAdapterName[0] = 0;

    tstring strWlbsClusterAdapterDriver, strWlbsVirtualAdapterDriver;

    TStringList slWlbsLinkage;

    CORegKey *prkWlbsLinkage =
        new CORegKey(HKEY_LOCAL_MACHINE, c_szRegWlbsLinkage, KEY_READ);

    if(!prkWlbsLinkage) {
        return false;
    }

    CORegKey *prkConvoyLinkage =
        new CORegKey(HKEY_LOCAL_MACHINE, c_szRegConvoyLinkage, KEY_READ);

    if(!prkConvoyLinkage) {
        delete prkWlbsLinkage;
        return false;
    }

    if ((prkWlbsLinkage->HKey() != NULL && prkWlbsLinkage->QueryValue(c_szRegValBind, slWlbsLinkage) == ERROR_SUCCESS) ||
        (prkConvoyLinkage->HKey() != NULL && prkConvoyLinkage->QueryValue(c_szRegValBind, slWlbsLinkage) == ERROR_SUCCESS))
    {
        TraceTag(ttidNetUpgrade, "%s: WLBS found - iterating", __FUNCNAME__);

        TStringListIter iter;
        tstring         strTmp;
        DWORD           i;

        // proper WLBS configuration will have only two bindings - one to the
        // wlbs virtual NIC, the other to the cluster NIC

        for (i = 0, iter = slWlbsLinkage.begin();
               i < 2 && iter != slWlbsLinkage.end(); i++, iter++)
        {
            strTmp = **iter;

            TraceTag(ttidNetUpgrade, "%s: WLBS bound to %S",
                     __FUNCNAME__, strTmp.c_str());

            strTmp.erase(0, 8);

            TraceTag(ttidNetUpgrade, "%s: WLBS now bound to %S",
                     __FUNCNAME__, strTmp.c_str());

            if (strTmp.find(c_szWLBS) != tstring::npos ||
                strTmp.find(c_szConvoy) != tstring::npos)
            {
                strWlbsVirtualAdapterDriver = strTmp;
            }
            else
            {
                strWlbsClusterAdapterDriver = strTmp;
            }
        }

        if (iter != slWlbsLinkage.end())
        {
            TraceTag(ttidNetUpgrade, "%s: WLBS bound to more than one NIC!",
                     __FUNCNAME__);
        }

        TraceTag(ttidNetUpgrade, "%s: WLBS is bound to %S and %S", __FUNCNAME__,
                 strWlbsVirtualAdapterDriver.c_str(),
                 strWlbsClusterAdapterDriver.c_str());
    }

    delete prkWlbsLinkage;
    delete prkConvoyLinkage;

    // end WLBS:

    pwisNetAdapters = pwifAnswerFile->AddSection(c_szAfSectionNetAdapters);

    prkNetworkCards =
        new CORegKey(HKEY_LOCAL_MACHINE, c_szRegKeyAdapterHome, KEY_READ);

    if(prkNetworkCards)
    {
        prkiNetAdapters = new CORegKeyIter(*prkNetworkCards);
        prkiNetAdapters->Reset();
    }
    WORD wNumAdapters = 0;
    CORegKey *prkAdapterDriverParams=NULL;
    BOOL fAbortFunction=FALSE;

    // This determines if we will write the line under NetAdapters to
    // reference the params section for this adapter.
    //
    BOOL fWriteNetAdaptersReference;

    while (!fAbortFunction && prkiNetAdapters && !prkiNetAdapters->Next(&strNetAdapterInstance))
    {
        DWORD dwHidden=0, err=0;
        WCHAR pszAdapterName[16], pszAdapterSectionName[256];
        WCHAR pszAdapterAdditionalParamsSectionName[256];

        tstring strPreNT5InfId, strAdapterDescription, strAdapterDescComment;

        fWriteNetAdaptersReference = FALSE;

        prkNetAdapterInstance =
            new CORegKey(*prkNetworkCards, strNetAdapterInstance.c_str());

        // for REAL netcards, "Hidden" is absent or if present the value is 0
        BOOL fRealNetCard;
        err = prkNetAdapterInstance->QueryValue(L"Hidden", dwHidden);
        fRealNetCard = (err != ERROR_SUCCESS) || (dwHidden == 0);

        prkNetAdapterInstance->QueryValue(c_szRegValDescription,
                                          strAdapterDescription);
        swprintf(pszAdapterName, L"Adapter%02d", ++wNumAdapters);

        TraceTag(ttidNetUpgrade, "%s: writing info for adapter %S (%S)",
                 __FUNCNAME__, pszAdapterName, strNetAdapterInstance.c_str());

        // Now, create adapter parameters sections
        swprintf(pszAdapterSectionName, L"%s%s", c_szAfParams, pszAdapterName);
        //pwisNetAdapters->AddKey(pszAdapterName, pszAdapterSectionName);
        swprintf(pszAdapterAdditionalParamsSectionName, L"%s%s.Additional",
                  c_szAfParams, pszAdapterName);

        if (NULL != pwisNetAdapterParams)
            pwifAnswerFile->GotoEndOfSection(pwisNetAdapterParams);

        pwisNetAdapterParams = pwifAnswerFile->AddSection(pszAdapterSectionName);
        pwisNetAdapterAdditionalParams =
            pwifAnswerFile->AddSection(pszAdapterAdditionalParamsSectionName);

        // moved up here from below so that for WLBS adapter we can set
        // fRealNetCard to FALSE

        tstring strAdapterDriver;

        prkNetAdapterInstance->QueryValue(c_szRegValServiceName,
                                          strAdapterDriver);

        // WLBS: based on pre-upgrade instance, find out virtual and cluster
        // NIC adapter instances

        if (_wcsicmp (strAdapterDriver.c_str(),
                      strWlbsVirtualAdapterDriver.c_str()) == 0)
        {
            TraceTag(ttidNetUpgrade, "%s: WLBS virtual adapter is %S",
                     __FUNCNAME__, pszAdapterName);

            wcscpy(pszWlbsVirtualAdapterName, pszAdapterName);
            fRealNetCard = FALSE;
        }
        else if (_wcsicmp (strAdapterDriver.c_str(),
                           strWlbsClusterAdapterDriver.c_str()) == 0)
        {
            TraceTag(ttidNetUpgrade, "%s: WLBS cluster adapter is %S",
                     __FUNCNAME__, pszAdapterName);

            wcscpy(pszWlbsClusterAdapterName, pszAdapterName);
        }

        // end WLBS:

        prkNetRules = new CORegKey(*prkNetAdapterInstance, c_szRegKeyNetRules);
        prkNetRules->QueryValue(c_szRegValInfOption, strPreNT5InfId);

        if (fRealNetCard)
        {
            strAdapterDescComment =
                tstring(L"Net Card: ") + strPreNT5InfId +
                tstring(L"  (") + strAdapterDescription + tstring(L")");
        }
        else
        {
            strAdapterDescComment =
                tstring(L"Pseudo Adapter: ") + strAdapterDescription;
        }
        ReplaceCharsInString((PWSTR) strAdapterDescComment.c_str(),
                             L"\n\r", L' ');

        pwisNetAdapterParams->AddComment(strAdapterDescComment.c_str());
        pwisNetAdapterParams->AddKey(c_szAfAdditionalParams,
                                     pszAdapterAdditionalParamsSectionName);
        pwisNetAdapterParams->AddBoolKey(c_szAfPseudoAdapter, !fRealNetCard);

        pwisNetAdapterParams->AddKey(c_szAfPreUpgradeInstance,
                                     strAdapterDriver.c_str());

        tstring strProductName;
        prkNetAdapterInstance->QueryValue(L"ProductName", strProductName);
        AddToNetCardDB(pszAdapterName, strProductName.c_str(),
                       strAdapterDriver.c_str());

        // We need to look at the ndiswan instances (if any) to decide
        // which RAS components we need to install.
        // the algorithm is like this
        //
        // - for each <instance> in
        //   software\microsoft\windows nt\currentversion\networkcards\<instance>
        // - if atleast one <intance>\ProductName
        //   - begins with "ndiswan" AND
        //   - has string "in" in it --> install ms_rassrv
        //   - has string "out" in it --> install ms_rascli
        //
        PCWSTR pszProductName;
        pszProductName = strProductName.c_str();
        if (FIsPrefix(c_szNdisWan, pszProductName))
        {
            static const WCHAR c_szIn[] = L"in";
            static const WCHAR c_szOut[] = L"out";

            if (wcsstr(pszProductName, c_szIn))
            {
                TraceTag(ttidNetUpgrade,
                         "%s: g_fAtLeastOneDialInUsingNdisWan set to TRUE because of %S",
                         __FUNCNAME__, pszProductName);
                g_fAtLeastOneDialInUsingNdisWan = TRUE;
            }
            if (wcsstr(pszProductName, c_szOut))
            {
                TraceTag(ttidNetUpgrade,
                         "%s: g_fAtLeastOneDialOutUsingNdisWan set to TRUE because of %S",
                         __FUNCNAME__, pszProductName);
                g_fAtLeastOneDialOutUsingNdisWan = TRUE;
            }
        }

        if (!fRealNetCard)
        {
            pwisNetAdapterParams->AddKey(c_szAfInfid, strPreNT5InfId.c_str());

            //The rest of the keys are for real net cards only
            goto cleanup_for_this_iteration;
        }

        //EthernetAddress
        if (!FIsInStringArray(c_aszDriversToIgnoreWhenGettingMacAddr,
                              celems(c_aszDriversToIgnoreWhenGettingMacAddr),
                              strProductName.c_str()))
        {
            QWORD qwEthernetAddress;

            // ignore the error if we cannot get the netcard address
            // this error is non-fatal

            // Based on what build we are on, we call a different API to
            // get netcard address.  Currently, this code path isn't executed
            // on any NT5 to NT5 upgrade, but if it changes, we want to use
            // the newer api.
            //
            if (g_NetUpgradeInfo.From.dwBuildNumber < 2031) // Pre-Beta3
            {
                (VOID) HrGetNetCardAddrOld(strAdapterDriver.c_str(), &qwEthernetAddress);
            }
            else
            {
                (VOID) HrGetNetCardAddr(strAdapterDriver.c_str(), &qwEthernetAddress);
            }
            pwisNetAdapterParams->AddQwordKey(c_szAfNetCardAddr, qwEthernetAddress);

            fWriteNetAdaptersReference = (0 != qwEthernetAddress);
        }
        else
        {
            TraceTag(ttidNetUpgrade, "%s: did not query %S for mac address",
                     __FUNCNAME__, strProductName.c_str());
        }

        GetServiceParamsKey(strAdapterDriver.c_str(), prkAdapterDriverParams);

        //write INFID key
        HKEY hkeyAdapterDriverParams;
        if (prkAdapterDriverParams)
        {
            hkeyAdapterDriverParams = prkAdapterDriverParams->HKey();
        }
        else
        {
            hkeyAdapterDriverParams = NULL;
        }

        BOOL fIsOemAdapter;
        CNetMapInfo* pnmi;

        fIsOemAdapter = FALSE;
        pnmi = NULL;

        hr = HrMapPreNT5NetCardInfIdToNT5InfId(hkeyAdapterDriverParams,
                                               strPreNT5InfId.c_str(),
                                               &strNT5InfId,
                                               &strAdapterType,
                                               &fIsOemAdapter, &pnmi);

        if (S_OK == hr)
        {
            if (!lstrcmpiW(strAdapterType.c_str(), c_szAsyncAdapters) ||
                !lstrcmpiW(strAdapterType.c_str(), c_szOemAsyncAdapters))
            {
                CWInfSection* pwisAsyncCards;
                pwisAsyncCards =
                    pwifAnswerFile->AddSectionIfNotPresent(c_szAsyncAdapters);
                if (pwisAsyncCards)
                {
                    pwisAsyncCards->AddKey(pszAdapterName,
                                           pszAdapterSectionName);
                }
            }
            else
            {
                fWriteNetAdaptersReference = TRUE;
            }
        }
        else
        {
            GetUnsupportedMessage(c_szNetCard, strAdapterDescription.c_str(),
                                  strPreNT5InfId.c_str(), &strUnsupportedMessage);
            pwisNetAdapterParams->AddComment(strUnsupportedMessage.c_str());
            strNT5InfId = c_szAfUnknown;
            TraceTag(ttidNetUpgrade, "WriteNetAdaptersInfo: %S",
                     strUnsupportedMessage.c_str());
        }

        if (fWriteNetAdaptersReference)
        {
            // We have enough information to determine which adapter goes
            // with this section so write out the reference.
            //
            pwisNetAdapters->AddKey(pszAdapterName, pszAdapterSectionName);
        }


        if (1 == cNumPhysicalAdapters)
        {
            TraceTag(ttidNetUpgrade, "%s: dumped '*' as InfID for %S",
                     __FUNCNAME__, strNT5InfId.c_str());
            pwisNetAdapterParams->AddKey(c_szAfInfid, L"*");
            pwisNetAdapterParams->AddKey(c_szAfInfidReal, strNT5InfId.c_str());
        }
        else
        {
            pwisNetAdapterParams->AddKey(c_szAfInfid, strNT5InfId.c_str());
        }

        if (!prkAdapterDriverParams)
        {
            // since we could not open the driver params key
            // we cant dump parameters. just skip this card and continue
            goto cleanup_for_this_iteration;
        }

        // -----------------------------------------------------------------
        // OEM upgrade code
        //

        if (fIsOemAdapter)
        {
            hr = HrProcessOemComponentAndUpdateAfSection(
                    pnmi, NULL,
                    prkAdapterDriverParams->HKey(),
                    strPreNT5InfId.c_str(),
                    strAdapterDriver.c_str(),
                    strNT5InfId.c_str(),
                    strAdapterDescription.c_str(),
                    pwisNetAdapterParams);

            // OEM upgrade may be aborted because of a fatal error or
            // if an OEM DLL requests it. in both cases we need to stop
            // our current answerfile generation
            //
            if (FIsUpgradeAborted())
            {
                fAbortFunction = TRUE;
                goto cleanup_for_this_iteration;
            }
        }
        // -----------------------------------------------------------------

        //BusType
        DWORD dwBusType;
        INTERFACE_TYPE eBusType;
        prkAdapterDriverParams->QueryValue(L"BusType", dwBusType);
        eBusType = (INTERFACE_TYPE) dwBusType;
        pwisNetAdapterParams->AddKey(c_szAfBusType,
                                     GetBusTypeName(eBusType));

        // for certain ISA cards the driver parameters store EISA as the bus type
        // when these cards are installed in EISA slots. Thus we have to dump parameters
        // when BusType is Eisa.
        //
        BOOL fDumpResources;
        fDumpResources = ((eBusType == Isa) || (eBusType == Eisa));

        // kumarp    14-July-97
        // this fix has been requested by billbe.
        // we do not dump hardware resources for the ISAPNP cards
        //
        if (!lstrcmpiW(strPreNT5InfId.c_str(), L"IEEPRO") ||
            !lstrcmpiW(strPreNT5InfId.c_str(), L"ELNK3ISA509"))
        {
            fDumpResources = FALSE;
        }

        DWORD dwIndex;
        dwIndex = 0;
        DWORD dwValueNameLen, dwValueType;

        WCHAR szValueName[REGSTR_MAX_VALUE_LENGTH+1];
        PCWSTR pszResourceName;
        DWORD dwValueDumpFormat;
        do
        {
            dwValueNameLen = REGSTR_MAX_VALUE_LENGTH;
            hr = HrRegEnumValue(prkAdapterDriverParams->HKey(),
                                dwIndex, szValueName, &dwValueNameLen,
                                &dwValueType, NULL, NULL);

            if (hr == S_OK)
            {
                pszResourceName = NULL;
                dwValueDumpFormat = REG_HEX;

                dwIndex++;
                if (FIsInStringArray(c_aszIrq,
                                     celems(c_aszIrq), szValueName))
                {
                    pszResourceName = c_szAfIrq;
                    dwValueDumpFormat = REG_DWORD;
                }
                else if (FIsInStringArray(c_aszIoAddr,
                                          celems(c_aszIoAddr), szValueName))
                {
                    pszResourceName = c_szAfIoAddr;
                }
                else if (FIsInStringArray(c_aszMem,
                                          celems(c_aszMem), szValueName))
                {
                    pszResourceName = c_szAfMem;
                }
                else if (FIsInStringArray(c_aszDma,
                                          celems(c_aszDma), szValueName))
                {
                    pszResourceName = c_szAfDma;
                }

                if (pszResourceName)
                {
                    if (fDumpResources)
                    {
                        WriteRegValueToAFile(pwisNetAdapterParams,
                                             *prkAdapterDriverParams,
                                             szValueName, dwValueDumpFormat,
                                             pszResourceName);
                    }
                }
                else if (!FIsInStringArray(c_aszAdapterParamsToIgnore,
                                           celems(c_aszAdapterParamsToIgnore),
                                           szValueName))
                {
                    WriteRegValueToAFile(pwisNetAdapterAdditionalParams,
                                         *prkAdapterDriverParams,
                                         szValueName, dwValueType);
                }
            }
        }
        while (hr == S_OK);

      cleanup_for_this_iteration:
        DeleteIfNotNull(prkNetAdapterInstance);
        DeleteIfNotNull(prkNetRules);
        DeleteIfNotNull(prkAdapterDriverParams);
    }

    // WLBS: if either cluster or virtual adapter were not matched - blow off
    // WLBS-specific upgrade code

    if (pszWlbsClusterAdapterName[0] == 0 || pszWlbsVirtualAdapterName[0] ==0)
    {
        pszWlbsClusterAdapterName[0] = pszWlbsVirtualAdapterName[0] = 0;
    }

    // end WLBS:

    fStatus=TRUE;
    goto cleanup;

    fStatus=FALSE;

  cleanup:
    DeleteIfNotNull(prkNetworkCards);
    DeleteIfNotNull(prkiNetAdapters);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  HrGetNumPhysicalNetAdapters
//
// Purpose:   Count and return number of physical adapters installed
//
// Arguments:
//    puNumAdapters [out] pointer to num adapters
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 29-May-98
//
HRESULT
HrGetNumPhysicalNetAdapters (
    OUT UINT* puNumAdapters)
{
    AssertValidWritePtr(puNumAdapters);
    DefineFunctionName("HrGetNumPhysicalNetAdapters");

    HRESULT hr;
    HKEY hkeyAdapters;
    HKEY hkeyAdapter;
    DWORD dwHidden;
    BOOL  fRealNetCard = FALSE;

    *puNumAdapters = 0;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyAdapterHome,
                        KEY_READ, &hkeyAdapters);
    if (S_OK == hr)
    {
        WCHAR szBuf[MAX_PATH];
        FILETIME time;
        DWORD dwSize;
        DWORD dwRegIndex;

        for (dwRegIndex = 0, dwSize = celems(szBuf);
             S_OK == HrRegEnumKeyEx(hkeyAdapters, dwRegIndex, szBuf,
                        &dwSize, NULL, NULL, &time);
             dwRegIndex++, dwSize = celems(szBuf))
        {
            Assert(*szBuf);

            hr = HrRegOpenKeyEx(hkeyAdapters, szBuf, KEY_READ, &hkeyAdapter);
            if (hr == S_OK)
            {
                hr = HrRegQueryDword(hkeyAdapter, c_szHidden, &dwHidden);

                // for REAL netcards, "Hidden" is absent or if present the value is 0
                if (S_OK == hr)
                {
                    fRealNetCard = (0 == dwHidden);
                }
                else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
                {
                    fRealNetCard = TRUE;
                    hr = S_OK;
                }

                if ((S_OK == hr) && fRealNetCard)
                {
                    (*puNumAdapters)++;
                }
                RegCloseKey(hkeyAdapter);
            }
        }

        RegCloseKey(hkeyAdapters);
    }

    TraceTag(ttidNetUpgrade, "%s: Found %d physical net adapters",
             __FUNCNAME__, *puNumAdapters);

    TraceError(__FUNCNAME__, hr);
    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  IsNetworkComponent
//
// Purpose:   Determine if a component is a net-component
//
// Arguments:
//    prkSoftwareMicrosoft [in]  pointer to CORegKey object
//    strComponentName     [in]  constTString object name of
//
// Returns:
//
// Author:    kumarp 03-December-97
//
// Notes:     any software that has a NetRules key under the CurrentVersion
//            key is considered a network component
//
BOOL
IsNetworkComponent (
    IN CORegKey *prkSoftwareMicrosoft,
    IN const tstring strComponentName)
{
    tstring strNetRules = strComponentName + L"\\CurrentVersion\\NetRules";
    CORegKey rkNetRules((HKEY) *prkSoftwareMicrosoft, strNetRules.c_str());
    return (((HKEY) rkNetRules) != NULL);
}

// ----------------------------------------------------------------------
// Network components (protocols, services)
// ----------------------------------------------------------------------

typedef BOOL (*WriteNetComponentParamsFn)(
        IN CWInfFile*    pwifAnswerFile,
        IN CWInfSection* pwisGlobalParams);

static PCWSTR c_aszNetComponents[] =
{
    L"RASPPTP",
    L"Browser",
    c_szSvcWorkstation,
    L"RpcLocator",
    L"LanmanServer",
    c_szSvcNetBIOS,
    c_szSvcNWCWorkstation,
    c_szSvcDhcpServer,
    L"ISOTP",
    c_szWLBS,
    c_szConvoy
};

static WriteNetComponentParamsFn c_afpWriteParamsFns[] =
{
    WritePPTPParams,
    WriteBrowserParams,
    WriteLanmanWorkstationParams,
    WriteRPCLocatorParams,
    WriteLanmanServerParams,
    WriteNetBIOSParams,
    WriteNWCWorkstationParams,
    WriteDhcpServerParams,
    WriteTp4Params,
    WriteWLBSParams,
    WriteConvoyParams
};

typedef BOOL (*WriteNetComponentParamsAndAdapterSectionsFn)(
        IN CWInfFile*    pwifAnswerFile,
        IN CWInfSection* pwisGlobalParams,
        OUT TStringList& slAdditionalParamsSections);

static const PCWSTR c_aszNetComponentsWithAdapterSpecificParams[] =
{
    L"Tcpip",
    L"NwlnkIpx",
    L"AppleTalk"
};

static WriteNetComponentParamsAndAdapterSectionsFn
c_afpWriteParamsAndAdapterSectionsFns[] =
{
    WriteTCPIPParams,
    WriteIPXParams,
    WriteAppleTalkParams
};

// ----------------------------------------------------------------------
//
// Function:  HrWriteNetComponentInfo
//
// Purpose:   Write info of the specified component to the answerfile
//
// Arguments:
//    szNetComponent     [in]  net component
//    pwifAnswerFile     [in]  pointer to CWInfFile object (answerfile)
//    hkeyCurrentVersion [in]  handle of CurrentVersion regkey
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 13-May-98
//
HRESULT
HrWriteNetComponentInfo (
    IN PCWSTR szNetComponent,
    IN CWInfFile* pwifAnswerFile,
    IN HKEY hkeyCurrentVersion)
{
    DefineFunctionName("HrWriteNetComponentInfo");

    HRESULT hr=S_OK;

    tstring strPreNT5InfId;
    tstring strNT5InfId;
    tstring strProductCurrentVersion;
    tstring strDescription;
    tstring strSoftwareType;
    tstring strParamsSectionName;

    TStringList slAdditionalParamsSections;
    BOOL  fIsOemComponent;
    UINT  uIndex;

    CWInfSection* pwisNetComponents;
    CWInfSection* pwisNetComponentParams;
    ENetComponentType nct=NCT_Unknown;
    PCWSTR szNetComponentsSection;
    CNetMapInfo* pnmi;
    static BOOL fRasParamsDumped=FALSE;

    hr = HrGetPreNT5InfIdAndDesc(hkeyCurrentVersion,
                                 &strPreNT5InfId, &strDescription,
                                 NULL);

    if (S_OK == hr)
    {
        TraceTag(ttidNetUpgrade, "%s: processing '[%S] %S'",
                 __FUNCNAME__, strPreNT5InfId.c_str(), strDescription.c_str());

        hr = HrMapPreNT5NetComponentInfIDToNT5InfID(
                strPreNT5InfId.c_str(), &strNT5InfId,
                &fIsOemComponent, &nct, &pnmi);

        if (S_OK == hr)
        {
            Assert((nct >= NCT_Adapter) &&
                   (nct <= NCT_Client));

            // add the top level section [Net*] if not present

            szNetComponentsSection =
                g_szNetComponentSectionName[nct];
            pwisNetComponents =
                pwifAnswerFile->AddSectionIfNotPresent(
                        szNetComponentsSection);

            strParamsSectionName = c_szAfParams + strNT5InfId;

            if (!pwisNetComponents->FindKey(strNT5InfId.c_str(),
                                            ISM_FromBeginning))
            {
                pwisNetComponentParams =
                    pwifAnswerFile->AddSection(strParamsSectionName.c_str());

                // RAS is a special case.
                if (0 != _wcsicmp(strNT5InfId.c_str(), c_szRAS))
                {
                    pwisNetComponents->AddKey(strNT5InfId.c_str(),
                                              strParamsSectionName.c_str());
                }

            }
            else
            {
                pwisNetComponentParams =
                    pwifAnswerFile->FindSection(strParamsSectionName.c_str());
            }

            AssertSz(pwisNetComponentParams,
                     "HrWriteNetComponentInfo: Need a section to add key to!");

            if (FIsInStringArray(c_aszNetComponents,
                                 celems(c_aszNetComponents),
                                 szNetComponent, &uIndex))
            {
                c_afpWriteParamsFns[uIndex](pwifAnswerFile,
                                            pwisNetComponentParams);
            }
            else if (FIsInStringArray(
                    c_aszNetComponentsWithAdapterSpecificParams,
                    celems(c_aszNetComponentsWithAdapterSpecificParams),
                    szNetComponent, &uIndex))
            {
                EraseAndDeleteAll(slAdditionalParamsSections);
                c_afpWriteParamsAndAdapterSectionsFns[uIndex]
                    (pwifAnswerFile,
                     pwisNetComponentParams,
                     slAdditionalParamsSections);
                if (!slAdditionalParamsSections.empty())
                {
                    pwisNetComponentParams->AddKey(c_szAfAdapterSections,
                                                   slAdditionalParamsSections);
                }
            }
            else if (!lstrcmpiW(strNT5InfId.c_str(), c_szRAS) &&
                     !fRasParamsDumped)
            {
                fRasParamsDumped = TRUE;
                WriteRASParams(pwifAnswerFile,
                               pwisNetComponents,
                               pwisNetComponentParams);
            }
            else if (fIsOemComponent)
            {
                HKEY hkeyServiceParams=NULL;
                tstring strServiceName;
                hr = HrRegQueryString(hkeyCurrentVersion,
                                      c_szRegValServiceName,
                                      &strServiceName);
                if (S_OK == hr)
                {
                    AssertSz(!strServiceName.empty(),
                             "Service name is empty for OEM component!!");
                    hr = HrRegOpenServiceSubKey(strServiceName.c_str(),
                                                c_szParameters,
                                                KEY_READ,
                                                &hkeyServiceParams);
                    if (S_OK == hr)
                    {
                        hr = HrProcessOemComponentAndUpdateAfSection(
                                pnmi, NULL,
                                hkeyServiceParams,       // Parameters reg key
                                strPreNT5InfId.c_str(),
                                strServiceName.c_str(),
                                strNT5InfId.c_str(),
                                strDescription.c_str(),
                                pwisNetComponentParams);

                        // OEM upgrade may be aborted because of a fatal error or
                        // if an OEM DLL requests it. in both cases we need to
                        // stop our current answerfile generation
                        if (FIsUpgradeAborted())
                        {
                            TraceTag(ttidNetUpgrade,
                                     "%s: upgrade aborted by %S",
                                     __FUNCNAME__, strNT5InfId.c_str());
                        }
                    }
                    else
                    {
                        TraceTag(ttidNetUpgrade,
                                 "%s: could not open Parameters key for '%S'",
                                 __FUNCNAME__, strServiceName.c_str());
                    }
                }
            }
            else
            {
                TraceTag(ttidNetUpgrade, "%s: '%S' Unknown component!!",
                         __FUNCNAME__, strPreNT5InfId.c_str());
            }
        }
        else if (S_FALSE == hr)
        {
            CWInfSection* pwisNetworking;
            pwisNetworking = pwifAnswerFile->FindSection(c_szAfSectionNetworking);
            if (pwisNetworking)
            {
                tstring strUnsupportedMessage;

                GetUnsupportedMessage(NULL,
                                      strDescription.c_str(),
                                      strPreNT5InfId.c_str(),
                                      &strUnsupportedMessage);
                pwisNetworking->AddComment(strUnsupportedMessage.c_str());
            }
        }
        else if (FAILED(hr))
        {
            TraceTag(ttidNetUpgrade,
                     "%s: mapping failed, skipped '%S'",
                     __FUNCNAME__, szNetComponent);
            hr = S_OK;
        }
    }
    else
    {
        TraceTag(ttidNetUpgrade,
                 "%s: HrGetPreNT5InfIdAndDesc failed, "
                 "skipped '%S'", __FUNCNAME__, szNetComponent);
        hr = S_OK;
    }

    TraceError(__FUNCNAME__, hr);

    return hr;
}


// ----------------------------------------------------------------------
//
// Function:  WriteNetComponentInfoForProvider
//
// Purpose:   Write info on installed net components (except net cards)
//            of the specified provider to the answerfile
//
// Arguments:
//    pszSoftwareProvider [in]  name of provider
//    pwifAnswerFile    [in]  pointer to CWInfFile object (answerfile)
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 13-May-98
//
VOID
WriteNetComponentInfoForProvider(
    IN HKEY hkeyProvider,
    IN PCWSTR pszSoftwareProvider,
    IN CWInfFile* pwifAnswerFile)
{
    AssertValidReadPtr(pszSoftwareProvider);
    AssertValidReadPtr(pwifAnswerFile);

    HRESULT hr;
    HKEY hkeyProductCurrentVersion;

    tstring strProductCurrentVersion;
    tstring strSoftwareType;

    WCHAR szNetComponent[MAX_PATH];
    FILETIME time;
    DWORD dwSize;
    DWORD dwRegIndex;

    for (dwRegIndex = 0, dwSize = celems(szNetComponent);
         !FIsUpgradeAborted() &&
         (S_OK == HrRegEnumKeyEx(hkeyProvider, dwRegIndex, szNetComponent,
                    &dwSize, NULL, NULL, &time));
         dwRegIndex++, dwSize = celems(szNetComponent))
    {
        Assert(*szNetComponent);

        strProductCurrentVersion = szNetComponent;
        AppendToPath(&strProductCurrentVersion, c_szRegKeyCurrentVersion);

        hr = HrRegOpenKeyEx(hkeyProvider, strProductCurrentVersion.c_str(),
                            KEY_READ, &hkeyProductCurrentVersion);
        if (S_OK == hr)
        {
            hr = HrRegQueryString(hkeyProductCurrentVersion,
                                  c_szRegValSoftwareType,
                                  &strSoftwareType);

            // ignore components of type "driver"

            if ((S_OK == hr) &&
                (0 != lstrcmpiW(strSoftwareType.c_str(), c_szSoftwareTypeDriver)))
            {
                // Don't write disabled bindings of NdisWan and NetBT.
                // They should always be enabled on upgrade.
                //
                if ((0 != lstrcmpiW(szNetComponent, L"NdisWan")) &&
                    (0 != lstrcmpiW(szNetComponent, L"NetBT")))
                {
                    WriteBindings(szNetComponent);
                }

                if (!ShouldIgnoreComponent(szNetComponent))
                {
                    (VOID) HrWriteNetComponentInfo(
                                szNetComponent, pwifAnswerFile,
                                hkeyProductCurrentVersion);
                }
            }

            RegCloseKey(hkeyProductCurrentVersion);
        }
    }
}

// ----------------------------------------------------------------------
//
// Function:  HrWriteNetComponentsInfo
//
// Purpose:   Write info on installed net components (except net cards)
//            of all providers to the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object (answerfile)
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 13-May-98
//
HRESULT
HrWriteNetComponentsInfo(
    IN CWInfFile* pwifAnswerFile)
{
    AssertValidReadPtr(pwifAnswerFile);

    HRESULT hr;
    HKEY hkeySoftware;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeySoftware,
                        KEY_READ, &hkeySoftware);
    if (S_OK == hr)
    {
        WCHAR szBuf[MAX_PATH];
        FILETIME time;
        DWORD dwSize;
        DWORD dwRegIndex;

        for (dwRegIndex = 0, dwSize = celems(szBuf);
             S_OK == HrRegEnumKeyEx(hkeySoftware, dwRegIndex, szBuf,
                        &dwSize, NULL, NULL, &time);
             dwRegIndex++, dwSize = celems(szBuf))
        {
            Assert(*szBuf);

            HKEY hkeyProvider;

            hr = HrRegOpenKeyEx(hkeySoftware, szBuf, KEY_READ, &hkeyProvider);

            if (S_OK == hr)
            {
                // We want to continue even if there is any error dumping info
                // of one provider
                //
                WriteNetComponentInfoForProvider(
                        hkeyProvider,
                        szBuf,
                        pwifAnswerFile);

                if (0 == _wcsicmp(szBuf, L"Microsoft"))
                {
                    (VOID) HrWritePreSP3ComponentsToSteelHeadUpgradeParams(
                            pwifAnswerFile);
                }

                RegCloseKey(hkeyProvider);
            }

        }

        RegCloseKey(hkeySoftware);
    }

    return hr;
}


// ----------------------------------------------------------------------
// TCPIP related
// ----------------------------------------------------------------------

static const WCHAR c_szTcpipParams[] = L"Tcpip\\Parameters";

VOID
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN CORegKey& rk,
    IN const ValueTypePair* prgVtp,
    IN ULONG crg)
{
    for (ULONG idx = 0; idx < crg; idx++)
    {
        if (REG_FILE == prgVtp[idx].dwType)
        {
            //This is just for "PersistentRoute" which we handle specifically
            continue;
        }

        WriteRegValueToAFile(pwisSection, rk, prgVtp[idx].pszValueName,
                             prgVtp[idx].dwType);
    }
}

// ----------------------------------------------------------------------
//
// Function:  WriteTCPIPParams
//
// Purpose:   Write parameters of TCPIP to the answerfile
//
// Arguments:
//    pwifAnswerFile             [in]  pointer to CWInfFile object
//    pwisTCPIPGlobalParams      [in]  pointer to TCPIP global params section
//    slAdditionalParamsSections [out] list of adapter sections
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteTCPIPParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisTCPIPGlobalParams,
    OUT TStringList& slAdditionalParamsSections)
{
    DefineFunctionName("WriteTCPIPParams");

    TraceFunctionEntry(ttidNetUpgrade);

    HRESULT hr;
    TStringList slList;
    PCORegKey prkRouter=NULL;
    PCORegKey prkTCPIP=NULL;
    PCORegKey prkTcpipParams=NULL;
    PCORegKey prkTCPIPLinkage=NULL;
    PCORegKey prkNetBT=NULL;
    DWORD dwEnableDNS=0;
    BOOL fEnableDNS=FALSE;

    GetServiceKey(c_szSvcTcpip, prkTCPIP);
    prkTcpipParams = new CORegKey(*prkTCPIP, c_szParameters);

    tstring strValue;
    DWORD dwValue;

    //first write the global parameters

    // UseDomainNameDevolution
    WriteServiceRegValueToAFile(pwisTCPIPGlobalParams,
                                L"DnsCache\\Parameters",
                                L"UseDomainNameDevolution",
                                REG_BOOL,
                                NULL,       // dont change value name
                                TRUE,       // use default
                                (BOOL) TRUE); // default value

    // EnableSecurity
    dwValue = 0;
    if (0 == prkTcpipParams->QueryValue(L"EnableSecurityFilters", dwValue))
    pwisTCPIPGlobalParams->AddBoolKey(c_szAfEnableSecurity, dwValue);

    // DNS
    GetServiceParamsKey(c_szSvcNetBT, prkNetBT);
    if (prkNetBT)
    {
        if (0 == prkNetBT->QueryValue(L"EnableDNS", dwEnableDNS))
        {
            fEnableDNS = dwEnableDNS;
        }

        // EnableLMHosts
        WriteRegValueToAFile(pwisTCPIPGlobalParams, *prkNetBT, NULL,
                             c_szAfEnableLmhosts, REG_BOOL,
                             NULL, TRUE, (BOOL)FALSE);

        // Write any present optional parameters to the answerfile
        //
        WriteRegValueToAFile(pwisTCPIPGlobalParams, *prkNetBT,
                             rgVtpNetBt, celems(rgVtpNetBt));
    }

    pwisTCPIPGlobalParams->AddBoolKey(c_szAfDns, fEnableDNS);

    // DNSDomain
    // Fix bug 349343, if the Domain value is empty, don't upgrade it
    strValue.erase();
    prkTcpipParams->QueryValue(c_szDomain, strValue);
    if (!strValue.empty())
    {
        pwisTCPIPGlobalParams->AddKey(c_szAfDnsDomain, strValue.c_str());
    }

    // HostName
    // 391590: save the hostname so we can maintain the capitalization
    strValue.erase();
    prkTcpipParams->QueryValue(c_szHostname, strValue);
    if (!strValue.empty())
    {
        pwisTCPIPGlobalParams->AddKey(c_szAfDnsHostname, strValue.c_str());
    }

    // --------------------------------------------------
    //$ ISSUE:  kumarp 12-December-97
    //
    // this should be removed for Connections
    // (they have been moved to adapter specific sections
    //
    //DNSServerSearchOrder
    strValue.erase();
    prkTcpipParams->QueryValue(c_szNameServer, strValue);
    ConvertDelimitedListToStringList(strValue, ' ', slList);
    pwisTCPIPGlobalParams->AddKey(c_szAfDnsServerSearchOrder, slList);
    // --------------------------------------------------

    // DNSSuffixSearchOrder
    strValue.erase();
    prkTcpipParams->QueryValue(L"SearchList", strValue);
    ConvertDelimitedListToStringList(strValue, ' ', slList);
    pwisTCPIPGlobalParams->AddKey(c_szAfDnsSuffixSearchOrder, slList);

    // ImportLMHostsFile
    // REVIEW: how to migrate the user-modified-lmhosts file ?

    // Per AmritanR, drop the upgrade support of IpEnableRouter (EnableIPForwarding in the answer file) to fix bug 345700
    // EnableIPForwarding (i.e. IpEnableRouter)
    

    // If Steelhead is installed then write the following otherwise do nothing
    //
    if (TRUE == GetServiceKey(c_szRouter, prkRouter))
    {
        pwisTCPIPGlobalParams->AddBoolKey(c_szAfEnableICMPRedirect, FALSE);
        pwisTCPIPGlobalParams->AddBoolKey(c_szAfDeadGWDetectDefault, FALSE);
        pwisTCPIPGlobalParams->AddBoolKey(c_szAfDontAddDefaultGatewayDefault, TRUE);
    }

    // DatabasePath  (REG_EXPAND_SZ)
    strValue.erase();
    prkTcpipParams->QueryValue(c_szDatabasePath, strValue);
    if (!strValue.empty())
    {
        pwisTCPIPGlobalParams->AddKey(c_szDatabasePath, strValue.c_str());
    }

    // Write any present optional parameters to the answerfile
    //
    WriteRegValueToAFile(pwisTCPIPGlobalParams, *prkTcpipParams,
                         rgVtpIp, celems(rgVtpIp));

    //PersistentRoutes
    (void) HrNetRegSaveKeyAndAddToSection(prkTcpipParams->HKey(),
                                          c_szPersistentRoutes,
                                          c_szAfTcpip,
                                          c_szPersistentRoutes,
                                          pwisTCPIPGlobalParams);

    //Write Adapter specific parameters
    prkTCPIPLinkage = new CORegKey(*prkTCPIP, c_szLinkage);
    prkTCPIPLinkage->QueryValue(L"Bind", slList);

    TraceStringList(ttidNetUpgrade, L"TCPIP: enabled adapters", slList);
    CORegKey* prkTCPIPLinkageDisabled;
    TStringList slDisabled;

    prkTCPIPLinkageDisabled = new CORegKey(*prkTCPIP, c_szLinkageDisabled);
    prkTCPIPLinkageDisabled->QueryValue(L"Bind", slDisabled);
    TraceStringList(ttidNetUpgrade, L"TCPIP: disabled adapters", slDisabled);
    slList.splice(slList.end(), slDisabled);
    delete prkTCPIPLinkageDisabled;

    // $REVIEW(tongl 2/18/99): Added for bug #192576
    // Get the list of disabled adapters to DHCP server, if it is installed
    HKEY hkey;
    ListStrings lstDisabledToDhcp;
    ListStrings lstDisabledNetbt;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE,
            c_szDhcpServerLinkageDisabled, KEY_READ, &hkey);

    if (S_OK == hr)
    {
        hr = HrRegQueryColString(hkey, L"Bind", &lstDisabledToDhcp);

        RegCloseKey (hkey);
    }

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE,
            L"SYSTEM\\CurrentControlSet\\Services\\Netbt\\Linkage\\Disabled",
            KEY_READ,
            &hkey);

    if (S_OK == hr)
    {
        hr = HrRegQueryColString(hkey, L"Bind", &lstDisabledNetbt);

        RegCloseKey (hkey);
    }

    TStringListIter iter;

    for (iter  = slList.begin();
         iter != slList.end();
         iter++)
    {
        static WCHAR szAdapterDriver[256];

        if (swscanf((*iter)->c_str(), L"\\Device\\%s", szAdapterDriver) == 1)
        {
            // $REVIEW(tongl 2/18/99): Added for bug #192576
            // If this adapter was on the disabled list to DHCP server,
            // set this to FALSE, otherwise, don't do anything
            BOOL fDisabledToDhcpServer = FALSE;
            BOOL fDisableNetbios = FALSE;

            if (lstDisabledToDhcp.size())
            {
                TraceTag(ttidNetUpgrade, "szAdapterDriver: %S", szAdapterDriver);

                TStringListIter iterD;
                for (iterD  = lstDisabledToDhcp.begin();
                     iterD != lstDisabledToDhcp.end();
                     iterD++)
                {
                    TraceTag(ttidNetUpgrade, "binding string: %S",
                        (*iterD)->c_str());

                    if (FIsSubstr(szAdapterDriver, (*iterD)->c_str()))
                    {
                        TraceTag(ttidNetUpgrade,
                            "Adapter %S is disabled to Dhcp Server",
                            szAdapterDriver);
                        fDisabledToDhcpServer = TRUE;
                        break;
                    }
                }
            }

            if (lstDisabledNetbt.size())
            {
                TraceTag(ttidNetUpgrade, "szAdapterDriver: %S", szAdapterDriver);

                TStringListIter iterD;
                for (iterD  = lstDisabledNetbt.begin();
                     iterD != lstDisabledNetbt.end();
                     iterD++)
                {
                    TraceTag(ttidNetUpgrade, "binding string: %S",
                        (*iterD)->c_str());

                    if (FIsSubstr(szAdapterDriver, (*iterD)->c_str()))
                    {
                        TraceTag(ttidNetUpgrade,
                            "Adapter %S is disabled for NetBIOS over TCP/IP",
                            szAdapterDriver);
                        fDisableNetbios = TRUE;
                        break;
                    }
                }
            }

            WriteTCPIPAdapterParams(
                pwifAnswerFile,
                szAdapterDriver,
                slAdditionalParamsSections,
                fDisabledToDhcpServer,
                fDisableNetbios);
        }
    }

    DeleteIfNotNull(prkTCPIP);
    DeleteIfNotNull(prkTcpipParams);
    DeleteIfNotNull(prkNetBT);
    DeleteIfNotNull(prkTCPIPLinkage);
    DeleteIfNotNull(prkRouter);

    EraseAndDeleteAll(slList);

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteTCPIPAdapterParams
//
// Purpose:   Write adapter-specific parameters of TCPIP to the answerfile
//
// Arguments:
//    pwifAnswerFile             [in]  pointer to answerfile
//    pszAdapterDriver           [in]  instance name of the adapter driver
//                                     (e.g. ieepro2)
//    slAdditionalParamsSections [out] list of adapter sections
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 03-December-97
//
BOOL
WriteTCPIPAdapterParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWSTR pszAdapterDriver,
    OUT TStringList& slAdditionalParamsSections,
    BOOL fDisabledToDhcpServer,
    BOOL fDisableNetbios)
{
    DefineFunctionName("WriteTCPIPAdapterParams");

    TraceFunctionEntry(ttidNetUpgrade);

    BOOL fStatus=FALSE;
    PCORegKey prkNetBTParams=NULL;
    tstring strValue;
    TStringList slList;
    tstring strAdapterParamsSectionName;
    PCWInfSection pwisParams;
    tstring strParamsKeyName;
    PCORegKey prkParams = NULL;

    PCWSTR pszAdapter = MapNetCardInstanceToAFileName(pszAdapterDriver);

    if (!pszAdapter)
    {
        // this is most likely due to corrupt or inconsistent registry
        //
        TraceTag(ttidNetUpgrade, "%s: skipped writing adapter specific ",
                 "parameters for %S", __FUNCNAME__, pszAdapterDriver);
        goto error_cleanup;
    }

    // WLBS: write WLBS TCP/IP parameters under the name of the cluster adapter,
    // and skip cluster adapter TCP/IP parameters alltogether.

    if (pszWlbsClusterAdapterName[0] != 0)
    {
        if (_wcsicmp(pszAdapter, pszWlbsClusterAdapterName) == 0)
        {
            TraceTag(ttidNetUpgrade, "%s: skipping %S section",
                     __FUNCNAME__, pszAdapter);

            goto error_cleanup;
        }
        else if (_wcsicmp(pszAdapter, pszWlbsVirtualAdapterName) == 0)
        {
            TraceTag(ttidNetUpgrade, "%s: replacing %S section with %S",
                     __FUNCNAME__, pszAdapter, pszWlbsClusterAdapterName);

            pszAdapter = pszWlbsClusterAdapterName;
        }
    }

    // end WLBS:

    strAdapterParamsSectionName = tstring(c_szAfParams) +
                                  c_szInfId_MS_TCPIP + L"." + pszAdapter;
    AddAtEndOfStringList(slAdditionalParamsSections, strAdapterParamsSectionName);

    pwisParams = pwifAnswerFile->AddSection(strAdapterParamsSectionName.c_str());
    pwisParams->AddKey(c_szAfSpecificTo, pszAdapter);

    //  TCPIP parameters for <adapter> are found at
    //  Services\<adapter-driver>\Parameters\Tcpip
    strParamsKeyName = tstring(c_szRegKeyServices) + L"\\" +
                       pszAdapterDriver + L"\\Parameters\\Tcpip";

    prkParams = new CORegKey(HKEY_LOCAL_MACHINE, strParamsKeyName.c_str());
    if (!prkParams)
        goto error_cleanup;

    //DNSServerSearchOrder
    //
    HRESULT hr;
    HKEY hkeyTcpipParams;

    hr = HrRegOpenServiceKey(c_szTcpipParams, KEY_READ, &hkeyTcpipParams);
    if (S_OK == hr)
    {
        tstring strDnsServerSearchOrder;

        hr = HrRegQueryString(hkeyTcpipParams, c_szNameServer,
                              &strDnsServerSearchOrder);
        if (S_OK == hr)
        {
            TStringList slDnsServerSearchOrder;

            ConvertDelimitedListToStringList(strDnsServerSearchOrder,
                                             ' ', slDnsServerSearchOrder);
            pwisParams->AddKey(c_szAfDnsServerSearchOrder,
                               slDnsServerSearchOrder);
        }
    }

    //DNSDomain
    WriteServiceRegValueToAFile(pwisParams,
                                c_szTcpipParams,
                                c_szDomain,
                                REG_SZ,
                                c_szAfDnsDomain);


    DWORD dwValue;
    prkParams->QueryValue(L"EnableDHCP", dwValue);
    pwisParams->AddBoolKey(c_szAfDhcp, dwValue);
    if (!dwValue)
    {
        //IPAddress
        WriteRegValueToAFile(pwisParams, *prkParams,
                             c_szAfIpaddress, REG_MULTI_SZ);

        //SubnetMask
        WriteRegValueToAFile(pwisParams, *prkParams,
                             c_szAfSubnetmask, REG_MULTI_SZ);
    }

    //Gateway
    WriteRegValueToAFile(pwisParams, *prkParams,
                         c_szAfDefaultGateway, REG_MULTI_SZ);

    // TcpAllowedPorts
    WriteRegValueToAFile(pwisParams, *prkParams,
                         L"TcpAllowedPorts",
                         REG_MULTI_SZ,
                         c_szAfTcpAllowedPorts);

    // UdpAllowedPorts
    WriteRegValueToAFile(pwisParams, *prkParams,
                         L"UdpAllowedPorts",
                         REG_MULTI_SZ,
                         c_szAfUdpAllowedPorts);

    // IpAllowedProtocols
    WriteRegValueToAFile(pwisParams, *prkParams,
                         L"RawIPAllowedProtocols",
                         REG_MULTI_SZ,
                         c_szAfIpAllowedProtocols);

    // Write any present optional parameters to the answerfile
    //
    WriteRegValueToAFile(pwisParams, *prkParams,
                         rgVtpIpAdapter, celems(rgVtpIpAdapter));


    strValue = L"Adapters\\";
    strValue += pszAdapterDriver;

    GetServiceSubkey(c_szSvcNetBT, strValue.c_str(), prkNetBTParams);
    if (!prkNetBTParams)
        goto error_cleanup;

    strValue.erase();
    prkNetBTParams->QueryValue(c_szNameServer, strValue);
    if (strValue.empty())
    {
        //WINS=No
        pwisParams->AddKey(c_szAfWins, c_szNo);
    }
    else
    {
        //WINS=Yes
        pwisParams->AddKey(c_szAfWins, c_szYes);

        tstring strWinsServerList;
        strWinsServerList = strValue;

        prkNetBTParams->QueryValue(L"NameServerBackup", strValue);
        if (!strValue.empty())
        {
            strWinsServerList += L",";
            strWinsServerList += strValue;
        }
        pwisParams->AddKey(c_szAfWinsServerList, strWinsServerList.c_str());
    }

    // BindToDhcpServer
    // $REVIEW(tongl 2/18/99): Added for bug #192576
    // If this adapter was on the disabled list to DHCP server, set this to FALSE
    // otherwise, don't do anything
    if (fDisabledToDhcpServer)
    {
        pwisParams->AddBoolKey(c_szAfBindToDhcpServer, !fDisabledToDhcpServer);
    }

    if (fDisableNetbios)
    {
        // Value of 2 means disable netbios over tcpip for this interface.
        pwisParams->AddKey(c_szAfNetBIOSOptions, 2);
    }

    fStatus=TRUE;
    goto cleanup;

error_cleanup:
    fStatus = FALSE;

cleanup:
    DeleteIfNotNull(prkParams);
    DeleteIfNotNull(prkNetBTParams);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  WriteAppleTalkParams
//
// Purpose:   Write parameters of AppleTalk protocol
//
// Arguments:
//    pwifAnswerFile             [in]  pointer to answerfile
//    pwisGlobalParams           [in]  pointer to global params section
//    slAdditionalParamsSections [out] list of adapter params sections
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 11-December-97
//
BOOL
WriteAppleTalkParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisGlobalParams,
    OUT TStringList& slAdditionalParamsSections)
{
    DefineFunctionName("WriteAppleTalkParams");

    TraceFunctionEntry(ttidNetUpgrade);

    BOOL fStatus=FALSE;

    tstring strTemp;
    CORegKeyIter *prkiAdapters=NULL;
    tstring strAdapterInstance;
    PCORegKey prkAdapters=NULL;
    tstring strDefaultPort;

    PCORegKey prkParams=NULL;
    GetServiceSubkey(L"AppleTalk", L"Parameters", prkParams);
    if (!prkParams)
        goto error_cleanup;

    //Write Global Parameters

    // DefaultPort
    prkParams->QueryValue(L"DefaultPort", strDefaultPort);
    WCHAR szTemp[256];
    PCWSTR pszNetCardAFileName;
    if ((swscanf(strDefaultPort.c_str(), L"\\Device\\%s", szTemp) == 1) &&
        ((pszNetCardAFileName = MapNetCardInstanceToAFileName(szTemp)) != NULL))
    {
        pwisGlobalParams->AddKey(L"DefaultPort", pszNetCardAFileName);
    }

    // DesiredZone
    WriteRegValueToAFile(pwisGlobalParams,
                         *prkParams,
                         L"DesiredZone");

    // EnableRouter
    WriteRegValueToAFile(pwisGlobalParams,
                         *prkParams,
                         L"EnableRouter",
                         REG_BOOL,
                         NULL,       // dont change value name
                         TRUE,       // use default
                         (BOOL) FALSE); // default value


    //Write Adapter specific parameters
    GetServiceSubkey(L"AppleTalk", L"Adapters", prkAdapters);
    DoErrorCleanupIf(!prkAdapters);

    prkiAdapters = new CORegKeyIter(*prkAdapters);
    prkiAdapters->Reset();

    strTemp = tstring(c_szAfParams) + c_szInfId_MS_AppleTalk + L".";
    while (!prkiAdapters->Next(&strAdapterInstance))
    {
        ContinueIf(strAdapterInstance.empty());

        CORegKey rkAdapterInstance(*prkAdapters, strAdapterInstance.c_str());

        PCWSTR pszNetCardAFileName =
            MapNetCardInstanceToAFileName(strAdapterInstance.c_str());
        ContinueIf(!pszNetCardAFileName);

        tstring strAdapterParamsSection = strTemp + pszNetCardAFileName;
        AddAtEndOfStringList(slAdditionalParamsSections, strAdapterParamsSection);

        PCWInfSection pwisAdapterParams;
        pwisAdapterParams =
            pwifAnswerFile->AddSection(strAdapterParamsSection.c_str());

        //SpecificTo
        pwisAdapterParams->AddKey(c_szAfSpecificTo, pszNetCardAFileName);

        // DefaultZone
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"DefaultZone");

        // NetworkRangeLowerEnd
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"NetworkRangeLowerEnd",
                             REG_DWORD);

        // NetworkRangeUpperEnd
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"NetworkRangeUpperEnd",
                             REG_DWORD);

        // PortName
        //
        //$ REVIEW  kumarp 24-May-97
        //  the value is of the form ieepro2@kumarp1
        //  this may need to be changed to Adapter03@kumarp1
        //
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"PortName");

        // SeedingNetwork
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"SeedingNetwork",
                             REG_DWORD,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (DWORD) 0); // default value

        // ZoneList
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"ZoneList",
                             REG_MULTI_SZ);

    }

    fStatus = TRUE;
    goto cleanup;

error_cleanup:
    fStatus = FALSE;

cleanup:
    DeleteIfNotNull(prkParams);
    DeleteIfNotNull(prkAdapters);
    DeleteIfNotNull(prkiAdapters);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  WritePPTPParams
//
// Purpose:   Write parameters of PPTP protocol
//
// Arguments:
//    pwifAnswerFile             [in]  pointer to answerfile
//    pwisParams                 [in]  pointer to global params section
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 11-December-97
//
BOOL
WritePPTPParams (
    PCWInfFile pwifAnswerFile,
    PCWInfSection pwisParams)
{
    DefineFunctionName("WritePPTPParams");

    TraceFunctionEntry(ttidNetUpgrade);

    //NumberLineDevices
    WriteServiceRegValueToAFile(pwisParams,
                                L"RASPPTPE\\Parameters\\Configuration",
                                L"NumberLineDevices",
                                REG_DWORD);

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteIPXParams
//
// Purpose:   Write parameters of IPX protocol
//
// Arguments:
//    pwifAnswerFile             [in]  pointer to answerfile
//    pwisIPXGlobalParams        [in]  pointer to global params section
//    slAdditionalParamsSections [out] list of adapter params sections
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 11-December-97
//
BOOL
WriteIPXParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisIPXGlobalParams,
    OUT TStringList& slAdditionalParamsSections)
{
    DefineFunctionName("WriteIPXParams");

    TraceFunctionEntry(ttidNetUpgrade);

    BOOL fStatus=FALSE;

    tstring strTemp;
    CORegKeyIter *prkiNetConfig=NULL;

    //InternalNetworkNumber
    WriteServiceRegValueToAFile(pwisIPXGlobalParams,
                                L"NwlnkIpx\\Parameters",
                                L"VirtualNetworkNumber",
                                REG_HEX,
                                c_szAfInternalNetworkNumber);

    // DedicatedRouter
    WriteServiceRegValueToAFile(pwisIPXGlobalParams,
                                L"NwlnkIpx\\Parameters",
                                L"DedicatedRouter",
                                REG_BOOL,
                                NULL,     // dont change value name
                                TRUE,     // use default
                                (BOOL) FALSE);   // default value

    // EnableWANRouter
    WriteServiceRegValueToAFile(pwisIPXGlobalParams,
                                L"NwlnkIpx\\Parameters",
                                L"EnableWANRouter",
                                REG_BOOL,
                                NULL,     // dont change value name
                                TRUE,     // use default
                                TRUE);    // default value

    // RipRoute
    WriteServiceRegValueToAFile(pwisIPXGlobalParams,
                                L"NwlnkIpx\\Parameters",
                                L"RipRoute",
                                REG_DWORD);

    // ------------------------------------------------------------------------------



    //Write Adapter specific parameters
    tstring strAdapterInstance;
    PCORegKey prkNetConfig=NULL;
    GetServiceSubkey(L"NwlnkIpx", L"NetConfig", prkNetConfig);
    if (!prkNetConfig)
        goto error_cleanup;

    prkiNetConfig = new CORegKeyIter(*prkNetConfig);
    prkiNetConfig->Reset();

    strTemp = tstring(c_szAfParams) + c_szInfId_MS_NWIPX + L".";
    while (!prkiNetConfig->Next(&strAdapterInstance))
    {
        ContinueIf(strAdapterInstance.empty());

        CORegKey rkAdapterInstance(*prkNetConfig, strAdapterInstance.c_str());

        PCWSTR pszNetCardAFileName =
            MapNetCardInstanceToAFileName(strAdapterInstance.c_str());
        ContinueIf(!pszNetCardAFileName);

        tstring strAdapterParamsSection = strTemp + pszNetCardAFileName;
        AddAtEndOfStringList(slAdditionalParamsSections, strAdapterParamsSection);

        PCWInfSection pwisAdapterParams;
        pwisAdapterParams =
            pwifAnswerFile->AddSection(strAdapterParamsSection.c_str());

        //SpecificTo
        pwisAdapterParams->AddKey(c_szAfSpecificTo, pszNetCardAFileName);

        // PktType
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"PktType",
                             REG_MULTI_SZ);

        // MaxPktSize
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"MaxPktSize",
                             REG_DWORD,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (DWORD) 0); // default value

        // NetworkNumber
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"NetworkNumber",
                             REG_MULTI_SZ);

        // BindSap
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"BindSap",
                             REG_HEX,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (DWORD) 0x8137); // default value

        // EnableFuncAddr
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"EnableFuncaddr",
                             REG_BOOL,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             TRUE);      // default value

        // SourceRouteDef
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"SourceRouteDef",
                             REG_DWORD,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (DWORD) 0); // default value

        // SourceRouteMcast
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"SourceRouteMcast",
                             REG_BOOL,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (BOOL) FALSE);     // default value

        // SourceRouting
        WriteRegValueToAFile(pwisAdapterParams,
                             rkAdapterInstance,
                             L"SourceRouting",
                             REG_BOOL,
                             NULL,       // dont change value name
                             TRUE,       // use default
                             (BOOL) FALSE);     // default value



        strAdapterInstance.erase();
    }

    fStatus=TRUE;
    goto cleanup;

  error_cleanup:
    fStatus=FALSE;

  cleanup:
    //    DeleteIfNotNull(prkParams);
    DeleteIfNotNull(prkNetConfig);
    DeleteIfNotNull(prkiNetConfig);

    return fStatus;
}

static const WCHAR c_szRegKeyRas[]      = L"Software\\Microsoft\\RAS";
static const WCHAR c_szRegKeyRasMan[]   = L"System\\CurrentControlSet\\Services\\Rasman\\PPP";
static const WCHAR c_szRegKeyRasManSH[] = L"System\\CurrentControlSet\\Services\\Rasman\\PPP\\COMPCP";
static const WCHAR c_szRegKeyUnimodem[] = L"TAPI DEVICES\\Unimodem";
static const WCHAR c_szAddress[]        = L"Address";
static const WCHAR c_szUsage[]          = L"Usage";

// ----------------------------------------------------------------------
//
// Function:  HrGetRasPortsInfo
//
// Purpose:   Find out ports' usage info from registry.
//            If the registry does not have this info (in case of NT3.51)
//            then try to get it from serial.ini file
//
// Arguments:
//    pslPorts [out] list of ports
//    pslUsage [out] usage of ports in the above list
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 17-December-97
//
HRESULT
HrGetRasPortsInfo (
    OUT TStringList* pslPorts,
    OUT TStringList* pslUsage)
{
    DefineFunctionName("HrGetRasPortsInfo");

    HRESULT hr=S_OK;

    HKEY hkeyUnimodem;
    tstring strUnimodem;
    strUnimodem = c_szRegKeyRas;
    strUnimodem += '\\';
    strUnimodem += c_szRegKeyUnimodem;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, strUnimodem.c_str(),
                        KEY_READ, &hkeyUnimodem);
    if (S_OK == hr)
    {
        hr = HrRegQueryColString(hkeyUnimodem, c_szAddress, pslPorts);
        if (S_OK == hr)
        {
            hr = HrRegQueryColString(hkeyUnimodem, c_szUsage, pslUsage);
        }
    }

    if (pslPorts->empty())
    {
        TraceTag(ttidNetUpgrade, "%s: there are no entries found under %S",
                 __FUNCNAME__, strUnimodem.c_str());
        TraceTag(ttidNetUpgrade, "%s: trying to get port usage info from serial.ini file", __FUNCNAME__);

        HINF hinf;
        tstring strSerialIni;
        hr = HrGetWindowsDir(&strSerialIni);
        if (S_OK == hr)
        {
            static const WCHAR c_szSystem32SerialIni[] =
                L"\\system32\\ras\\serial.ini";
            strSerialIni += c_szSystem32SerialIni;

            hr = HrSetupOpenInfFile(strSerialIni.c_str(), NULL,
                                    INF_STYLE_OLDNT, NULL, &hinf);
            if (S_OK == hr)
            {
                tstring strUsage;
                WCHAR szPortName[16];
                INFCONTEXT ic;

                for (int i=1; i<=255; i++)
                {
                    swprintf(szPortName, L"COM%d", i);

                    hr = HrSetupFindFirstLine(hinf, szPortName, c_szUsage, &ic);
                    if (S_OK == hr)
                    {
                        hr = HrSetupGetStringField(ic, 1, &strUsage);
                        if (S_OK == hr)
                        {
                            TraceTag(ttidNetUpgrade,
                                     "%s: as per serial.ini file: %S --> %S",
                                     __FUNCNAME__, szPortName, strUsage.c_str());
                            pslPorts->push_back(new tstring(szPortName));
                            pslUsage->push_back(new tstring(strUsage.c_str()));
                        }
                    }
                }

                hr = S_OK;
                SetupCloseInfFile(hinf);
            }
        }
    }

    TraceError(__FUNCNAME__, hr);

    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  ConvertIpAddrRangeToAddrAndMask
//
// Purpose:   Convert a range of IP addr specified using Start/End to
//            equivalent Start+Mask combination
//
// Arguments:
//    pszIpBegin  [in]  Start addr
//    pszIpEnd    [in]  End addr
//    pstrIpAddr [out] pointer to Start addr
//    pstrIpMask [out] pointer to Mask
//
// Returns:   None
//
// Author:    kumarp 27-April-98
//
void
ConvertIpAddrRangeToAddrAndMask(
    IN PCWSTR pszIpBegin,
    IN PCWSTR pszIpEnd,
    OUT tstring* pstrIpAddr,
    OUT tstring* pstrIpMask)
{
    WCHAR szBuf[16];

    DWORD dwIpBegin = IpPszToHostAddr(pszIpBegin);
    DWORD dwIpEnd   = IpPszToHostAddr(pszIpEnd);

    // dwTemp will have a bit set for each common bit between
    // dwIpBegin and dwIpEnd.
    //
    DWORD dwTemp = ~(dwIpBegin ^ dwIpEnd);

    // Compute the subnet mask as the longest run of 1s from
    // the highest order down.
    //
    DWORD dwIpMask = 0;
    while (dwTemp & 0x80000000)
    {
        dwTemp <<= 1;   // Eventually shifts a zero to the high bit
        // so the loop will stop.

        // Form the mask by shifting 1 right from the high bit.
        dwIpMask = 0x80000000 | (dwIpMask >> 1);
    }

    // Reset the begin address (if needed) to the base of the subnet mask.
    //
    dwIpBegin &= dwIpMask;

    IpHostAddrToPsz(dwIpBegin, szBuf);
    *pstrIpAddr = szBuf;

    IpHostAddrToPsz(dwIpMask, szBuf);
    *pstrIpMask = szBuf;
}


// ----------------------------------------------------------------------
//
// Function:  ConvertAddrAndMaskToIpAddrRange
//
// Purpose:   Convert a IP address Start + Mask combination into the
//            equivalent IP address range
//
// Arguments:
//    pszIpAddr   [in]  Start
//    pszIpMask   [in]  Mask
//    pstrIpBegin [out] pointer to Start addr
//    pstrIpEnd   [out] pointer to End addr
//
// Returns:   None
//
// Author:    SumitC    28-Jul-99
//
void
ConvertAddrAndMaskToIpAddrRange(
    IN PCWSTR pszIpAddr,
    IN PCWSTR pszIpMask,
    OUT tstring* pstrIpBegin,
    OUT tstring* pstrIpEnd)
{
    WCHAR szBuf[16];

    DWORD dwIpBegin = IpPszToHostAddr(pszIpAddr);

    // dwEnd is generated by inverting the mask and adding to IpBegin
    //
    DWORD dwIpEnd = dwIpBegin + (~ IpPszToHostAddr(pszIpMask));

    *pstrIpBegin = pszIpAddr;

    IpHostAddrToPsz(dwIpEnd, szBuf);
    *pstrIpEnd = szBuf;
}


//+---------------------------------------------------------------------------
//
// Function:  RasGetDialInUsage
//
// Purpose:   Find out if at least one RAS port is configured for dialin.
//
// Returns:   TRUE if at least one port configured for dial in.
//
// Author:    kumarp 28-January-99
//
BOOL
RasGetDialInUsage (VOID)
{
    static const WCHAR c_szTapiDevices[] =
        L"Software\\Microsoft\\RAS\\TAPI DEVICES";
    HRESULT hr=S_OK;
    HKEY hkeyTapiDevices;
    HKEY hkeyTapiDevice;

    BOOL fAtLeastOneDialin = FALSE;

    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE,
                        c_szTapiDevices, KEY_READ,
                        &hkeyTapiDevices);
    if (S_OK == hr)
    {
        WCHAR szBuf[MAX_PATH];
        FILETIME time;
        DWORD dwSize;
        DWORD dwRegIndex;

        for (dwRegIndex = 0, dwSize = celems(szBuf);
             !fAtLeastOneDialin &&
             (S_OK == HrRegEnumKeyEx(hkeyTapiDevices, dwRegIndex, szBuf,
                        &dwSize, NULL, NULL, &time));
             dwRegIndex++, dwSize = celems(szBuf))
        {
            Assert(*szBuf);

            hr = HrRegOpenKeyEx(hkeyTapiDevices,
                                szBuf, KEY_READ,
                                &hkeyTapiDevice);
            if (S_OK == hr)
            {
                PWSTR pmszUsage;

                hr = HrRegQueryMultiSzWithAlloc(hkeyTapiDevice, c_szUsage,
                                                &pmszUsage);
                if ((S_OK == hr) && pmszUsage)
                {
                    PCWSTR pszScan;

                    for (pszScan = pmszUsage;
                         *pszScan;
                         pszScan += wcslen(pszScan) + 1)
                    {
                        if (FIsSubstr(c_szServer, pszScan) ||
                            FIsSubstr(c_szRouter, pszScan))
                        {
                            fAtLeastOneDialin = TRUE;
                            break;
                        }
                    }

                    MemFree(pmszUsage);
                }

                RegCloseKey(hkeyTapiDevice);
            }
        }

        RegCloseKey(hkeyTapiDevices);
    }

    return fAtLeastOneDialin;
}

//+---------------------------------------------------------------------------
//
// Function:  WriteRouterUpgradeInfo
//
// Purpose:   Write info required for upgrading Router to answerfile.
//
// Arguments:
//    pwifAnswerFile [in]  pointer to CWInfFile object
//
// Returns:   None
//
// Author:    kumarp 16-June-98
//
void
WriteRouterUpgradeInfo (
    IN CWInfFile* pwifAnswerFile)
{
    DefineFunctionName("HrWriteRouterUpgradeInfo");

    TraceTag(ttidNetUpgrade, "-----> entering %s", __FUNCNAME__);

    tstring strParamsSectionName;
    CWInfSection* pwisNetServices;
    CWInfSection* pwisRouter;

    strParamsSectionName = c_szAfParams;
    strParamsSectionName = strParamsSectionName + L"ms_rasrtr";

    pwisNetServices = pwifAnswerFile->FindSection(c_szAfSectionNetServices);

    AssertSz(pwisNetServices, "No [NetServices] section ??");

    pwisNetServices->AddKey(L"ms_rasrtr", strParamsSectionName.c_str());
    pwisRouter = pwifAnswerFile->AddSection(strParamsSectionName.c_str());
    pwisRouter->AddKey(c_szAfInfid, L"ms_rasrtr");
    pwisRouter->AddKey(c_szAfParamsSection, strParamsSectionName.c_str());

    (void) HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcRouter, NULL,
                                                    c_szAfPreUpgradeRouter,
                                                    pwisRouter);

    (void) HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcSapAgent,
                                                    c_szParameters,
                                                    c_szAfNwSapAgentParams,
                                                    pwisRouter);

    (void) HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcRipForIp,
                                                    c_szParameters,
                                                    c_szAfIpRipParameters,
                                                    pwisRouter);

    (void) HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcDhcpRelayAgent,
                                                    c_szParameters,
                                                    c_szAfDhcpRelayAgentParameters,
                                                    pwisRouter);

    (void) HrNetRegSaveKeyAndAddToSection(HKEY_LOCAL_MACHINE,
                                          L"Software\\Microsoft\\Ras\\Radius",
                                          L"Radius",
                                          c_szAfRadiusParameters,
                                          pwisRouter);
}

// ----------------------------------------------------------------------
//
// Function:  WriteRASParams
//
// Purpose:   Write RAS parameters to the answerfile
//
// Arguments:
//    pwifAnswerFile  [in]  pointer to answerfile
//    pwisNetServices [in]  pointer to NetServices section
//    pwisParams      [in]  pointer to global params section
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 11-December-97
//
BOOL
WriteRASParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisNetServices,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteRASParams");

    TraceFunctionEntry(ttidNetUpgrade);

    PCORegKey prkRAS = new CORegKey(HKEY_LOCAL_MACHINE, c_szRegKeyRas);
    PCORegKey prkProtocols = new CORegKey(*prkRAS, L"Protocols");

    if(!prkRAS || !prkProtocols) 
    {
        return false;
    }

    WriteRegValueToAFile(pwisParams, *prkProtocols, c_szAfRouterType, REG_DWORD);

    TStringList slPorts, slUsage, slTemp;
    tstring strPorts, strValue, strTemp, strPortSections;
    tstring strIpAddrStart;
    tstring strIpAddrEnd;
    DWORD dwValue=0;
    BOOL  fSteelHeadInstalled=FALSE;
    HRESULT hr=S_OK;
    LONG err;

    // find out if SteelHead is installed.
    // if the service "Router" is found --> SteelHead is installed
    fSteelHeadInstalled = FIsServiceKeyPresent(c_szSvcRouter);

    PCWInfSection pwisPort;

    (void) HrGetRasPortsInfo(&slPorts, &slUsage);

    TStringListIter pos1 = slPorts.begin();
    TStringListIter pos2 = slUsage.begin();
    //Write parameters for each port
    while ((pos1 != slPorts.end()) && (pos2 != slUsage.end()))
    {
        strValue = **pos1++;
        strTemp = c_szAfParams;
        strTemp += strValue;
        if (!strPortSections.empty())
        strPortSections += c_szAfListDelimiter;
        strPortSections += strTemp;

        pwisPort = pwifAnswerFile->AddSection(strTemp.c_str());

        //PortName
        pwisPort->AddKey(c_szAfPortname, strValue.c_str());

        //PortUsage
        strValue = **pos2++;
        //MapPortUsageRegValueToAFileValue(strValue, strValue);
        pwisPort->AddKey(c_szAfPortUsage, strValue.c_str());

        //this decides what we need to install
        // i.e a combination of MS_RasCli / MS_RasSrv
        //
        if (wcsstr(strValue.c_str(), L"Client"))
        {
            TraceTag(ttidNetUpgrade,
                     "%s: g_fAtLeastOneDialOut set to TRUE because of PortUsage %S",
                     __FUNCNAME__, strValue.c_str());
            g_fAtLeastOneDialOut = TRUE;
        }


        if (wcsstr(strValue.c_str(), c_szServer))
        {
            TraceTag(ttidNetUpgrade,
                     "%s: g_fAtLeastOneDialIn set to TRUE because of PortUsage %S",
                     __FUNCNAME__, strValue.c_str());
            g_fAtLeastOneDialIn = TRUE;
        }

    }

    // if the Port usage cannot be determined using the ports list
    // then we need to use the values found using ndiswan ProductName
    //
    if (slPorts.size() == 0)
    {
        TraceTag(ttidNetUpgrade, "%s: Since PortUsage is not defined, using flags generated by inspecting ndiswan ProductName",
                 __FUNCNAME__);
        g_fAtLeastOneDialIn = g_fAtLeastOneDialInUsingNdisWan;
        g_fAtLeastOneDialOut = g_fAtLeastOneDialOutUsingNdisWan;
    }

    //Now write RAS Global parameters
    ValueTypePair rgVtpRasParams[] = {
        {L"ForceEncryptedPassword", REG_DWORD},
        {L"ForceEncryptedData",REG_BOOL},
        {L"Multilink", REG_BOOL}};

    WriteRegValueToAFile(pwisParams, *prkProtocols,
                         rgVtpRasParams, celems(rgVtpRasParams));

    //PortSections
    pwisParams->AddKey(c_szAfPortSections, strPortSections.c_str());

    //DialoutProtocols
    err = prkProtocols->QueryValue(L"fIpxSelected", dwValue);
    if ((0 == err) && dwValue)
    {
        AddAtEndOfStringList(slTemp, c_szAfIpx);
    }
    err = prkProtocols->QueryValue(L"fNetbeuiSelected", dwValue);
    if ((0 == err) && dwValue)
    {
        AddAtEndOfStringList(slTemp, c_szAfNetbeui);
    }
    err = prkProtocols->QueryValue(L"fTcpIpSelected", dwValue);
    if ((0 == err) && dwValue)
    {
        AddAtEndOfStringList(slTemp, c_szAfTcpip);
    }
    if (!slTemp.empty())
        pwisParams->AddKey(L"DialoutProtocols", slTemp);


    //DialinProtocols
    DWORD dwIpxAllowed, dwNetBEUIAllowed, dwTcpIpAllowed;

    EraseAndDeleteAll(slTemp);
    err = prkProtocols->QueryValue(L"fIpxAllowed", dwIpxAllowed);
    if ((0 == err) && dwIpxAllowed)
    {
        AddAtEndOfStringList(slTemp, c_szAfIpx);
    }
    err = prkProtocols->QueryValue(L"fNetbeuiAllowed", dwNetBEUIAllowed);
    if ((0 == err) && dwNetBEUIAllowed)
    {
        AddAtEndOfStringList(slTemp, c_szAfNetbeui);
    }
    err = prkProtocols->QueryValue(L"fTcpIpAllowed", dwTcpIpAllowed);
    if ((0 == err) && dwTcpIpAllowed)
    {
        AddAtEndOfStringList(slTemp, c_szAfTcpip);
    }
    if (!slTemp.empty())
        pwisParams->AddKey(L"DialinProtocols", slTemp);

    if (dwNetBEUIAllowed)
    {
        //NetBEUIClientAccess
        PCORegKey prkNetBEUI = new CORegKey(*prkProtocols, L"NBF");
        err = prkNetBEUI->QueryValue(L"NetbiosGatewayEnabled", dwValue);
        if (0 == err)
        {
            if (dwValue)
            {
                pwisParams->AddKey(c_szAfNetbeuiClientAccess, c_szAfNetwork);
            }
            else
            {
                pwisParams->AddKey(c_szAfNetbeuiClientAccess, c_szAfThisComputer);
            }
        }
        DeleteIfNotNull(prkNetBEUI);
    }

    if (dwTcpIpAllowed)
    {
        //TcpIpClientAccess
        PCORegKey prkTcpIp = new CORegKey(*prkProtocols, L"IP");
        err = prkTcpIp->QueryValue(L"AllowNetworkAccess", dwValue);
        if (0 == err)
        {
            if (dwValue)
            {
                pwisParams->AddKey(c_szAfTcpipClientAccess, c_szAfNetwork);
            }
            else
            {
                pwisParams->AddKey(c_szAfTcpipClientAccess, c_szAfThisComputer);
            }
        }

        //UseDHCP
        err = prkTcpIp->QueryValue(L"UseDHCPAddressing", dwValue);
        if (0 == err)
        {
            pwisParams->AddBoolKey(c_szAfUseDhcp, dwValue);
            if (!dwValue)
            {
                // registry values for NT4
                static const WCHAR c_szIpAddressStart[] = L"IpAddressStart";
                static const WCHAR c_szIpAddressEnd[]   = L"IpAddressEnd";

                err = prkTcpIp->QueryValue(c_szIpAddressStart, strIpAddrStart);
                if (0 == err)
                {
                    err = prkTcpIp->QueryValue(c_szIpAddressEnd, strIpAddrEnd);
                    if (0 == err)
                    {
                        pwisParams->AddKey(c_szAfIpAddressStart, strIpAddrStart.c_str());
                        pwisParams->AddKey(c_szAfIpAddressEnd,  strIpAddrEnd.c_str());
                    }
                }
                else if (ERROR_FILE_NOT_FOUND == err)
                {
                    // IpAddressStart value not found, try for IpAddress/Mask

                    static const WCHAR c_szIpAddress[]      = L"IpAddress";
                    static const WCHAR c_szIpMask[]         = L"IpMask";
                    tstring strIpAddr;
                    tstring strIpMask;

                    err = prkTcpIp->QueryValue(c_szIpAddress, strIpAddr);
                    if (0 == err)
                    {
                        err = prkTcpIp->QueryValue(c_szIpMask, strIpMask);
                        if (0 == err)
                        {
                            ConvertAddrAndMaskToIpAddrRange(strIpAddr.c_str(),
                                                            strIpMask.c_str(),
                                                            &strIpAddrStart,
                                                            &strIpAddrEnd);
                            pwisParams->AddKey(c_szAfIpAddressStart, strIpAddrStart.c_str());
                            pwisParams->AddKey(c_szAfIpAddressEnd,  strIpAddrEnd.c_str());
                        }
                    }   
                }
            }
        }

        //ClientCanRequestIPAddress
        if (0 == prkTcpIp->QueryValue(L"AllowClientIPAddresses", dwValue))
        {
            pwisParams->AddBoolKey(c_szAfClientCanReqIpaddr, dwValue);
        }

        DeleteIfNotNull(prkTcpIp);
    }

    if (dwIpxAllowed)
    {
        //IpxClientAccess
        PCORegKey prkIpx = new CORegKey(*prkProtocols, L"IPX");
        err = prkIpx->QueryValue(L"AllowNetworkAccess", dwValue);
        if (0 == err)
        {
            if (dwValue)
            {
                pwisParams->AddKey(c_szAfIpxClientAccess, c_szAfNetwork);
            }
            else
            {
                pwisParams->AddKey(c_szAfIpxClientAccess, c_szAfThisComputer);
            }
        }

        //AutomaticNetworkNumbers
        err = prkIpx->QueryValue(L"AutoWanNetAllocation", dwValue);
        if (0 == err)
        {
            pwisParams->AddBoolKey(c_szAfAutoNetworkNumbers, dwValue);
        }

        //NetworkNumberFrom
        err = prkIpx->QueryValue(L"FirstWanNet", dwValue);
        if (0 == err)
        {
            pwisParams->AddKey(c_szAfNetNumberFrom, dwValue);
        }

        // WanNetPoolSize
        err = prkIpx->QueryValue(L"WanNetPoolSize", dwValue);
        if (0 == err)
        {
            pwisParams->AddKey(c_szAfWanNetPoolSize, dwValue);
        }

        //AssignSameNetworkNumber
        err = prkIpx->QueryValue(L"GlobalWanNet", dwValue);
        if (0 == err)
        {
            pwisParams->AddBoolKey(c_szAfSameNetworkNumber, dwValue);
        }

        //ClientsCanRequestIpxNodeNumber
        err = prkIpx->QueryValue(L"AcceptRemoteNodeNumber", dwValue);
        if (0 == err)
        {
            pwisParams->AddBoolKey(c_szAfClientReqNodeNumber, dwValue);
        }

        DeleteIfNotNull(prkIpx);
    }

    {
        //SecureVPN

        PCORegKey prkRasman = new CORegKey(HKEY_LOCAL_MACHINE, c_szRegKeyRasMan);

        err = prkRasman->QueryValue(L"SecureVPN", dwValue);
        if (0 == err)
        {
            pwisParams->AddKey(c_szAfSecureVPN, dwValue);
        }

        //ForceStrongEncryption
        // 398632: write this value, for both regular RAS case & steelhead case

        dwValue = 0;    // to avoid fall-thru problem (writing 0 to the answerfile is ok)
        if (fSteelHeadInstalled)
        {
            err = prkRasman->QueryValue(L"ForceStrongEncryption", dwValue);
        }
        else
        {
            PCORegKey prkComPCP = new CORegKey(HKEY_LOCAL_MACHINE, c_szRegKeyRasManSH);
            err = prkComPCP->QueryValue(L"ForceStrongEncryption", dwValue);
            DeleteIfNotNull(prkComPCP);
        }

        if (0 == err)
        {
            pwisParams->AddBoolKey(c_szAfForceStrongEncryption, dwValue);
        }

        DeleteIfNotNull(prkRasman);
    }

    pwifAnswerFile->GotoEnd();
    tstring strParamsSectionName;
    PCWInfSection pwisRasComponent;

    if (g_fAtLeastOneDialOut)
    {
        strParamsSectionName = c_szAfParams;
        strParamsSectionName = strParamsSectionName + c_szInfId_MS_RasCli;
        pwisNetServices->AddKey(c_szInfId_MS_RasCli, strParamsSectionName.c_str());
        pwisRasComponent = pwifAnswerFile->AddSection(strParamsSectionName.c_str());
        pwisRasComponent->AddKey(c_szAfInfid, c_szInfId_MS_RasCli);
        pwisRasComponent->AddKey(c_szAfParamsSection, pwisParams->Name());
    }

    if (g_fAtLeastOneDialIn)
    {
        strParamsSectionName = c_szAfParams;
        strParamsSectionName = strParamsSectionName + c_szInfId_MS_RasSrv;
        pwisNetServices->AddKey(c_szInfId_MS_RasSrv, strParamsSectionName.c_str());
        pwisRasComponent = pwifAnswerFile->AddSection(strParamsSectionName.c_str());
        pwisRasComponent->AddKey(c_szAfInfid, c_szInfId_MS_RasSrv);
        pwisRasComponent->AddKey(c_szAfParamsSection, pwisParams->Name());
    }

    // SetDialInUsage
    BOOL fSetDialInUsage = TRUE;

    if (g_NetUpgradeInfo.To.ProductType != NT_SERVER)
    {
        fSetDialInUsage = RasGetDialInUsage ();
    }
    pwisParams->AddKey(c_szAfSetDialinUsage, (UINT) fSetDialInUsage);

    if (fSteelHeadInstalled)
    {
        WriteRouterUpgradeInfo(pwifAnswerFile);
    }
    else
    {
        TraceTag(ttidNetUpgrade, "%s: Router is not installed", __FUNCNAME__);
    }

    DeleteIfNotNull(prkRAS);
    DeleteIfNotNull(prkProtocols);

    EraseAndDeleteAll(slTemp);
    EraseAndDeleteAll(slPorts);
    EraseAndDeleteAll(slUsage);

    return TRUE;
}
// ----------------------------------------------------------------------
//
// Function:  HrWritePreSP3ComponentsToSteelHeadUpgradeParams
//
// Purpose:   Write parameters of pre-SP3 steelhead components to answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 11-December-97
//
// Notes:     DHCPRelayAgent, Rip for Ip(x), SapAgent --> Steelhead upgrade
//
HRESULT
HrWritePreSP3ComponentsToSteelHeadUpgradeParams(
    IN CWInfFile* pwifAnswerFile)
{
    DefineFunctionName("HrWritePreSP3ComponentsToSteelHeadUpgradeParams");

    TraceFunctionEntry(ttidNetUpgrade);

    HRESULT hr=S_OK;
    CWInfSection* pwisServices;
    pwisServices = pwifAnswerFile->FindSection(c_szAfSectionNetServices);
    if (!pwisServices)
    {
        hr = E_FAIL;
        goto return_from_function;
    }

    if (FIsServiceKeyPresent(c_szSvcRouter))
    {
        hr = S_OK;
        TraceTag(ttidNetUpgrade, "%s: SteelHead is found to be installed, individual components will not be upgraded", __FUNCNAME__);
        goto return_from_function;
    }

    BOOL fSrv2SrvUpgrade;
        
    fSrv2SrvUpgrade = FALSE;

    if (g_NetUpgradeInfo.From.ProductType == NT_SERVER)
    {
        if (g_NetUpgradeInfo.To.ProductType == NT_WORKSTATION)
        {
            AssertSz(FALSE, "Cannot upgrade from srv to wks!!");
        }
        else if (g_NetUpgradeInfo.To.ProductType == NT_SERVER)
        {
            fSrv2SrvUpgrade = TRUE;
        }
    }

    BOOL fInstallSteelHead;
    BOOL fInstallSapAgent;

    fInstallSteelHead = FALSE;
    fInstallSapAgent = FALSE;

    BOOL fSapAgentInstalled;
    BOOL fRipForIpInstalled;
    BOOL fRipForIpxInstalled;
    BOOL fDhcpRelayAgentInstalled;

    fSapAgentInstalled = FALSE;
    fRipForIpInstalled = FALSE;
    fRipForIpxInstalled = FALSE;
    fDhcpRelayAgentInstalled = FALSE;

    // first find out which components are installed.
    //
    fSapAgentInstalled = FIsServiceKeyPresent(c_szSvcSapAgent);
    fRipForIpInstalled = FIsServiceKeyPresent(c_szSvcRipForIp);
    fRipForIpxInstalled = FIsServiceKeyPresent(c_szSvcRipForIpx);
    fDhcpRelayAgentInstalled = FIsServiceKeyPresent(c_szSvcDhcpRelayAgent);

#ifdef ENABLETRACE
    if (fSapAgentInstalled)
    {
        TraceTag(ttidNetUpgrade, "%s: %S is installed", __FUNCNAME__,
                 c_szSvcSapAgent);
    }

    if (fRipForIpInstalled)
    {
        TraceTag(ttidNetUpgrade, "%s: %S is installed", __FUNCNAME__,
                 c_szSvcRipForIp);
    }

    if (fRipForIpxInstalled)
    {
        TraceTag(ttidNetUpgrade, "%s: %S is installed", __FUNCNAME__,
                 c_szSvcRipForIpx);
    }

    if (fDhcpRelayAgentInstalled)
    {
        TraceTag(ttidNetUpgrade, "%s: %S is installed", __FUNCNAME__,
                 c_szSvcDhcpRelayAgent);
    }
#endif
    // now separate out cases to consider
    //
    if (fSapAgentInstalled &&
        !(fRipForIpxInstalled || fRipForIpInstalled || fDhcpRelayAgentInstalled))
    {
        fInstallSapAgent = TRUE;
    }
    else if (fRipForIpInstalled &&
             !(fRipForIpxInstalled || fSapAgentInstalled ||
               fDhcpRelayAgentInstalled))
    {
        if (fSrv2SrvUpgrade)
        {
            fInstallSteelHead = TRUE;
        }
    }
    else if ((fRipForIpInstalled && fSapAgentInstalled) &&
             !(fRipForIpxInstalled || fDhcpRelayAgentInstalled))
    {
        if (fSrv2SrvUpgrade)
        {
            fInstallSteelHead = TRUE;
        }
        else
        {
            fInstallSapAgent = TRUE;
        }
    }
    else if (fRipForIpxInstalled || fDhcpRelayAgentInstalled)
    {
        fInstallSteelHead = TRUE;
    }
    else
    {
        TraceTag(ttidNetUpgrade, "%s: no pre-SP3 steelhead components found",
                 __FUNCNAME__);
    }

    AssertSz(!(fInstallSapAgent && fInstallSteelHead),
             "Both fInstallSteelHead && fInstallSapAgent cannot be TRUE");


    // now go ahead and output the right information for the right case
    // in the answerfile
    //
    if (fInstallSteelHead)
    {
        TraceTag(ttidNetUpgrade,
                 "%s: The component(s) found will be upgraded to SteelHead",
                 __FUNCNAME__);

        WriteRouterUpgradeInfo(pwifAnswerFile);
    }
    else if (fInstallSapAgent)
    {
        TraceTag(ttidNetUpgrade, "%s: dumping data to upgrade SAP agent", __FUNCNAME__);

        CWInfSection* pwisServices;
        pwisServices = pwifAnswerFile->FindSection(c_szAfSectionNetServices);
        AssertSz(pwisServices, "[NetServices] section missing!!");

        if (pwisServices)
        {
            tstring strSapSection;
            strSapSection  = c_szAfParams;
            strSapSection += c_szInfId_MS_NwSapAgent;

            CWInfSection* pwisSap;
            pwisSap = pwifAnswerFile->AddSection(strSapSection.c_str());
            if (pwisSap)
            {
                pwisServices->AddKey(c_szInfId_MS_NwSapAgent,
                                     strSapSection.c_str());
                (void) HrNetRegSaveServiceSubKeyAndAddToSection(
                        c_szSvcSapAgent,
                        c_szParameters,
                        c_szAfNwSapAgentParams,
                        pwisSap);
            }
        }
    }

return_from_function:
    TraceError(__FUNCNAME__, hr);

    return hr;
}


// ----------------------------------------------------------------------
//
// Function:  WriteNetBIOSParams
//
// Purpose:   Write parameters of NetBIOS to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write this info
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteNetBIOSParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteNetBIOSParams");

    TraceFunctionEntry(ttidNetUpgrade);

    PCORegKey prkLinkage;

    // The netbios section will be used to apply lana config but since
    // MSClient installs NetBIOS we don't want to install it
    // via the answerfilein GUI mode.
    //
    pwisParams->AddBoolKey(c_szAfSkipInstall, TRUE);

    GetServiceSubkey(c_szSvcNetBIOS, c_szLinkage, prkLinkage);
    if (!prkLinkage)
        return FALSE;

    TStringList     slRoutes, slRoute, slLanaPath;
    tstring         strRoute, strLanaPath, strTemp;
    TStringListIter iter;
    TByteArray baLanaMap;

    prkLinkage->QueryValue(L"LanaMap", baLanaMap);

    BYTE* pbData=NULL;

    if (baLanaMap.size() > 0)
    {
        GetDataFromByteArray(baLanaMap, pbData);

        WORD* pwLanaCodes;
        WORD wLanaNumber;
        WORD wRouteNum;

        pwLanaCodes = (WORD *) pbData;

        prkLinkage->QueryValue(c_szRegValRoute, slRoutes);

        iter = slRoutes.begin();
        wRouteNum=0;

        while (iter != slRoutes.end())
        {
            strRoute = **iter++;
            TraceTag(ttidNetUpgrade, "%s: processing: %S",
                     __FUNCNAME__, strRoute.c_str());

            EraseAndDeleteAll(slLanaPath);
            ConvertRouteToStringList(strRoute.c_str(), slRoute);
            TStringListIter pos2 = slRoute.begin();
            while (pos2 != slRoute.end())
            {
                strTemp = **pos2++;
                TraceTag(ttidNetUpgrade, "%s: route component: %S",
                         __FUNCNAME__, strTemp.c_str());
                if (IsNetCardProductName(strTemp.c_str()))
                    continue;
                MapNetComponentNameForBinding(strTemp.c_str(), strTemp);
                AddAtEndOfStringList(slLanaPath, strTemp.c_str());

                // Stop adding components if the last one soesn't
                // expose its lower components.
                if (FIsDontExposeLowerComponent (strTemp.c_str()))
                {
                    break;
                }
            }

            // Note: The following must be written out exactly!!!  The
            // consumer of this information expects each LanaPath key to be
            // followed by the corresponding LanaNumber key.
            //
            TraceStringList(ttidNetUpgrade, L"LanaPath: ", slLanaPath);
            pwisParams->AddKey(L"LanaPath", slLanaPath);

            wLanaNumber = HIBYTE (pwLanaCodes[wRouteNum]);

            TraceTag(ttidNetUpgrade, "%s: LanaNumber: 0x%x", __FUNCNAME__, wLanaNumber);
            pwisParams->AddHexKey(L"LanaNumber", wLanaNumber);

            wRouteNum++;
        }
        pwisParams->AddKey (L"NumberOfPaths", wRouteNum);
    }
    else
    {
        TraceTag(ttidNetUpgrade, "%s: LanaMap has no entries!!, skipped LanaMap dump", __FUNCNAME__);
    }

    DeleteIfNotNull(prkLinkage);

    EraseAndDeleteAll(slRoute);
    EraseAndDeleteAll(slRoutes);
    EraseAndDeleteAll(slLanaPath);

    delete pbData;

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteDhcpServerParams
//
// Purpose:   Write parameters of DHCPServer to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteDhcpServerParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteDhcpServerParams");

    TraceFunctionEntry(ttidNetUpgrade);

    static const WCHAR c_szConfiguration[] = L"Configuration";

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcDhcpServer,
                                             c_szParameters,
                                             c_szAfDhcpServerParameters,
                                             pwisParams);

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcDhcpServer,
                                             c_szConfiguration,
                                             c_szAfDhcpServerConfiguration,
                                             pwisParams);

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteTp4Params
//
// Purpose:   Write parameters of Tp4 to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 01-October-98
//
BOOL
WriteTp4Params (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    static const WCHAR c_szCLNP[] = L"IsoTp\\Parameters\\CLNP";
    static const WCHAR c_szLocalMachineName[] = L"LocalMachineName";
    static const WCHAR c_szLocalMachineNSAP[] = L"LocalMachineNSAP";

    WriteServiceRegValueToAFile(pwisParams, c_szCLNP, c_szLocalMachineName);
    WriteServiceRegValueToAFile(pwisParams, c_szCLNP, c_szLocalMachineNSAP);

    return TRUE;
}


// ----------------------------------------------------------------------
//
// Function:WriteWLBSParams
//
// Purpose: Write parameters of WLBS (windows load balancing service)
//          to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    SumitC    04-Mar-99   created
//
BOOL
WriteWLBSParams(
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteWLBSParams");

    TraceFunctionEntry(ttidNetUpgrade);

    /* We should get here only for upgrades from NT4 or earlier */
    Assert (g_NetUpgradeInfo.From.dwBuildNumber);
    Assert (g_NetUpgradeInfo.From.dwBuildNumber <= wWinNT4BuildNumber);

    HRESULT hr = S_OK;

    static const struct
    {
        PCWSTR     szName;
        WORD        wType;
    } aParams[] =
    {
        { CVY_NAME_VERSION,        CVY_TYPE_VERSION          },
        { CVY_NAME_DED_IP_ADDR,    CVY_TYPE_DED_IP_ADDR      },
        { CVY_NAME_DED_NET_MASK,   CVY_TYPE_DED_NET_MASK     },
        { CVY_NAME_HOST_PRIORITY,  CVY_TYPE_HOST_PRIORITY    },
        { CVY_NAME_NETWORK_ADDR,   CVY_TYPE_NETWORK_ADDR     },
        { CVY_NAME_CL_IP_ADDR,     CVY_TYPE_CL_IP_ADDR       },
        { CVY_NAME_CL_NET_MASK,    CVY_TYPE_CL_NET_MASK      },
        { CVY_NAME_CLUSTER_MODE,   CVY_TYPE_CLUSTER_MODE     },
        { CVY_NAME_ALIVE_PERIOD,   CVY_TYPE_ALIVE_PERIOD     },
        { CVY_NAME_ALIVE_TOLER,    CVY_TYPE_ALIVE_TOLER      },
        { CVY_NAME_NUM_ACTIONS,    CVY_TYPE_NUM_ACTIONS      },
        { CVY_NAME_NUM_PACKETS,    CVY_TYPE_NUM_PACKETS      },
        { CVY_NAME_NUM_SEND_MSGS,  CVY_TYPE_NUM_SEND_MSGS    },
        { CVY_NAME_DOMAIN_NAME,    CVY_TYPE_DOMAIN_NAME      },
        { CVY_NAME_LICENSE_KEY,    CVY_TYPE_LICENSE_KEY      },
        { CVY_NAME_RMT_PASSWORD,   CVY_TYPE_RMT_PASSWORD     },
        { CVY_NAME_RCT_PASSWORD,   CVY_TYPE_RCT_PASSWORD     },
        { CVY_NAME_RCT_PORT,       CVY_TYPE_RCT_PORT         },
        { CVY_NAME_RCT_ENABLED,    CVY_TYPE_RCT_ENABLED      },
        { CVY_NAME_NUM_RULES,      CVY_TYPE_NUM_RULES        },
        { CVY_NAME_CUR_VERSION,    CVY_TYPE_CUR_VERSION      },
        { CVY_NAME_PORT_RULES,     CVY_TYPE_PORT_RULES       },
        { CVY_NAME_DSCR_PER_ALLOC, CVY_TYPE_DSCR_PER_ALLOC   },
        { CVY_NAME_MAX_DSCR_ALLOCS,CVY_TYPE_MAX_DSCR_ALLOCS  },
        { CVY_NAME_SCALE_CLIENT,   CVY_TYPE_SCALE_CLIENT     },
        { CVY_NAME_CLEANUP_DELAY,  CVY_TYPE_CLEANUP_DELAY    },
        { CVY_NAME_NBT_SUPPORT,    CVY_TYPE_NBT_SUPPORT      },
        { CVY_NAME_MCAST_SUPPORT,  CVY_TYPE_MCAST_SUPPORT    },
        { CVY_NAME_MCAST_SPOOF,    CVY_TYPE_MCAST_SPOOF      },
        { CVY_NAME_MASK_SRC_MAC,   CVY_TYPE_MASK_SRC_MAC     },
        { CVY_NAME_CONVERT_MAC,    CVY_TYPE_CONVERT_MAC      },
    };

    // Verify that we have the name of the adapter to which NLB should be bound
    if (0 == pszWlbsClusterAdapterName[0])
    {
        hr = E_UNEXPECTED;
    }

    if (SUCCEEDED(hr))
    {
        static const WCHAR c_szWLBSParams[] = L"WLBS\\Parameters";
        tstring szSectionName = pwisParams->Name();
        // Adapter01 is hardcoded is for an NT4 to Whistler upgrade, we will always only have one WLBS adapter
        szSectionName += L".Adapter01";
        pwisParams->AddKey(c_szAfAdapterSections, szSectionName.c_str());
        PCWInfSection pWlbsAdapterSection = pwifAnswerFile->AddSection(szSectionName.c_str());
        if (!pWlbsAdapterSection)
        {
            hr = E_FAIL;
        }

        if (SUCCEEDED(hr))
        {
            pWlbsAdapterSection->AddKey(c_szAfSpecificTo, pszWlbsClusterAdapterName);

            for (UINT i = 0 ; i < celems(aParams); ++i)
            {
                WriteServiceRegValueToAFile(pWlbsAdapterSection,
                                            c_szWLBSParams,
                                            aParams[i].szName,
                                            aParams[i].wType);
            }
        }
    }
    
    if (FAILED(hr))
    {
        TraceError("WriteWLBSParams", hr );
    }

    return SUCCEEDED(hr);

}


// ----------------------------------------------------------------------
//
// Function:WriteConvoyParams
//
// Purpose: Write parameters of Convoy (windows load balancing service)
//          to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    SumitC    04-Mar-99   created
//
BOOL
WriteConvoyParams(
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteConvoyParams");

    TraceFunctionEntry(ttidNetUpgrade);

    HRESULT hr = S_OK;

    static const struct
    {
        PCWSTR     szName;
        WORD        wType;
    } aParams[] =
    {
        { CVY_NAME_VERSION,        CVY_TYPE_VERSION          },
        { CVY_NAME_DED_IP_ADDR,    CVY_TYPE_DED_IP_ADDR      },
        { CVY_NAME_DED_NET_MASK,   CVY_TYPE_DED_NET_MASK     },
        { CVY_NAME_HOST_PRIORITY,  CVY_TYPE_HOST_PRIORITY    },
        { CVY_NAME_NETWORK_ADDR,   CVY_TYPE_NETWORK_ADDR     },
        { CVY_NAME_CL_IP_ADDR,     CVY_TYPE_CL_IP_ADDR       },
        { CVY_NAME_CL_NET_MASK,    CVY_TYPE_CL_NET_MASK      },
        { CVY_NAME_CLUSTER_MODE,   CVY_TYPE_CLUSTER_MODE     },
        { CVY_NAME_ALIVE_PERIOD,   CVY_TYPE_ALIVE_PERIOD     },
        { CVY_NAME_ALIVE_TOLER,    CVY_TYPE_ALIVE_TOLER      },
        { CVY_NAME_NUM_ACTIONS,    CVY_TYPE_NUM_ACTIONS      },
        { CVY_NAME_NUM_PACKETS,    CVY_TYPE_NUM_PACKETS      },
        { CVY_NAME_NUM_SEND_MSGS,  CVY_TYPE_NUM_SEND_MSGS    },
        { CVY_NAME_DOMAIN_NAME,    CVY_TYPE_DOMAIN_NAME      },
        { CVY_NAME_LICENSE_KEY,    CVY_TYPE_LICENSE_KEY      },
        { CVY_NAME_RMT_PASSWORD,   CVY_TYPE_RMT_PASSWORD     },
        { CVY_NAME_RCT_PASSWORD,   CVY_TYPE_RCT_PASSWORD     },
        { CVY_NAME_RCT_PORT,       CVY_TYPE_RCT_PORT         },
        { CVY_NAME_RCT_ENABLED,    CVY_TYPE_RCT_ENABLED      },
        { CVY_NAME_NUM_RULES,      CVY_TYPE_NUM_RULES        },
        { CVY_NAME_CUR_VERSION,    CVY_TYPE_CUR_VERSION      },
        { CVY_NAME_PORT_RULES,     CVY_TYPE_PORT_RULES       },
        { CVY_NAME_DSCR_PER_ALLOC, CVY_TYPE_DSCR_PER_ALLOC   },
        { CVY_NAME_MAX_DSCR_ALLOCS,CVY_TYPE_MAX_DSCR_ALLOCS  },
        { CVY_NAME_SCALE_CLIENT,   CVY_TYPE_SCALE_CLIENT     },
        { CVY_NAME_CLEANUP_DELAY,  CVY_TYPE_CLEANUP_DELAY    },
        { CVY_NAME_NBT_SUPPORT,    CVY_TYPE_NBT_SUPPORT      },
        { CVY_NAME_MCAST_SUPPORT,  CVY_TYPE_MCAST_SUPPORT    },
        { CVY_NAME_MCAST_SPOOF,    CVY_TYPE_MCAST_SPOOF      },
        { CVY_NAME_MASK_SRC_MAC,   CVY_TYPE_MASK_SRC_MAC     },
        { CVY_NAME_CONVERT_MAC,    CVY_TYPE_CONVERT_MAC      },
    };
    static const WCHAR c_szConvoyParams[] = L"Convoy\\Parameters";

    for (UINT i = 0 ; i < celems(aParams); ++i)
    {
        WriteServiceRegValueToAFile(pwisParams,
                                    c_szConvoyParams,
                                    aParams[i].szName,
                                    aParams[i].wType);
    }

    return SUCCEEDED(hr);

}


// ----------------------------------------------------------------------
//
// Function:  WriteNWCWorkstationParams
//
// Purpose:   Write parameters of Netware Client to the answerfile
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteNWCWorkstationParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteNWCWorkstationParams");

    TraceFunctionEntry(ttidNetUpgrade);

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcNWCWorkstation,
                                             c_szParameters,
                                             c_szAfNWCWorkstationParameters,
                                             pwisParams);

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcNWCWorkstation,
                                             c_szShares,
                                             c_szAfNWCWorkstationShares,
                                             pwisParams);
    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcNWCWorkstation,
                                             c_szDrives,
                                             c_szAfNWCWorkstationDrives,
                                             pwisParams);

    return TRUE;

    // we want to retain this code till jeffspr makes up his mind
    //
/*    PCORegKey prkParams;
    PCWInfSection pwisLogonInfo;
    tstring strId;

    GetServiceParamsKey(c_szSvcNWCWorkstation, prkParams);
    if (!prkParams)
        return FALSE;

    CORegKey rkLogon(*prkParams, L"Logon");
    CORegKey rkOption(*prkParams, L"Option");
    //CORegKeyIter rkiLogon(rkLogon);
    CORegKeyIter rkiOption(rkOption);

    while (!rkiOption.Next(&strId))
    {
        CORegKey rkId(rkLogon, strId.c_str());
        ContinueIf(!rkId.HKey());

        TByteArray abLogonID;
        rkId.QueryValue(L"LogonID", abLogonID);
        QWORD qwLogonID = ConvertToQWord(abLogonID);

        pwisParams->AddKey(L"LogonInfo", strId.c_str());
        pwisLogonInfo = pwifAnswerFile->AddSection(strId.c_str());
        ContinueIf(!pwisParams);

        CORegKey rkOptionLogonId(rkOption, strId.c_str());
        if (!rkOption.HKey())
        {
            continue;
        }

        // LogonId
        pwisLogonInfo->AddQwordKey(L"LogonID", qwLogonID);

        // LogonScript
        WriteRegValueToAFile(pwisLogonInfo, rkOptionLogonId, L"LogonScript",
                             REG_DWORD, NULL, TRUE, (DWORD) 0);

        // PreferredServer
        WriteRegValueToAFile(pwisLogonInfo, rkOptionLogonId, L"PreferredServer");

        // PrintOption
        WriteRegValueToAFile(pwisLogonInfo, rkOptionLogonId,
                             L"PrintOption", REG_DWORD);
    }

    return TRUE;
*/
}

// ----------------------------------------------------------------------
//
// Function:  WriteBrowserParams
//
// Purpose:   Write parameters of Browser to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteBrowserParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteBrowserParams");

    TraceFunctionEntry(ttidNetUpgrade);

    PCORegKey prkParams;
    //Browser stores its parameters under the LanmanWorkstation key!
    GetServiceParamsKey(c_szSvcWorkstation, prkParams);

    TStringList slDomains;

    prkParams->QueryValue(L"OtherDomains", slDomains);
    pwisParams->AddKey(c_szAfBrowseDomains, slDomains);

    DeleteIfNotNull(prkParams);

    // now write reg-dump keys
    tstring strFileName;
    tstring strServices = c_szRegKeyServices;
    strServices += L"\\";

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcBrowser,
                                             c_szParameters,
                                             c_szAfBrowserParameters,
                                             pwisParams);

    HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcNetLogon,
                                             c_szParameters,
                                             c_szAfNetLogonParameters,
                                             pwisParams);

    EraseAndDeleteAll(slDomains);

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteLanmanServerParams
//
// Purpose:   Write parameters of LanmanServer to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteLanmanServerParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteLanmanServerParams");

    TraceFunctionEntry(ttidNetUpgrade);

    PCORegKey prkParams;
    static const WCHAR c_szShares[] = L"Shares";
    static const WCHAR c_szAutotunedParameters[] = L"AutotunedParameters";
    static const WCHAR c_szMemoryManagement[] = L"System\\CurrentControlSet\\Control\\Session Manager\\Memory Management";
    static const WCHAR c_szLargeSystemCache[] = L"LargeSystemCache";

    GetServiceParamsKey(c_szSvcLmServer, prkParams);

    DWORD dwValue=3;
    HRESULT hr=S_OK;

    //Optimization
    prkParams->QueryValue(L"Size", dwValue);
    if ((dwValue >= 1) && (dwValue <= 3))
    {
        if (dwValue == 3)
        {
            HKEY hkey;
            // need to inspect one more key
            hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szMemoryManagement,
                                KEY_READ, &hkey);
            if (S_OK == hr)
            {
                DWORD dw;

                hr = HrRegQueryDword(hkey, c_szLargeSystemCache, &dw);
                if (S_OK == hr)
                {
                    if (dw == 0)
                    {
                        dwValue = 4;
                    }
                }
                RegCloseKey(hkey);
            }
        }
        pwisParams->AddKey(c_szAfLmServerOptimization, g_pszServerOptimization[dwValue]);
    }

    //BroadcastsToLanman2Clients
    dwValue=0;
    prkParams->QueryValue(L"Lmannounce", dwValue);
    pwisParams->AddBoolKey(c_szAfBroadcastToClients, dwValue);

    // now write reg-dump keys
    tstring strFileName;
    tstring strServices = c_szRegKeyServices;
    strServices += L"\\";

    // ignore the error codes so that we can dump whatever is available/present
    //
    hr = HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcLmServer,
                                                  c_szParameters,
                                                  c_szAfLmServerParameters,
                                                  pwisParams);

    hr = HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcLmServer,
                                                  c_szShares,
                                                  c_szAfLmServerShares,
                                                  pwisParams);

    hr = HrNetRegSaveServiceSubKeyAndAddToSection(c_szSvcLmServer,
                                                  c_szAutotunedParameters,
                                                  c_szAfLmServerAutotunedParameters,
                                                  pwisParams);

    DeleteIfNotNull(prkParams);

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  WriteLanmanWorkstationParams
//
// Purpose:   Write parameters of LanmanWorkstation to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteLanmanWorkstationParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteLanmanWorkstationParams");

    TraceFunctionEntry(ttidNetUpgrade);

    //    pwisParams->AddComment(c_szNoParamsRequired);

    return TRUE;
}


// ----------------------------------------------------------------------
//
// Function:  WriteRPCLocatorParams
//
// Purpose:   Write parameters of RPCLOCATOR to the specified section
//
// Arguments:
//    pwifAnswerFile [in]  pointer to answerfile
//    pwisParams     [in]  section where to write the parameters
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteRPCLocatorParams (
    IN PCWInfFile pwifAnswerFile,
    IN PCWInfSection pwisParams)
{
    DefineFunctionName("WriteRPCLocatorParams");

    TraceFunctionEntry(ttidNetUpgrade);

    //DefaultSecurityProvider
    WriteRegValueToAFile(pwisParams,
                         HKEY_LOCAL_MACHINE,
                         L"SOFTWARE\\Microsoft\\Rpc\\SecurityService",
                         L"DefaultProvider", REG_SZ,
                         c_szAfDefaultProvider);

    //NameServiceNetworkAddress
    WriteRegValueToAFile(pwisParams,
                         HKEY_LOCAL_MACHINE,
                         L"SOFTWARE\\Microsoft\\Rpc\\NameService",
                         L"NetworkAddress", REG_SZ,
                         c_szAfNameServiceAddr);

    //NameServiceProtocol
    WriteRegValueToAFile(pwisParams,
                         HKEY_LOCAL_MACHINE,
                         L"SOFTWARE\\Microsoft\\Rpc\\NameService",
                         L"Protocol", REG_SZ,
                         c_szAfNameServiceProtocol);

    return TRUE;
}


// ----------------------------------------------------------------------
//
// Function:  IsNetComponentBindable
//
// Purpose:   Determine if a component is bindable
//            (it has Bind value under the Linkage key)
//
// Arguments:
//    prkNetComponentLinkage [in]  Linkage key of the component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
IsNetComponentBindable (
    IN const PCORegKey prkNetComponentLinkage)
{
    BOOL status;
    TStringList slTemp;

    status = prkNetComponentLinkage->QueryValue(c_szRegValBind, slTemp) == ERROR_SUCCESS;

    EraseAndDeleteAll(slTemp);

    return status;
}

// ----------------------------------------------------------------------
//
// Function:  ConvertRouteToStringList
//
// Purpose:   Convert Linkage\Route value to a tstring list
//
// Arguments:
//    pszRoute [in]   route
//    slRoute  [out]  list of route elements
//
// Returns:   None
//
// Author:    kumarp 17-December-97
//
void
ConvertRouteToStringList (
    IN PCWSTR pszRoute,
    OUT TStringList &slRoute )
{
    EraseAndDeleteAll(slRoute);
    const WCHAR CHQUOTE = '"';
    tstring str;

    INT cQuote;

    for ( cQuote = 0 ; *pszRoute ; pszRoute++ )
    {
        if ( *pszRoute == CHQUOTE )
        {
            if ( cQuote++ & 1 )  // If it's a closing quote...
            {
                if ( str.size() )
                {
                    if (FIsDontExposeLowerComponent(str.c_str()))
                    {
                        break;
                    }

                    AddAtEndOfStringList(slRoute, str.c_str());

                    // If the route contains NetBT, then add in TCPIP
                    // because TCPIP is in the bind string in Windows 2000.
                    // e.g. a binding of NetBT->Adapter will become
                    // NetBT->TCPIP->Adapter.
                    //
                    if (0 == _wcsicmp (str.c_str(), L"NetBT"))
                    {
                        AddAtEndOfStringList(slRoute, L"TCPIP");
                    }
                }
            }
            str.erase();
        }
        else
        {
            str += *pszRoute;
        }
    }
}

// ----------------------------------------------------------------------
//
// Function:  IsMSNetClientComponent
//
// Purpose:   Determine if the specified component is a subcomponent
//            of MS_MSClient
//
// Arguments:
//    pszComponentName [in]  name of component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
IsMSNetClientComponent (
    IN PCWSTR pszComponentName)
{
    Assert (pszComponentName && *pszComponentName);

    return ((!_wcsicmp(pszComponentName, c_szSvcBrowser)) ||
            (!_wcsicmp(pszComponentName, c_szSvcWorkstation)) ||
            (!_wcsicmp(pszComponentName, L"RpcLocator")));
}

// ----------------------------------------------------------------------
//
// Function:  WriteBindings
//
// Purpose:   Write disabled bindings of a component to [NetBindings] section
//
// Arguments:
//    pszComponentName [in]  name of component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteBindings (
    IN PCWSTR pszComponentName)
{
    Assert (pszComponentName && *pszComponentName);

    DefineFunctionName("WriteBindings");

    BOOL            fStatus=TRUE;
    TStringList     slBindings, slRoute;
    tstring         strRoute, strBindings, strTemp;
    TStringListIter iter;

    // we want to write bindings only for LanmanWorkstation among the
    // MSClient components
    //
    if (IsMSNetClientComponent(pszComponentName) &&
        (lstrcmpiW(pszComponentName, c_szSvcWorkstation)))
    {
        return TRUE;
    }

    TraceTag(ttidNetUpgrade, "%s: writing bindings of '%S'...",
             __FUNCNAME__, pszComponentName);

    PCORegKey prkNetComponentLinkage=NULL,
        prkNetComponentLinkageDisabled=NULL;
    GetServiceSubkey(pszComponentName, c_szLinkage, prkNetComponentLinkage);

    if (!prkNetComponentLinkage || !IsNetComponentBindable(prkNetComponentLinkage))
        goto error_cleanup;

    GetServiceSubkey(pszComponentName,
                     c_szLinkageDisabled,
                     prkNetComponentLinkageDisabled);
    if (!prkNetComponentLinkageDisabled)
        goto error_cleanup;

    //We write only those bindings that are disabled, others by default are enabled
    //    prkNetComponentLinkage->QueryValue(c_szRegValRoute, slBindings);
    prkNetComponentLinkageDisabled->QueryValue(c_szRegValRoute, slBindings);

    for (iter = slBindings.begin(); iter != slBindings.end(); iter++)
    {
        strRoute = **iter;

        MapNetComponentNameForBinding(pszComponentName, strBindings);
        if (!lstrcmpiW(strBindings.c_str(), c_szInfId_MS_NetBT))
        {
            strBindings += L",";
            strBindings += c_szInfId_MS_TCPIP;
        }
        ConvertRouteToStringList(strRoute.c_str(), slRoute);
        TStringListIter iterComponentsInRoute;

        for (iterComponentsInRoute = slRoute.begin();
             iterComponentsInRoute != slRoute.end();
             iterComponentsInRoute++)
        {
            strTemp = **iterComponentsInRoute;

            if (IsNetCardProductName(strTemp.c_str()))
                continue;
            MapNetComponentNameForBinding(strTemp.c_str(), strTemp);

            // pre-NT5 code stores bindings such that MS_NetBT appears to
            // bind directly to a netcard. in NT5 MS_NetBT binds to MS_TCPIP
            // which then binds to a netcard.
            // thus for any binding path having MS_NetBT in it, we need to
            // convert this to MS_NetBT,MS_TCPIP
            //

            // NTRAID9:210426@20001130#deonb. 
            // This is redundant. ConvertRouteToStringList already add MS_TCPIP after encountering NETBT,
            // Adding it again will result in a bindpath of MS_NetBT,ms_tcpip,MS_TCPIP which will not be matched
            // by GUI setup. Removing this check.
            // if (!lstrcmpiW(strTemp.c_str(), c_szInfId_MS_NetBT))
            // {
            //      strTemp += L",";
            //      strTemp += c_szInfId_MS_TCPIP;
            // }

            // 306866: pre-NT5 code stores ISO/TP4 bindings in the form
            // isotp4->streams->adapter.  In NT5, each of these binds
            // directly to the adapter.  So if we find an isotp Route for
            // which the first component is Streams, we skip it.
            //
            if (!lstrcmpiW(strBindings.c_str(), c_szInfId_MS_Isotpsys) &&
                !lstrcmpiW(strTemp.c_str(), c_szInfId_MS_Streams))
            {
                continue;
            }

            strBindings += L"," + strTemp;

            // 243906: if the component is DONT_EXPOSE_LOWER, terminate the bindpath

            if (!lstrcmpiW(strTemp.c_str(), c_szInfId_MS_NWIPX) ||
                !lstrcmpiW(strTemp.c_str(), c_szInfId_MS_NWNB) ||
                !lstrcmpiW(strTemp.c_str(), c_szInfId_MS_NWSPX))
            {
                break;
            }
        }
        EraseAndDeleteAll(slRoute);

        // WLBS: don't write Disable bindings that contain MS_TCPIP and WLBS
        // cluster adapter.

        if (pszWlbsClusterAdapterName[0] != 0 &&
            (strBindings.find(c_szInfId_MS_TCPIP) != tstring::npos ||
             strBindings.find(c_szMSTCPIP) != tstring::npos) &&
            strBindings.find(pszWlbsClusterAdapterName) != tstring::npos)
        {
            TraceTag(ttidNetUpgrade, "%s: skipping Disable=%S",
                     __FUNCNAME__, strBindings.c_str());

            continue;
        }

        // end WLBS:

        g_pwisBindings->AddKey(c_szAfDisable, strBindings.c_str());
        TraceTag(ttidNetUpgrade, "%s: Disable=%S",
                 __FUNCNAME__, strBindings.c_str());
    }

    // WLBS: if WLBS is bound to a NIC, then write explicit Enable binding to it.
    // by default, WLBS notifier object will disable all bindings on install.

    if ((_wcsicmp(pszComponentName, c_szWLBS) == 0 ||
         _wcsicmp(pszComponentName, c_szConvoy) == 0)
        && pszWlbsClusterAdapterName[0] != 0)
    {
        strBindings  = c_szMSWLBS;
        strBindings += L",";
        strBindings += pszWlbsClusterAdapterName;
        g_pwisBindings->AddKey(c_szAfEnable, strBindings.c_str());

        TraceTag(ttidNetUpgrade, "%s: Enable=%S",
                 __FUNCNAME__, strBindings.c_str());
    }

    // end WLBS:

    fStatus=TRUE;
    goto cleanup;

  error_cleanup:
    fStatus = FALSE;

  cleanup:
    DeleteIfNotNull(prkNetComponentLinkage);
    DeleteIfNotNull(prkNetComponentLinkageDisabled);

    EraseAndDeleteAll(slBindings);

    return fStatus;
}


// ----------------------------------------------------------------------
// Misc. Helper Functions
// ----------------------------------------------------------------------

// ----------------------------------------------------------------------
//
// Function:  WriteServiceRegValueToAFile
//
// Purpose:   Write specified value in registry to the specified section
//            in the answerfile, renaming if required
//
// Arguments:
//    pwisSection      [in]  section to which the value is written
//    pszServiceKey    [in]  name of service
//    pszValueName     [in]  name of value under Parameters subkey
//    wValueType       [in]  type of value
//    pszValueNewName  [in]  change name to this
//    fDefaultProvided [in]  is a default value provided ?
//    ...              [in]  use this default value if the specified value is
//                           not found in the registry
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteServiceRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN PCWSTR pszServiceKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    ...)
{
    AssertValidReadPtr(pwisSection);
    AssertValidReadPtr(pszValueName);

    tstring strKeyFullPath;
    strKeyFullPath = tstring(L"System\\CurrentControlSet\\Services\\")
        + pszServiceKey;

    va_list arglist;

    va_start (arglist, fDefaultProvided);
    BOOL fStatus =
        WriteRegValueToAFile(pwisSection, HKEY_LOCAL_MACHINE,
                             strKeyFullPath.c_str(), pszValueName, wValueType,
                             pszValueNewName, fDefaultProvided, arglist);
    va_end(arglist);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  WriteServiceRegValueToAFile
//
// Purpose:   Write specified value in registry to the specified section
//            in the answerfile, renaming if required
//
// Arguments:
//    pwisSection      [in]  section to which the value is written
//    hkey             [in]  handle to a regkey
//    pszSubKey        [in]  name of subkey
//    pszValueName     [in]  name of value
//    wValueType       [in]  type of value
//    pszValueNewName  [in]  change name to this
//    fDefaultProvided [in]  is a default value provided ?
//    ...              [in]  use this default value if the specified value is
//                           not found in the registry
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN HKEY hKey,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    ...)
{
    BOOL fStatus;
    va_list arglist;

    va_start (arglist, fDefaultProvided);
    fStatus = WriteRegValueToAFile(pwisSection, hKey, pszSubKey,
                                   pszValueName, wValueType,
                                   pszValueNewName, fDefaultProvided, arglist);
    va_end(arglist);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  WriteServiceRegValueToAFile
//
// Purpose:   Write specified value in registry to the specified section
//            in the answerfile, renaming if required
//
// Arguments:
//    pwisSection      [in]  section to which the value is written
//    hkey             [in]  handle to a regkey
//    pszSubKey        [in]  name of subkey
//    pszValueName     [in]  name of value
//    wValueType       [in]  type of value
//    pszValueNewName  [in]  change name to this
//    fDefaultProvided [in]  is a default value provided ?
//    arglist          [in]  use this default value if the specified value is
//                           not found in the registry
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN HKEY hKey,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    va_list arglist)
{
    CORegKey rk(hKey, pszSubKey);
    BOOL fKeyNotFound = (((HKEY) rk) == NULL);

    if (fKeyNotFound && !fDefaultProvided)
    {
        return FALSE;
    }
    else
    {
        //even if key is not found, we need to write the default value

        return WriteRegValueToAFile(pwisSection, rk, pszValueName, wValueType,
                                    pszValueNewName, fDefaultProvided, arglist);
    }
}

// ----------------------------------------------------------------------
//
// Function:  WriteServiceRegValueToAFile
//
// Purpose:   Write specified value in registry to the specified section
//            in the answerfile, renaming if required
//
// Arguments:
//    pwisSection      [in]  section to which the value is written
//    rk               [in]  regkey
//    pszValueName     [in]  name of value
//    wValueType       [in]  type of value
//    pszValueNewName  [in]  change name to this
//    fDefaultProvided [in]  is a default value provided ?
//    ...              [in]  use this default value if the specified value is
//                           not found in the registry
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN CORegKey& rk,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    ...)
{
    BOOL fStatus;
    va_list arglist;

    va_start (arglist, fDefaultProvided);
    fStatus = WriteRegValueToAFile(pwisSection, rk,
                                   pszValueName, wValueType,
                                   pszValueNewName, fDefaultProvided, arglist);
    va_end(arglist);

    return fStatus;
}

// ----------------------------------------------------------------------
//
// Function:  WriteServiceRegValueToAFile
//
// Purpose:   Write specified value in registry to the specified section
//            in the answerfile, renaming if required
//
// Arguments:
//    pwisSection      [in]  section to which the value is written
//    rk               [in]  regkey
//    pszValueName     [in]  name of value
//    wValueType       [in]  type of value
//    pszValueNewName  [in]  change name to this
//    fDefaultProvided [in]  is a default value provided ?
//    arglist          [in]  use this default value if the specified value is
//                           not found in the registry
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
WriteRegValueToAFile(
    IN PCWInfSection pwisSection,
    IN CORegKey& rk,
    IN PCWSTR pszValueName,
    IN WORD wValueType,
    IN PCWSTR pszValueNewName,
    IN BOOL fDefaultProvided,
    IN va_list arglist)
{
    if (!pwisSection)
    {
        return FALSE;
    }

    BOOL fValue, fDefault=FALSE;
    DWORD dwValue, dwDefault=0;
    PCWSTR pszValue, pszDefault=NULL;
    TStringList slValue;
    tstring strValue;

    if (pszValueNewName == NULL)
    {
        pszValueNewName = pszValueName;
    }

    if (fDefaultProvided)
    {
        switch (wValueType)
        {
        default:
            AssertSz(FALSE, "WriteRegValueToAFile: Invalid wValueType");
            break;

        case REG_SZ:
            pszDefault = va_arg(arglist, PCWSTR);
            break;

        case REG_HEX:
        case REG_DWORD:
            dwDefault =  va_arg(arglist, DWORD);
            break;

        case REG_BOOL:
            fDefault = va_arg(arglist, BOOL);
            break;

        }
    }

    LONG err;
    BOOL fStatus=FALSE;

    switch(wValueType)
    {
        default:
            AssertSz(FALSE, "WriteRegValueToAFile: Invalid wValueType");
            break;

        case REG_SZ:
            err = rk.QueryValue(pszValueName, strValue);
            if (err)
            {
                if (fDefaultProvided)
                {
                    pszValue = pszDefault;
                }
                else
                {
                    return FALSE;
                }
            }
            else
            {
                pszValue = strValue.c_str();
            }
            pwisSection->AddKey(pszValueNewName, pszValue);
            fStatus = TRUE;
            break;

        case REG_HEX:
        case REG_DWORD:
            err = rk.QueryValue(pszValueName, dwValue);
            if (err)
            {
                if (fDefaultProvided)
                {
                    dwValue = dwDefault;
                }
                else
                {
                    return FALSE;
                }
            }
            if (wValueType == REG_HEX)
            {
                pwisSection->AddHexKey(pszValueNewName, dwValue);
            }
            else
            {
                pwisSection->AddKey(pszValueNewName, dwValue);
            }
            fStatus = TRUE;
            break;

        case REG_BOOL:
            err = rk.QueryValue(pszValueName, dwValue);
            if (err)
            {
                if (fDefaultProvided)
                {
                    dwValue = fDefault;
                }
                else
                {
                    return FALSE;
                }
            }
            fValue = dwValue != 0;
            pwisSection->AddBoolKey(pszValueNewName, fValue);
            fStatus = TRUE;
            break;

        case REG_MULTI_SZ:
            err = rk.QueryValue(pszValueName, slValue);
            if (err)
            {
                // cant specify default for REG_MULTI_SZ, just return FALSE
                return FALSE;
            }
            pwisSection->AddKey(pszValueNewName, slValue);
            EraseAndDeleteAll(slValue);
            fStatus = TRUE;
            break;

        case REG_BINARY:
        {
            TByteArray ab;

            err = rk.QueryValue(pszValueName, ab);
            if (err)
            {
                // cant specify default for REG_BINARY, just return FALSE
                return FALSE;
            }

            ConvertToByteList(ab, strValue);

            pszValue = strValue.c_str();
            pwisSection->AddKey(pszValueNewName, pszValue);

            break;
        }
    }

    return fStatus;
}


// ----------------------------------------------------------------------
//
// Function:  GetBusTypeName
//
// Purpose:   Get name string for the specify bus-type
//
// Arguments:
//    eBusType [in]  bus type
//
// Returns:   name string for the bus-type
//
// Author:    kumarp 17-December-97
//
PCWSTR
GetBusTypeName (
    IN INTERFACE_TYPE eBusType)
{
    switch (eBusType)
    {
    case Internal:
        return c_szAfBusInternal;

    case Isa:
        return c_szAfBusIsa;

    case Eisa:
        return c_szAfBusEisa;

    case MicroChannel:
        return c_szAfBusMicrochannel;

    case TurboChannel:
        return c_szAfBusTurbochannel;

    case PCIBus:
        return c_szAfBusPci;

    case VMEBus:
        return c_szAfBusVme;

    case NuBus:
        return c_szAfBusNu;

    case PCMCIABus:
        return c_szAfBusPcmcia;

    case CBus:
        return c_szAfBusC;

    case MPIBus:
        return c_szAfBusMpi;

    case MPSABus:
        return c_szAfBusMpsa;

    case ProcessorInternal:
        return c_szAfBusProcessorinternal;

    case InternalPowerBus:
        return c_szAfBusInternalpower;

    case PNPISABus:
        return c_szAfBusPnpisa;

    default:
        return c_szAfUnknown;
    }
};


// ----------------------------------------------------------------------
//
// Function:  AddToNetCardDB
//
// Purpose:   Add the given adapter token to a list. This list is later
//            used to map token <--> drivername
//
// Arguments:
//    pszAdapterName   [in]  adapter token (e.g. Adapter01)
//    pszProductName   [in]  adapter ID (e.g. IEEPRO)
//    pszAdapterDriver [in]  instance ID (e.g. IEEPRO3)
//
// Returns:   None
//
// Author:    kumarp 17-December-97
//
void
AddToNetCardDB (
    IN PCWSTR pszAdapterName,
    IN PCWSTR pszProductName,
    IN PCWSTR pszAdapterDriver)
{
    Assert(pszAdapterName   && *pszAdapterName);
    Assert(pszProductName   && *pszProductName);
    Assert(pszAdapterDriver && *pszAdapterDriver);

    AddAtEndOfStringList(*g_pslNetCardAFileName, pszAdapterName);
    AddAtEndOfStringList(*g_pslNetCard, pszProductName);
    AddAtEndOfStringList(*g_pslNetCardInstance, pszAdapterDriver);
}

// ----------------------------------------------------------------------
//
// Function:  IsNetCardProductName
//
// Purpose:   Determine if the specified name represents an adapter
//
// Arguments:
//    pszName [in]  name of a component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
IsNetCardProductName (
    IN PCWSTR pszName)
{
    AssertValidReadPtr(pszName);

    return FIsInStringList(*g_pslNetCard, pszName);
}


// ----------------------------------------------------------------------
//
// Function:  IsNetCardInstance
//
// Purpose:   Determine if the specified instance represents an adapter
//
// Arguments:
//    pszName [in]  instance name of a component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
IsNetCardInstance(
    IN PCWSTR pszName)
{
    AssertValidReadPtr(pszName);

    return FIsInStringList(*g_pslNetCardInstance, pszName);
}

// ----------------------------------------------------------------------
//
// Function:  MapNetCardInstanceToAFileName
//
// Purpose:   Map netcard instance name to its answerfile token
//
// Arguments:
//    pszNetCardInstance  [in]  net card instance
//    strNetCardAFileName [out] answerfile token for that net card
//
// Returns:   None
//
// Author:    kumarp 17-December-97
//
VOID
MapNetCardInstanceToAFileName (
    IN PCWSTR pszNetCardInstance,
    OUT tstring& strNetCardAFileName)
{
    strNetCardAFileName = MapNetCardInstanceToAFileName(pszNetCardInstance);
}

// ----------------------------------------------------------------------
//
// Function:  MapNetCardInstanceToAFileName
//
// Purpose:   Map netcard instance name to its answerfile token
//
// Arguments:
//    pszNetCardInstance [in]  net card instance
//
// Returns:   answerfile token for that net card
//
// Author:    kumarp 17-December-97
//
PCWSTR
MapNetCardInstanceToAFileName (
    IN PCWSTR pszNetCardInstance)
{
    DefineFunctionName("MapNetCardInstanceToAFileName");

    Assert(pszNetCardInstance && *pszNetCardInstance);

    tstring strTemp;
    TStringListIter iter = g_pslNetCardInstance->begin();
    TStringListIter pos2;
    DWORD index=0;
    PCWSTR pszNetCardAFileName=NULL;

    while (iter != g_pslNetCardInstance->end())
    {
        strTemp = **iter++;
        if (0 == _wcsicmp(strTemp.c_str(), pszNetCardInstance))
        {
            pszNetCardAFileName = GetNthItem(*g_pslNetCardAFileName, index)->c_str();
            break;
        }
        index++;
    }

    if (!pszNetCardAFileName)
    {
        TraceTag(ttidError, "%s: Couldnt locate %S in g_pslNetCardAFileName",
                 __FUNCNAME__, pszNetCardInstance);
    }

    return pszNetCardAFileName;
}

// ----------------------------------------------------------------------
//
// Function:  GetServiceKey
//
// Purpose:   Get regkey object for the specified service
//
// Arguments:
//    pszServiceName [in]  name of service
//    prkService     [out] pointer to CORegKey object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
GetServiceKey (
    IN PCWSTR pszServiceName,
    OUT PCORegKey &prkService)
{
    DefineFunctionName("GetServiceKey");

    tstring strServiceFullName = tstring(c_szRegKeyServices) + L"\\" +
        pszServiceName;
    prkService = new CORegKey(HKEY_LOCAL_MACHINE, strServiceFullName.c_str());

    if(!prkService) 
    {
        return false;
    }

    if (!prkService->HKey())
    {
        delete prkService;
        prkService = NULL;
        TraceHr (ttidError, FAL,
                HRESULT_FROM_WIN32(ERROR_SERVICE_DOES_NOT_EXIST), FALSE,
                 "GetServiceKey for service %S", pszServiceName);
        return FALSE;
    }

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  GetServiceParamsKey
//
// Purpose:   Get regkey object for the Parameters subkey of the specified service
//
// Arguments:
//    pszServiceName   [in]  name of a service
//    prkServiceParams [out] pointer to CORegKey object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
GetServiceParamsKey (
    IN PCWSTR pszServiceName,
    OUT PCORegKey &prkServiceParams)
{
    return GetServiceSubkey(pszServiceName, c_szParameters, prkServiceParams);
}

// ----------------------------------------------------------------------
//
// Function:  GetServiceSubkey
//
// Purpose:   Get subkey of a service
//
// Arguments:
//    pszServiceName   [in]  name of service
//    pszSubKeyName    [in]  name of subkey
//    prkServiceSubkey [out] pointer to CORegKey object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
GetServiceSubkey (
    IN PCWSTR pszServiceName,
    IN PCWSTR pszSubKeyName,
    OUT PCORegKey &prkServiceSubkey)
{
    DefineFunctionName("GetServiceSubkey(PCWSTR pszServiceName, )");

    tstring strServiceSubkeyFullName = tstring(c_szRegKeyServices) + L"\\" +
    pszServiceName + L"\\" + pszSubKeyName;

    prkServiceSubkey = new CORegKey(HKEY_LOCAL_MACHINE, strServiceSubkeyFullName.c_str());

    if(!prkServiceSubkey)
    {
        return false;
    }

    if (!prkServiceSubkey->HKey())
    {
        delete prkServiceSubkey;
        prkServiceSubkey = NULL;
        TraceTag(ttidError, "%s: error opening service sub key for %S -- %S",
                 __FUNCNAME__, pszServiceName, pszServiceName);
        return FALSE;
    }

    return TRUE;
}

// ----------------------------------------------------------------------
//
// Function:  GetServiceSubkey
//
// Purpose:   Get subkey of a service
//
// Arguments:
//    prkService       [in]  service regkey
//    pszSubKeyName    [in]  name of subkey
//    prkServiceSubkey [out] pointer to CORegKey object
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
GetServiceSubkey (
    IN const PCORegKey prkService,
    IN PCWSTR pszSubKeyName,
    OUT PCORegKey &prkServiceSubkey)
{
    DefineFunctionName("GetServiceSubkey(PCORegKey prkService, )");

    prkServiceSubkey = new CORegKey(*prkService, pszSubKeyName);

    if(!prkServiceSubkey)
    {
        return false;
    }

    if (!prkServiceSubkey->HKey())
    {
        delete prkServiceSubkey;
        prkServiceSubkey = NULL;
        TraceWin32FunctionError(ERROR_SERVICE_DOES_NOT_EXIST);
        return FALSE;
    }

    return TRUE;
}

#pragma BEGIN_CONST_SECTION
static const PCWSTR c_aszComponentsToIgnore[] =
{
    // These are installed automatically when TCPIP is installed
    // and has no user settable parameters of its own
    //
    L"NetBT",
    L"TcpipCU",
    L"Wins",

    // This is installed automatically when RAS is installed
    // and has no user settable parameters of its own
    //
    L"NdisWan",

    // Parameters of RAS are under Software\Microsoft\RAS
    // and not under the service key as with other net components
    //
    L"RASPPTPE",
    L"RASPPTPM",
    L"RasAuto",
    L"RemoteAccess",
    L"Router",

    // These are installed automatically when MS_IPX is installed
    // and has no user settable parameters of its own
    //
    L"NwlnkNb",
    L"NwlnkSpx",

    // This is installed automatically when MS_MSClient is installed
    // and has no user settable parameters of its own
    //
    L"RpcBanyan",

    // we dont install this using answer-file
    //
    L"Inetsrv",
    L"DFS",

    // this will be cleaned up by the IIS setup guys.
    // contact "Linan Tong" if you have any questions:
    //
    L"FTPD",

    // these are installed when SFM is installed
    //
    L"MacPrint",
    L"MacFile",

    // pre-sp3 SteelHead components
    //
    L"NwSapAgent",
    L"IPRIP",
    L"NWLNKRIP",
    L"RelayAgent",
};
#pragma END_CONST_SECTION


// ----------------------------------------------------------------------
//
// Function:  ShouldIgnoreComponent
//
// Purpose:   Determine if a components should be ignored when
//            writing parameters to answerfile
//
// Arguments:
//    pszComponentName [in]  name of component
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
ShouldIgnoreComponent (
    IN PCWSTR pszComponentName)
{
    BOOL fRet=TRUE;

    DefineFunctionName("ShouldIgnoreComponent");
    TraceFunctionEntry(ttidNetUpgrade);

    TraceTag(ttidNetUpgrade, "%s: Checking if %S should be ignored.",
             __FUNCNAME__, pszComponentName);

    fRet = !FIsInStringArray(c_aszComponentsToIgnore,
                             celems(c_aszComponentsToIgnore),
                             pszComponentName) &&
        (!FIsOptionalComponent(pszComponentName) ||
         // even though DHCPServer is an optional component,
         // we need to treat it differently and thus must write its
         // parameters
         !lstrcmpiW(pszComponentName, c_szSvcDhcpServer));

    // If none of the above net components then, check if it is DLC.

    if ( fRet == TRUE )
    {
        if ( lstrcmpiW(pszComponentName, sz_DLC) == 0 )
        {
           return ShouldRemoveDLC( NULL, NULL );
        }
    }

    return !fRet;
}

// ----------------------------------------------------------------------
//
// Function:  StringListsIntersect
//
// Purpose:   Determine if at least one item of sl1 matches with
//            at least one item of sl2
//
// Arguments:
//    sl1 [in]  list 1
//    sl2 [in]  list 2
//
// Returns:   TRUE on success, FALSE otherwise
//
// Author:    kumarp 17-December-97
//
BOOL
StringListsIntersect (
    IN const TStringList& sl1,
    IN const TStringList& sl2)
{
    if ((sl1.size() == 0) || (sl2.size() == 0))
        return FALSE;

    tstring s1, s2;
    TStringListIter pos1, pos2;

    pos1 = sl1.begin();
    while (pos1 != sl1.end())
    {
        s1 = **pos1++;
        pos2 = sl2.begin();
        while (pos2 != sl2.end())
        {
            s2 = **pos2++;
            if (s1 == s2)
            {
                return TRUE;
            }
        }
    }

    return FALSE;
}

// ----------------------------------------------------------------------
//
// Function:  ConvertToQWord
//
// Purpose:   Convert a size 8 byte array to a qword
//
// Arguments:
//    ab [in]  byte array
//
// Returns:
//
// Author:    kumarp 17-December-97
//
QWORD
ConvertToQWord (
    IN TByteArray ab)
{
    Assert(ab.size() == 8);

    QWORD qwRet = 0;
    WORD wShiftBy=0;
    for (int i=0; i<8; i++)
    {
        qwRet |= ((QWORD) ab[i]) << wShiftBy;
        wShiftBy += 8;
    }

    return qwRet;
}


// ----------------------------------------------------------------------
//
// Function:  ConvertToByteList
//
// Purpose:   Convert TByteArray to comma-separated byte list
//
// Arguments:
//    ab [in]  byte array
//
// Returns:
//
// Author:    kyrilf 2-April-99
//
VOID
ConvertToByteList (
    IN TByteArray ab,
    OUT tstring& str)
{
    WCHAR    byte [3];
    DWORD    size = ab.size();

    for (DWORD i=0; i < size; i++)
    {
        swprintf(byte, L"%0.2X", ab[i]);

        str += byte;

        if (i == size - 1)
            break;
        else
            str += ',';
    }
}

// ----------------------------------------------------------------------
//
// Function:  ReplaceCharsInString
//
// Purpose:   Replace all occurrances of chFindChar in the specified string
//            by chReplaceWith charater
//
// Arguments:
//    pszString      [in]  string
//    pszFindChars   [in]  set of chars to find
//    chReplaceWith [in]  char to replace with
//
// Returns:   None
//
// Author:    kumarp 17-December-97
//
void
ReplaceCharsInString (
    IN OUT PWSTR pszString,
    IN PCWSTR pszFindChars,
    IN WCHAR chReplaceWith)
{
    UINT uLen = wcslen(pszString);
    UINT uPos;

    while ((uPos = wcscspn(pszString, pszFindChars)) < uLen)
    {
        pszString[uPos] = chReplaceWith;
        pszString += uPos + 1;
        uLen -= uPos + 1;
    }
}

// ----------------------------------------------------------------------
//
// Function:  HrNetRegSaveKey
//
// Purpose:   Save the entire specified registry tree to a file
//
// Arguments:
//    hkeyBase     [in]  handle of base key
//    pszSubKey     [in]  name of subkey
//    pszComponent  [in]  file name prefix to use
//    pstrFileName [out] name of file written
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 17-December-97
//
HRESULT
HrNetRegSaveKey (
    IN HKEY hkeyBase,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszComponent,
    OUT tstring* pstrFileName)
{
    DefineFunctionName("HrNetRegSaveKey");

    Assert(hkeyBase);
    AssertValidReadPtr(pszComponent);
    AssertValidWritePtr(pstrFileName);

    HRESULT hr;
    HKEY hkey;

    hr = HrRegOpenKeyEx(hkeyBase, pszSubKey, KEY_READ, &hkey);

    if (S_OK == hr)
    {
        tstring strFileName;
        strFileName = pszComponent;
        if (pszSubKey)
        {
            AssertValidReadPtr(pszSubKey);

            strFileName += L"-";
            strFileName += pszSubKey;
            ReplaceCharsInString((PWSTR) strFileName.c_str(), L"\\/", '-');
        }
        strFileName += L".reg";

        tstring strFullPath;

        hr = HrGetNetUpgradeTempDir(&strFullPath);
        if (S_OK == hr)
        {
            strFullPath += strFileName;

            TraceTag(ttidNetUpgrade, "%s: dumping key %S to file %S",
                     __FUNCNAME__, pszSubKey ? pszSubKey : L"", strFullPath.c_str());

            DeleteFile(strFullPath.c_str());

            extern LONG EnableAllPrivileges ( VOID );
            EnableAllPrivileges();

            DWORD err = ::RegSaveKey(hkey, strFullPath.c_str(), NULL);
            if (err == ERROR_SUCCESS)
            {
                *pstrFileName = strFullPath;
                hr = S_OK;
            }
            else
            {
                hr = HrFromLastWin32Error();
            }
        }

        RegCloseKey(hkey);
    }

    TraceErrorOptional(__FUNCNAME__, hr,
                       (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)));

    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrNetRegSaveKeyAndAddToSection
//
// Purpose:   Save the entire specified registry tree to a file and
//            add a key in the specified section to indicate where
//            this file is located
//
// Arguments:
//    hkeyBase     [in]  handle of base key
//    pszSubKey     [in]  name of subkey
//    pszComponent  [in]  file name prefix to use
//    pszKeyName    [in]  name of key to write
//    pwisSection  [in]  section to write to
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 17-December-97
//
HRESULT
HrNetRegSaveKeyAndAddToSection (
    IN HKEY hkeyBase,
    IN PCWSTR pszSubKey,
    IN PCWSTR pszComponent,
    IN PCWSTR pszKeyName,
    IN CWInfSection* pwisSection)
{
    DefineFunctionName("HrNetRegSaveKeyAndAddToSection");

    Assert(hkeyBase);
    AssertValidReadPtr(pszComponent);
    AssertValidReadPtr(pszKeyName);
    AssertValidReadPtr(pwisSection);

    HRESULT hr;
    tstring strFileName;

    hr = HrNetRegSaveKey(hkeyBase, pszSubKey, pszComponent, &strFileName);
    if (SUCCEEDED(hr))
    {
        pwisSection->AddKey(pszKeyName, strFileName.c_str());
    }

    if (S_OK != hr)
    {
        TraceTag(ttidNetUpgrade, "%s: failed for %S in [%S] -- %S: hr: 0x%08X",
                 __FUNCNAME__, pszKeyName, pwisSection->Name(), pszSubKey, hr);
    }

    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrNetRegSaveKeyAndAddToSection
//
// Purpose:   Save the entire specified registry tree to a file and
//            add a key in the specified section to indicate where
//            this file is located
//
// Arguments:
//    pszServiceName [in]  name of service
//    pszSubKey      [in]  name of subkey
//    pszKeyName     [in]  name of key to write
//    pwisSection   [in]  section to write to
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 17-December-97
//
HRESULT
HrNetRegSaveServiceSubKeyAndAddToSection (
    IN PCWSTR pszServiceName,
    IN PCWSTR pszServiceSubKeyName,
    IN PCWSTR pszKeyName,
    IN CWInfSection* pwisSection)
{
    AssertValidReadPtr(pszServiceName);
    AssertValidReadPtr(pszKeyName);
    AssertValidWritePtr(pwisSection);

    HRESULT hr;
    tstring strServiceSubKey = c_szRegKeyServices;

    strServiceSubKey += L"\\";
    strServiceSubKey += pszServiceName;
    if (pszServiceSubKeyName)
    {
        strServiceSubKey += L"\\";
        strServiceSubKey += pszServiceSubKeyName;
    }

    // we ignore the return code
    hr = HrNetRegSaveKeyAndAddToSection(HKEY_LOCAL_MACHINE,
                                        strServiceSubKey.c_str(),
                                        pszServiceName,
                                        pszKeyName, pwisSection);

    return hr;
}

// ----------------------------------------------------------------------
//
// Function:  HrProcessOemComponentAndUpdateAfSection
//
// Purpose:   Process the specified OEM component in the following steps:
//            - Load an OEM DLL
//            - call PreUpgradeInitialize once
//            - call DoPreUpgradeProcessing
//            - if the above steps are successful,
//              add the right sections in the answerfile
//
// Arguments:
//    pnmi             [in]  pointer to CNetMapInfo object
//    hParentWindow    [in]  handle of parent window
//    hkeyParams       [in]  handle of Parameters registry key
//    pszPreNT5InfId    [in]  pre-NT5 InfID of a component (e.g. IEEPRO)
//    pszPreNT5Instance [in]  pre-NT5 instance of a component (e.g. IEEPRO2)
//    pszNT5InfId       [in]  NT5 InfID of the component
//    pszDescription    [in]  description of the component
//    pwisParams       [in]  pointer to params section of this component
//
// Returns:   S_OK on success, otherwise an error code
//
// Author:    kumarp 13-May-98
//
HRESULT HrProcessOemComponentAndUpdateAfSection(
    IN  CNetMapInfo* pnmi,
    IN  HWND      hParentWindow,
    IN  HKEY      hkeyParams,
    IN  PCWSTR   pszPreNT5InfId,
    IN  PCWSTR   pszPreNT5Instance,
    IN  PCWSTR   pszNT5InfId,
    IN  PCWSTR   pszDescription,
    IN  CWInfSection* pwisParams)
{
    AssertValidReadPtr(pnmi);
    //Assert(hParentWindow);
    Assert(hkeyParams);
    AssertValidReadPtr(pszPreNT5InfId);
    AssertValidReadPtr(pszPreNT5Instance);
    AssertValidReadPtr(pszNT5InfId);
    AssertValidReadPtr(pszDescription);
    AssertValidReadPtr(pwisParams);

    DefineFunctionName("HrProcessOemComponentAndUpdateAfSection");

    HRESULT hr;
    tstring strOemSectionName;
    DWORD dwFlags = 0;
    PCWSTR pszOemSection;

    TraceTag(ttidNetUpgrade, "%s: Component %S (%S) is an OEM component",
             __FUNCNAME__, pszDescription, pszPreNT5Instance);

    strOemSectionName = pwisParams->Name();
    strOemSectionName += L".";
    strOemSectionName += c_szAfOemSection;
    pszOemSection = strOemSectionName.c_str();

    hr = HrProcessOemComponent(pnmi, &g_NetUpgradeInfo,
                               hParentWindow,
                               hkeyParams,
                               pszPreNT5InfId,
                               pszPreNT5Instance,
                               pszNT5InfId,
                               pszDescription,
                               pszOemSection,
                               &dwFlags);

    if (S_OK == hr)
    {
        tstring strOemInf;

        pwisParams->AddKey(c_szAfOemSection, pszOemSection);

        AssertSz(!pnmi->m_strOemDir.empty(), "Did not get OemDir!!");

        pwisParams->AddKey(c_szAfOemDir, pnmi->m_strOemDir.c_str());

        hr = pnmi->HrGetOemInfName(pszNT5InfId, &strOemInf);
        if (S_OK == hr)
        {
            pwisParams->AddKey(c_szAfOemInf, strOemInf.c_str());
        }

        if (dwFlags & NUA_LOAD_POST_UPGRADE)
        {
            pwisParams->AddKey(c_szAfOemDllToLoad,
                               pnmi->m_strOemDllName.c_str());
        }

        // currently the SkipInstall feature is used only by
        // SNA and MS_NetBios for their peculiar upgrade requirements.
        // This may or may not become a documented feature.
        //
        if (dwFlags & NUA_SKIP_INSTALL_IN_GUI_MODE)
        {
            pwisParams->AddBoolKey(c_szAfSkipInstall, TRUE);
        }
    }

    TraceError(__FUNCNAME__, hr);

    return hr;
}


/*******************************************************************

    NAME:       EnableAllPrivileges

    SYNOPSIS:   Enxable all privileges on the current process token.  This
                is used just prior to attempting to shut down the system.

    ENTRY:      Nothing

    EXIT:       Nothing

    RETURNS:    LONG error code

    NOTES:

    HISTORY:

********************************************************************/

LONG EnableAllPrivileges ( VOID )
{
    HANDLE Token = NULL ;
    ULONG ReturnLength = 4096,
          Index ;
    PTOKEN_PRIVILEGES NewState = NULL ;
    BOOL Result = FALSE ;
    LONG Error = 0 ;

    do
    {
        Result = OpenProcessToken( GetCurrentProcess(),
                                   TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                                   & Token ) ;
        if (! Result)
        {
           Error = GetLastError() ;
           break;
        }

        Result = (NewState = (PTOKEN_PRIVILEGES) MemAlloc( ReturnLength )) != NULL ;

        if (! Result)
        {
           Error = ERROR_NOT_ENOUGH_MEMORY ;
           break;
        }

        Result = GetTokenInformation( Token,            // TokenHandle
                                      TokenPrivileges,  // TokenInformationClass
                                      NewState,         // TokenInformation
                                      ReturnLength,     // TokenInformationLength
                                      &ReturnLength     // ReturnLength
                                     );
        if (! Result)
        {
           Error = GetLastError() ;
           break;
        }

        //
        // Set the state settings so that all privileges are enabled...
        //

        if ( NewState->PrivilegeCount > 0 )
        {
                for (Index = 0; Index < NewState->PrivilegeCount; Index++ )
            {
                NewState->Privileges[Index].Attributes = SE_PRIVILEGE_ENABLED ;
            }
        }

        Result = AdjustTokenPrivileges( Token,          // TokenHandle
                                        FALSE,          // DisableAllPrivileges
                                        NewState,       // NewState (OPTIONAL)
                                        ReturnLength,   // BufferLength
                                        NULL,           // PreviousState (OPTIONAL)
                                        &ReturnLength   // ReturnLength
                                      );

        if (! Result)
        {
           Error = GetLastError() ;
           break;
        }
    }
    while ( FALSE ) ;

    if ( Token != NULL )
        CloseHandle( Token );

    MemFree( NewState ) ;

    return Result ? Error : 0 ;
}