windows-xp/Source/XPSP1/NT/net/config/netcfg/engine/classinst.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1999.
//
//  File:       C L A S S I N S T . C P P
//
//  Contents:   Defines the interface between the binding engine and the
//              network class installer.
//
//  Notes:
//
//  Author:     billbe   15 Jan 1999
//
//----------------------------------------------------------------------------

#include <pch.h>
#pragma hdrstop
#include "adapter.h"
#include "benchmrk.h"
#include "classinst.h"
#include "filtdev.h"
#include "netcfg.h"
#include "iatl.h"
#include "lockdown.h"
#include "ncatl.h"
#include "ncoc.h"
#include "ncreg.h"
#include "ncsetup.h"
#include "ncui.h"
#include "ncwins.h"
#include "persist.h"
#include "provider.h"
#include "resource.h"
#include "util.h"


// HrRegisterNotificationDll functions
enum ciRegisterDllFunction {CIRDF_REGISTER, CIRDF_UNREGISTER};

//+--------------------------------------------------------------------------
//
//  Function:   HrCiRegDeleteComponentNetworkKey
//
//  Purpose:    This function deletes the component key strInstanceGuid
//                  (and its subkeys) under the Network\<guidClass> tree.
//
//  Arguments:
//      Class            [in] The class of the component
//      pszInstanceGuid  [in] The instance guid of the component
//
//  Returns:    HRESULT. S_OK if successful, an error code otherwise.
//
//  Author:     billbe   27 Apr 1997
//
//  Notes:
//
HRESULT
HrCiRegDeleteComponentNetworkKey (
    IN NETCLASS Class,
    IN PCWSTR pszInstanceGuid)
{
    HRESULT hr = S_OK;
    HKEY    hkeyClass = NULL;

    PCWSTR pszNetworkSubtreePath = MAP_NETCLASS_TO_NETWORK_SUBTREE[Class];

    // Open the proper class key in the Network tree
    hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, pszNetworkSubtreePath,
            KEY_WRITE, &hkeyClass);

    // Delete the instance key tree
    //
    if (S_OK == hr)
    {
        hr = HrRegDeleteKeyTree(hkeyClass, pszInstanceGuid);
        RegSafeCloseKey(hkeyClass);
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiRegisterNotificationDll
//
//  Purpose:    Registers or Unregisters a component's notification dll with
//                  COM
//
//  Arguments:
//      hkeyInstance [in] The handle to the instance key for the component
//      crdf         [in] CIRDF_REGISTER if we are registering,
//                              CIRDF_UNREGISTER if we are unregistering
//
//  Returns:    HRESULT. S_OK on if dll is successfully registered,
//                          S_FALSE, if the component has no dll to
//                          register, error code otherwise
//
//  Author:     billbe   23 Mar 1997
//
//  Notes:
//
HRESULT
HrCiRegisterNotificationDll(
    IN HKEY hkeyInstance,
    IN ciRegisterDllFunction crdf)
{
    Assert(hkeyInstance);

    HKEY hkeyNdi;
    HRESULT hr;

    // Open the ndi key in the component's instance key so we can get the
    // Dll path.
    hr = HrRegOpenKeyEx (hkeyInstance, L"Ndi", KEY_READ, &hkeyNdi);
    if (S_OK == hr)
    {
        // Get the notification dll path
        tstring strDllPath;
        hr = HrRegQueryString (hkeyNdi, L"ComponentDLL", &strDllPath);

        if (S_OK == hr)
        {
            TraceTag (ttidClassInst,
                    "Attempting to (un)register notification dll '%S'",
                    strDllPath.c_str());
            hr = (CIRDF_REGISTER == crdf) ?
                    HrRegisterComObject (strDllPath.c_str()) :
                        HrUnregisterComObject (strDllPath.c_str());
        }
        else
        {
            if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
            {
                // The presence of the value is optional, so return
                // S_OK if it was not found
                hr = S_OK;
            }
        }
        RegCloseKey (hkeyNdi);
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiInstallServices
//
//  Purpose:    Processes any Inf service sections using strInfSection as a
//                  base name
//
//  Arguments:
//      hinfFile      [in] A handle to the inf file
//      pszInfSection [in] The base section name
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   2 Apr 1997
//
//  Notes: See SetupInstallServicesFromInfSection in SetupApi for more
//          info.
//
HRESULT
HrCiInstallServices(
    IN HINF hinfFile,
    IN PCWSTR pszInfSection)
{
    Assert (IsValidHandle(hinfFile));
    Assert (pszInfSection && *pszInfSection);

    BOOL fSuccess;
    WCHAR szServiceSection[_MAX_PATH];

    // append .Services to the section name
    //
    swprintf (szServiceSection, L"%s.%s", pszInfSection,
            INFSTR_SUBKEY_SERVICES);

    // Process the Services section
    fSuccess = SetupInstallServicesFromInfSection (hinfFile,
                    szServiceSection, 0);
    if (!fSuccess)
    {
        // Since the section is optional, we can ignore
        // ERROR_SECTION_NOT_FOUND
        if (ERROR_SECTION_NOT_FOUND == GetLastError())
        {
            fSuccess = TRUE;
        }
    }

    // Any errors must be converted
    HRESULT hr = S_OK;
    if (!fSuccess)
    {
        hr = HrFromLastWin32Error();
    }

    TraceHr (ttidError, FAL, hr, FALSE,
        "HrCiInstallServices (%S)", szServiceSection);
    return hr;
}


//+--------------------------------------------------------------------------
//
//  Function:   HrCiInstallFromInfSection
//
//  Purpose:    A wrapper function for SetupInstallFromInfSection. This
//              function handles setting up the copy files process for
//              SetupInstallFromInfSection as well.
//
//  Arguments:
//      hinfFile            [in] A handle to the inf file to install from
//      pszInfSectionName   [in] The section to install
//      hkeyRelative        [in] The key that will be used as the section's
//                                  HKR
//      hwndParent          [in] The HWND to the parent window, used for UI
//      dwInstallFlags      [in] See SetupInstallFromInfSection for info on
//                               these flags
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   4 Apr 1997
//
//  Notes: See SetupApi documentation for more info on
//              SetupInstallFromInfSection and
//              SetupInstallFilesFromInfSection
//
HRESULT
HrCiInstallFromInfSection(
    IN HINF hinfFile,
    IN PCWSTR pszInfSectionName,
    IN HKEY hkeyRelative,
    IN HWND hwndParent,
    IN DWORD dwInstallFlags)
{
    Assert (IsValidHandle (hinfFile));
    Assert (pszInfSectionName && *pszInfSectionName);

    HRESULT hr = S_OK;

    if (dwInstallFlags & SPINST_FILES)
    {
        // The next three variables are used for SetupApi's copy files process
        PSP_FILE_CALLBACK pfc;
        PVOID pvCtx;
        HSPFILEQ hfq;

        // If the inf file has a layout entry in its version section
        // we need to append its information for proper locations
        // of any files we need to copy.  If the call fails we can
        // still install, it just means the prompt for files will not
        // have the correct directory to begin with
        (VOID) SetupOpenAppendInfFile (NULL, hinfFile, NULL);

        // We need to create our own file queue so we can scan all the
        // files to be copied.  Scanning before committing our queue will
        // prompt the user if the files already exist in the destination
        //
        hr = HrSetupOpenFileQueue (&hfq);
        if (S_OK == hr)
        {
            BOOL fInGuiModeSetup = FInSystemSetup();

            hr = HrSetupInstallFilesFromInfSection (hinfFile, NULL, hfq,
                    pszInfSectionName, NULL, 0);

            // Set the default callback context
            // If the we are in system setup, we need to make sure the
            // callback doesn't display UI
            //
            if (S_OK == hr)
            {
                hr = HrSetupInitDefaultQueueCallbackEx (hwndParent,
                        (fInGuiModeSetup ? (HWND)INVALID_HANDLE_VALUE : NULL),
                        0, 0, NULL, &pvCtx);

                if (S_OK == hr)
                {
                    // Not doing anything special so use SetupApi default
                    // handler for file copy.
                    pfc = SetupDefaultQueueCallback;

                    // Scan the queue to see if the files are already in the
                    // destination and if so, prune them out.
                    DWORD dwScanResult;
                    hr = HrSetupScanFileQueueWithNoCallback (hfq,
                            SPQ_SCAN_FILE_VALIDITY |
                            SPQ_SCAN_PRUNE_COPY_QUEUE, hwndParent,
                            &dwScanResult);

                    // Now commit the queue so any files needing to be
                    // copied, will be.  If the scan result is 1 then there
                    // is nothing to commit.
                    //
                    if ((S_OK == hr) && (1 != dwScanResult))
                    {
                        hr = HrSetupCommitFileQueue (hwndParent, hfq, pfc, pvCtx);
                    }

                    // We need to release the default context and close our
                    // file queue
                    //
                    SetupTermDefaultQueueCallback (pvCtx);
                    SetupCloseFileQueue (hfq);
                }
            }
        }
    }

    if ((S_OK == hr) && (dwInstallFlags & ~SPINST_FILES))
    {
        Assert (hkeyRelative);

        // Now we run all sections but CopyFiles
        hr = HrSetupInstallFromInfSection (hwndParent, hinfFile,
                pszInfSectionName, (dwInstallFlags & ~SPINST_FILES),
                hkeyRelative, NULL, 0, NULL, NULL, NULL, NULL);
    }

    TraceHr (ttidError, FAL, hr, HRESULT_FROM_WIN32(ERROR_CANCELLED) == hr,
            "HrCiInstallFromInfSection");
    return hr;

}



//+--------------------------------------------------------------------------
//
//  Function:   HrCiDoCompleteSectionInstall
//
//  Purpose:    Runs all relevant sections of an inf file using strSection
//                   as the base section name.
//
//  Arguments:
//      hinfFile      [in] SetupApi handle to an inf file
//      hkeyRelative  [in] The registry key that will be the HKR
//                         key during inf processing.
//      pszSection    [in] Section name to install
//      hwndParent    [in] The handle to the parent, for
//                                   displaying UI
//      fEnumerated   [in] TRUE if this component is PnP enumerated
//                         FALSE otherwise
//
//  Returns:    HRESULT. S_OK if sucessful, error code otherwise
//
//  Author:     billbe   15 Apr 1997
//
//  Notes:
//
HRESULT
HrCiDoCompleteSectionInstall(
    IN HINF hinfFile,
    IN HKEY hkeyRelative,
    IN PCWSTR pszSection,
    IN HWND hwndParent,
    IN BOOL fEnumerated)
{
    Assert (IsValidHandle (hinfFile));
    Assert (FImplies (!fEnumerated, hkeyRelative));

    HRESULT hr = S_OK;

    // Only do this if there is a section name to work with
    if (pszSection && *pszSection)
    {
        // If this is an enumerated device, the service section and
        // the copy files section will be processed by the Device Installer
        // fcn SetupDiInstallDevice so we can exclude it from the following
        // calls.  But we do some processing based on registry and log config
        // entries so we will pre-run the registry section for enumerated
        // devices and exclude the others
        //

        // Run the section found using hkeyRelative as the HKR
        hr = HrCiInstallFromInfSection (hinfFile, pszSection,
                hkeyRelative, hwndParent,
                (fEnumerated ? (SPINST_REGISTRY | SPINST_LOGCONFIG) :
                        SPINST_ALL & ~SPINST_REGSVR));

        if (!fEnumerated)
        {
            // We need to run the Services section and
            // check for Winsock dependency if they aren't specified to be
            // excluded.
            //
            // Note:  Other sections may be added later.  The default is to
            // run all sections not listed in dwExcludeSectionFlags
            //
            if (S_OK == hr)
            {
                // run services section if it exists
                hr = HrCiInstallServices (hinfFile, pszSection);
                if (S_OK == hr)
                {
                    // Bug #383239: Wait till services are installed before
                    // running the RegisterDlls section
                    //
                    hr = HrCiInstallFromInfSection (hinfFile, pszSection,
                                                    hkeyRelative, hwndParent,
                                                    SPINST_REGSVR);
                }
            }

        }

        if (S_OK == hr)
        {

            //sb This part can be called for either add or remove. We
            //sb are moving only the remove part forward. This should
            //sb still be performed for add.
            //
            // Determine if a .Winsock section exists for the
            // section specified in szActualSection

            PCWSTR pszSubSection = wcsstr(pszSection, L".Remove");

            if(!pszSubSection || wcscmp(pszSubSection, L".Remove"))
            {
                hr = HrAddOrRemoveWinsockDependancy (hinfFile, pszSection);
            }

            // These other extensions are undocumented and some have been
            // added by external groups.  We don't want any of them
            // processed for enumerated components.
            //
            if ((S_OK == hr) && !fEnumerated)
            {
                // Process the additional INF extensions (SNMP Agent,
                // PrintMonitors, etc.)
                //
                hr = HrProcessAllINFExtensions (hinfFile, pszSection);
            }
        }
    }

    TraceHr (ttidError, FAL, hr, (HRESULT_FROM_WIN32(ERROR_CANCELLED) == hr),
            "HrCiDoCompleteSectionInstall");
    return hr;
}


//+--------------------------------------------------------------------------
//
//  Function:   HrCiRemoveNonEnumeratedComponent
//
//  Purpose:    This will run the remove section and delete the network
//                  instance key for the component if necessary.  This
//                  function is called for partially (i.e. failed install)
//                  and fully installed components
//
//  Arguments:
//      hinf              [in] The handle to the component's inf file
//      hkeyInstance      [in] The handle to the component's instance key
//      Class             [in] The class of the component
//      InstanceGuid      [in] The instance guid of the component
//      pstrRemoveSection [out] Optional pointer to a tstring which receives
//                              the remove section name.
//
//  Returns:    HRESULT. S_OK if successful, NETCFG_S_REBOOT if successful
//                  but a reboot is required, or an error code otherwise
//
//  Author:     billbe   10 Dec 1996
//              Revised  27 Apr 1997
//
//  Notes:
//
HRESULT
HrCiRemoveNonEnumeratedComponent(
    IN HINF hinf,
    IN HKEY hkeyInstance,
    IN NETCLASS Class,
    IN const GUID& InstanceGuid,
    OUT tstring* pstrRemoveSection OPTIONAL)
{
    Assert (IsValidHandle (hinf));
    Assert (IsValidHandle (hkeyInstance));

    static const WCHAR c_szRemoveSectionSuffix[] = L".Remove";

    // We get the remove section name and process all relevant sections
    // We also try to unregister any Notify objects available
    //
    WCHAR szRemoveSection[_MAX_PATH];
    DWORD cbBuffer = sizeof (szRemoveSection);
    HRESULT hr = HrRegQuerySzBuffer (hkeyInstance, REGSTR_VAL_INFSECTION,
                    szRemoveSection, &cbBuffer);

    if (S_OK == hr)
    {
        wcscat (szRemoveSection, c_szRemoveSectionSuffix);
        if (pstrRemoveSection)
        {
            pstrRemoveSection->assign(szRemoveSection);
        }
        hr = HrCiDoCompleteSectionInstall (hinf, hkeyInstance,
                szRemoveSection, NULL, NULL);
    }
    // Whether unregistering the notify object is successful or not,
    // we must fully remove the component.
    (VOID) HrCiRegisterNotificationDll (hkeyInstance, CIRDF_UNREGISTER);

    // Now we need to remove the component key in the Network tree
    // We need to do this regardless of any previous errors
    // so we don't need the return value.
    WCHAR szGuid[c_cchGuidWithTerm];
    StringFromGUID2 (InstanceGuid, szGuid, c_cchGuidWithTerm);
    (VOID) HrCiRegDeleteComponentNetworkKey (Class, szGuid);

    // if all went well, set the return value based on whether a reboot
    // is required or not or any error from HrRegisterNotificationDll.
    //
    if (S_FALSE == hr)
    {
        // S_FALSE is okay but should not be returned by this fcn.
        hr = S_OK;
    }

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


//+--------------------------------------------------------------------------
//
//  Function:   HrCiRemoveComponent
//
//  Purpose:    Called from INetCfg, this will uninstall a network component.
//
//  Arguments:
//      pComponent        [in] The component to uninstall.
//      pstrRemoveSection [out] Optional pointer to a tstring which receives
//                              the remove section name.
//
//  Returns:    HRESULT. S_OK if successful, NETCFG_S_REBOOT if successful
//                  but a reboot is required, or an error code otherwise
//
//  Author:     billbe   10 Dec 1996
//              Revised  27 Apr 1997
//
//  Notes:
//
HRESULT
HrCiRemoveComponent(
    IN const CComponent* pComponent,
    OUT tstring* pstrRemoveSection OPTIONAL)
{
    Assert (pComponent);

    HINF hinf = NULL;
    HDEVINFO hdi = NULL;
    SP_DEVINFO_DATA deid;
    HKEY hkeyInstance = NULL;
    HRESULT hr = S_OK;

    // If this is an enumerated net class component, then we need to
    // create the Device Installer structures for HrSetupDiRemoveDevice
    //
    if (FIsEnumerated (pComponent->Class()))
    {
        if (pComponent->m_dwCharacter & NCF_PHYSICAL)
        {
            // The binding engine calls us to remove physical devices
            // only when we need to potentially cleanup the information
            // we saved away when the class installer removed the device.
            // This happens when the class installer is told to remove
            // the device (which it does) and then notifies the binding
            // engine to remove it from its data structures.  The binding
            // engine then calls this method to cleanup this info we
            // set so that the binding engine could notify components of
            // its removal.
            //
            // We can also be called here when a physical component is
            // removed (with the binding engine write lock held by someone)
            // and then readded immediately.  The new component will get
            // the same PnpId as the removed one but the bindng engine still
            // has the removed component in its structures.  When this
            // condition is detected, the binding engine will remove the
            // old instance (by calling us here).  In this case, if we were
            // to open the device info on pComponent->m_pszPnpId, we'd open
            // the new instance that was added.  We don't want to do this.
            // We just want to cleanup any of the information that we set
            // for the binding engine when we first removed the device.
            //

            HKEY hkeyComponent;
            hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE,
                    c_szTempNetcfgStorageForUninstalledEnumeratedComponent,
                    KEY_WRITE, &hkeyComponent);

            if (S_OK == hr)
            {
                WCHAR szGuid[c_cchGuidWithTerm];
                INT cch = StringFromGUID2 (pComponent->m_InstanceGuid, szGuid,
                        c_cchGuidWithTerm);

                Assert (c_cchGuidWithTerm == cch);

                (VOID) HrRegDeleteKeyTree (hkeyComponent, szGuid);
                RegCloseKey (hkeyComponent);
            }
        }
        else
        {
            // Create a device info list
            hr = HrOpenDeviceInfo (pComponent->Class(),
                    pComponent->m_pszPnpId, &hdi, &deid);

            if (S_OK == hr)
            {
                // removals must go through device installer
                // hook (NetClassInstaller).  The function we are
                // in can only be called if the caller has the write lock
                // so we need to indicate this to the device installer hook
                // through our reserved data.
                ADAPTER_REMOVE_PARAMS arp = {0};
                CiSetReservedField (hdi, &deid, &arp);

                // removals must go through device installer
                // hook (NetClassInstaller).
                hr = HrSetupDiCallClassInstaller (DIF_REMOVE, hdi, &deid);

                // clear the reserved field so we don't delete it later
                CiClearReservedField (hdi, &deid);

                if (S_OK == hr)
                {
                    hr = FSetupDiCheckIfRestartNeeded (hdi, &deid) ?
                            NETCFG_S_REBOOT : S_OK;
#ifdef ENABLETRACE
                    if (NETCFG_S_REBOOT == hr)
                    {
                        TraceTag (ttidClassInst, "***********************************"
                                "**************************************************");

                        TraceTag (ttidClassInst, "The component %S needs a reboot "
                                "in order to function", pComponent->m_pszPnpId);

                        TraceTag (ttidClassInst, "***********************************"
                            "**************************************************");
                    }
#endif //ENABLETRACE
                }
                SetupDiDestroyDeviceInfoList (hdi);
            }
        }
    }
    else
    {
        // For non enumerated components, the instance key is the
        // component key
        hr = pComponent->HrOpenInstanceKey (KEY_ALL_ACCESS, &hkeyInstance,
                NULL, NULL);

        if (S_OK == hr)
        {
            if (NC_NETCLIENT == pComponent->Class ())
            {
                hr = HrCiDeleteNetProviderInfo (hkeyInstance, NULL, NULL);
            }


            if (S_OK == hr)
            {
                hr = pComponent->HrOpenInfFile(&hinf);

                if( S_OK == hr )
                {
                    // Remove the component
                    hr = HrCiRemoveNonEnumeratedComponent ( hinf,
                            hkeyInstance, pComponent->Class(),
                            pComponent->m_InstanceGuid,
                            pstrRemoveSection);
                }
            }
        }

        RegSafeCloseKey (hkeyInstance);
    }

    TraceHr (ttidError, FAL, hr, NETCFG_S_REBOOT == hr,
            "HrCiRemoveComponent (%S)", pComponent->PszGetPnpIdOrInfId());
    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   HrCiGetDriverInfo
//
//  Purpose:    Finds a component's driver information (in the inf file) and
//              creates a Device Info Data structure containing that
//              information as the structure's selected driver.
//              (see Device Installer Api for more info).
//
//  Arguments:
//      hdi        [in] See Device Installer Api documentation for more info.
//      pdeid      [in, out] See Device Installer Api documentation for
//                    more info. Should be allocated by caller, but empty.
//      guidClass  [in] The class guid for the component.
//      pszInfId   [in] The id of the component as found in its inf.
//      pszInfFile [in] Optional. The inf file for the component.
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise.
//
//  Author:     billbe   11 Mar 1997
//
//  Notes:
//
HRESULT
HrCiGetDriverInfo (
    IN     HDEVINFO hdi,
    IN OUT PSP_DEVINFO_DATA pdeid,
    IN     const GUID& guidClass,
    IN     PCWSTR pszInfId,
    IN     PCWSTR pszInfFile OPTIONAL)
{
    HRESULT hr;

    Assert (IsValidHandle (hdi));
    Assert (pdeid);
    Assert (pszInfId);

    // Copy the Id since we may need to change it.
    //
    WCHAR szId[_MAX_PATH];
    wcscpy (szId, pszInfId);

    // We cannot generate ids via HrSetupDiCreateDeviceInfo if they contain
    // slashes (e.g. Eisa\*pnp0232), so we need to convert any slashes in
    // the instance id to ampersands.
    //
    int iPos = 0;
    while (szId[iPos])
    {
        if (L'\\' == szId[iPos])
        {
            szId[iPos] = L'&';
        }
        ++iPos;
    }

    // First, create a [temporary] device info. This will be used to
    // find the component's Inf file.
    hr = HrSetupDiCreateDeviceInfo (hdi, szId, guidClass, NULL, NULL,
            DICD_GENERATE_ID, pdeid);

    if (S_OK == hr)
    {
        // In order to find the Inf file, Device Installer Api needs the
        // component id which it calls the Hardware id.
        //

        // We need to include an extra null since this registry value is a
        // multi-sz
        //
        wcsncpy (szId, pszInfId, iPos);
        szId[iPos + 1] = 0;

        hr = HrSetupDiSetDeviceRegistryProperty (hdi, pdeid, SPDRP_HARDWAREID,
                (const BYTE*)szId, CbOfSzAndTerm (szId) + sizeof(WCHAR));

        if (S_OK == hr)
        {
            // Get the install params and set the class for compat flag
            // This will use the device's class guid as a filter when
            // searching through infs, speeding things up.  We can also
            // let Device Installer Api know that we want to use a single
            // inf. if we can't get the params and set it it isn't an error
            // since it only slows things down a bit
            //
            SP_DEVINSTALL_PARAMS deip;
            hr = HrSetupDiGetDeviceInstallParams (hdi, pdeid, &deip);
            if (S_OK == hr)
            {
                deip.FlagsEx |= DI_FLAGSEX_USECLASSFORCOMPAT;

                // If we were not given an inf file to use...
                // We have a map of known components and their inf files.
                // If this component is in the map then we can set the
                // driver path in the device info data and
                // set the enumerate a single inf flag.  This will
                // cause the device installer to just look at the specified
                // inf file for the driver node.
                //

                // We only do this if the node doesn't already have a file
                // name set.
                //
                if (!(*deip.DriverPath))
                {
                    if (pszInfFile && *pszInfFile)
                    {
                        wcscpy (deip.DriverPath, pszInfFile);
                    }
                    else
                    {
                        FInfFileFromComponentId (pszInfId, deip.DriverPath);
                    }
                }

                if (*deip.DriverPath)
                {

                    TraceTag (ttidClassInst, "Class Installer was given %S "
                             "as a filename for %S", deip.DriverPath,
                             pszInfId);
                    deip.Flags |= DI_ENUMSINGLEINF;

                    if ((0 == _wcsicmp(L"netrasa.inf", deip.DriverPath)) ||
                        (0 == _wcsicmp(L"netpsa.inf",  deip.DriverPath)))
                    {
                        deip.Flags |= DI_NOFILECOPY;
                    }
                }
#ifdef ENABLETRACE
                else
                {
                    TraceTag (ttidNetcfgBase,
                              "Perf Warning: No knowledge of INF file for the '%S' "
                              "component.  SetupApi is now thrashing the disk looking for it.",
                              pszInfId);
                }
#endif // ENABLETRACE

                // For non-device classes, we need to allow excluded
                // drivers in order to get any driver list returned.
                if (!FIsEnumerated (guidClass))
                {
                    deip.FlagsEx |= DI_FLAGSEX_ALLOWEXCLUDEDDRVS;
                }

                (VOID) HrSetupDiSetDeviceInstallParams (hdi, pdeid, &deip);
            }

            // Now we let Device Installer Api build a driver list based on
            // the information we have given so far.  This will result in the
            // Inf file being found if it exists in the usual Inf directory
            //
#ifdef ENABLETRACE
    CBenchmark bmrk;
    bmrk.Start ("SetupDiBuildDriverInfoList");
#endif //ENABLETRACE

            hr = HrSetupDiBuildDriverInfoList (hdi, pdeid,
                    SPDIT_COMPATDRIVER);
#ifdef ENABLETRACE
    bmrk.Stop();
    TraceTag (ttidBenchmark, "%s : %s seconds",
            bmrk.SznDescription(), bmrk.SznBenchmarkSeconds (2));
#endif //ENABLETRACE

            if (S_OK == hr)
            {
                // HrSetupDiSelectBestCompatDrv finds and selects the best
                // driver for the device.
                //
                SP_DRVINFO_DATA drid;
                hr = HrSetupDiSelectBestCompatDrv(hdi, pdeid);

                if (HRESULT_FROM_SETUPAPI(ERROR_NO_COMPAT_DRIVERS) == hr)
                {
                    // Make the ERROR_NO_COMPAT_DRIVERS case look like what
                    // it really means -- the requested component's driver
                    // info (i.e. inf) could not be found.
                    //
                    hr = SPAPI_E_NO_DRIVER_SELECTED;
                }
            }
            else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
            {
                // We couldn't find an inf file which means we cannot
                // selected the driver for this component.
                //
                hr = SPAPI_E_NO_DRIVER_SELECTED;
            }
        }

        // if anything failed, we should remove the device node we created
        if (FAILED(hr))
        {
            (VOID) SetupDiDeleteDeviceInfo (hdi, pdeid);
        }
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiGetClassAndInfFileOfInfId
//
//  Purpose:    Finds a component's class and inf file.
//
//  Arguments:
//      pszInfId   [in]  The Id of the component as found in its Inf.
//      pClass     [out] The class of the component.
//      pszInfFile [out] The filename of the component's inf
//                       (must be _MAX_PATH long).
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise.
//
//  Author:     billbe   16 Mar 1998
//
//  Notes:
//
HRESULT
HrCiGetClassAndInfFileOfInfId (
    IN PCWSTR pszInfId,
    OUT NETCLASS* pClass,
    OUT PWSTR pszInfFile)   // Must be _MAX_PATH long
{
    HRESULT hr;
    const COMPONENT_INFO* pCompInfo;
    HDEVINFO hdi;

    Assert (pszInfId && *pszInfId);
    Assert (pClass);
    Assert (pszInfFile);

    hr = S_OK;

    // First, try the fast route by seeing if it's in our internal map.
    //
    pCompInfo = PComponentInfoFromComponentId (pszInfId);
    if (pCompInfo)
    {
        *pClass = NetClassEnumFromGuid (*pCompInfo->pguidClass);

        if (FIsValidNetClass (*pClass))
        {
            wcsncpy (pszInfFile, pCompInfo->pszInfFile, _MAX_PATH);
            pszInfFile [_MAX_PATH - 1] = 0;
        }
        else
        {
            hr = SPAPI_E_INVALID_CLASS;
        }
    }
    else
    {
        // Create a device info list.
        //
        hr = HrSetupDiCreateDeviceInfoList (NULL, NULL, &hdi);
        if (S_OK == hr)
        {
            SP_DEVINFO_DATA deid;

            // Get the driver info for the component and set it as the
            // selected driver
            //
            hr = HrCiGetDriverInfo (hdi, &deid, GUID_NULL, pszInfId, NULL);
            if (S_OK == hr)
            {
                SP_DRVINFO_DATA drid;

                // Get the selected driver.
                //
                hr = HrSetupDiGetSelectedDriver (hdi, &deid, &drid);
                if (S_OK == hr)
                {
                    // Set the class output parameter from the dev info data
                    // structure (HrGetDriverInfo updates this field if a driver
                    // was found)
                    //
                    *pClass = NetClassEnumFromGuid (deid.ClassGuid);

                    if (!FIsValidNetClass (*pClass))
                    {
                        hr = SPAPI_E_INVALID_CLASS;
                    }
                    else
                    {
                        PSP_DRVINFO_DETAIL_DATA pdridd;

                        // Now get the driver's detailed information
                        //
                        hr = HrCiGetDriverDetail (hdi, &deid, &drid,
                                                 &pdridd);
                        if (S_OK == hr)
                        {
                            // Get the inf filename and set the
                            // output parameter.
                            //
                            wcsncpy (pszInfFile, pdridd->InfFileName,
                                _MAX_PATH);
                            pszInfFile[_MAX_PATH - 1] = 0;

                            MemFree (pdridd);
                        }
                    }
                }
            }
            SetupDiDestroyDeviceInfoList (hdi);
        }
    }

    if (S_OK != hr)
    {
        *pClass = NC_INVALID;
        *pszInfFile = 0;
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiGetDriverDetail
//
//  Purpose:    Creates and fills a PSP_DRVINFO_DETAIL_DATA structure
//                  with detailed information about the pDevInfoData's
//                  selected driver
//
//  Arguments:
//      hdi     [in] See Device Installer Api documentation for more info
//      pdeid   [in] See Device Installer Api documentation for more info
//                          This value is NULL for non-physical net
//                          components.
//      pdrid   [in] See Device Installer Api documentation for more info
//      ppdridd [out] See Device Installer Api documentation for more info
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   11 Mar 1997
//
//  Notes:
//
HRESULT
HrCiGetDriverDetail (
    IN HDEVINFO hdi,
    IN PSP_DEVINFO_DATA pdeid OPTIONAL,
    OUT PSP_DRVINFO_DATA pdrid,
    OUT PSP_DRVINFO_DETAIL_DATA* ppdridd)
{
    Assert(IsValidHandle(hdi));
    Assert(pdrid);
    Assert(ppdridd);

    // initialize pdrid and set its cbSize field
    ZeroMemory (pdrid, sizeof (SP_DRVINFO_DATA));
    pdrid->cbSize = sizeof (SP_DRVINFO_DATA);

    HRESULT hr = S_OK;

    *ppdridd = NULL;

    // Get the selected driver for the component
    hr = HrSetupDiGetSelectedDriver (hdi, pdeid, pdrid);
    if (S_OK == hr)
    {
        // Get driver detail info
        hr = HrSetupDiGetDriverInfoDetail (hdi, pdeid, pdrid, ppdridd);
    }

    // clean up on failure
    if (FAILED(hr))
    {
        if (*ppdridd)
        {
            MemFree (*ppdridd);
            *ppdridd = NULL;
        }
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiRegSetComponentInformation
//
//  Purpose:    Stores component information under the instance key of
//                  the component.
//
//  Arguments:
//      hkeyInstance [in] Component's instance registry key.
//      pcii         [in] Component's information to store in hkeyInstance.
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise.
//
//  Author:     billbe   11 Mar 1997
//
//  Notes:
//
HRESULT
HrCiRegSetComponentInformation(
    IN HKEY hkeyInstance,
    IN COMPONENT_INSTALL_INFO* pcii)
{
    Assert(hkeyInstance);
    Assert(pcii);

    HRESULT hr = S_OK;

    BOOL fIsEnumerated = FIsEnumerated (pcii->Class);

    // Store the characteristics, inf path, and main
    // install section for the component
    //

    hr = HrRegSetDword (hkeyInstance, L"Characteristics", pcii->dwCharacter);

    if (FAILED(hr))
    {
        goto exit;
    }

    if (!fIsEnumerated)
    {
        hr = HrRegSetSz (hkeyInstance, L"InfPath" /*REGSTR_VAL_INFPATH*/,
                pcii->pszInfFile);

        if (FAILED(hr))
        {
            goto exit;
        }

        hr = HrRegSetSz (hkeyInstance, L"InfSection"/*REGSTR_VAL_INFSECTION*/,
                pcii->pszSectionName);

        if (FAILED(hr))
        {
            goto exit;
        }
    }

    // For non-enumerated components, store description into the registry.
    //
    if (!fIsEnumerated)
    {
        hr = HrRegSetSz (hkeyInstance, L"Description", pcii->pszDescription);

        if (FAILED(hr))
        {
            goto exit;
        }
    }

    // If this component is already installed, then there is no need to write
    // the following information
    //
    if (FIsEnumerated (pcii->Class) && !pcii->fPreviouslyInstalled &&
                FIsPhysicalAdapter (pcii->Class, pcii->dwCharacter) &&
                (InterfaceTypeUndefined != pcii->BusType))
    {
        hr = HrRegSetSzAsUlong (hkeyInstance, L"BusType",
                pcii->BusType, c_nBase10);

        if (FAILED(hr))
        {
            goto exit;
        }
    }

    hr = HrRegSetSz (hkeyInstance, L"ComponentId", pcii->pszInfId);

exit:

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiCreateInstanceKey
//
//  Purpose:    Creates an instance key for the component.  For enumerated
//                devices, this is
//                HKLM\System\CCS\Control\Class\<net guid>\<instance id>
//                For non-enumerated components, this is under
//                HKLM\System\CCS\Control\Network\<Class Guid>\<Instance Guid>
//
//  Arguments:
//      pcii          [inout] Component install info structure.
//      phkeyInstance [out]   The component's registry instance key.
//
//  Returns:    HRESULT
//
//  Author:     billbe   22 Mar 1997
//
//  Notes:
//
HRESULT
HrCiCreateInstanceKey(
    IN COMPONENT_INSTALL_INFO* pcii,
    OUT HKEY* phkeyInstance)
{
    Assert (pcii);
    Assert (phkeyInstance);
    Assert (FImplies (FIsEnumerated (pcii->Class),
                    IsValidHandle (pcii->hdi) && pcii->pdeid));

    HRESULT hr = S_OK;

    // initialize the HKEY parameter
    *phkeyInstance = NULL;

    // Create the instance key for this component under the
    // Network\<net guid> tree.  This will be the component's
    // instance key for all but physical net class components.  Their
    // instance key is created by Device Installer Api and lives under the
    // Pnp Net Class driver tree.

    // If the object is an enumerated component then we let
    // the Device Installer api do the work
    //
    if (FIsEnumerated (pcii->Class))
    {

        // We need to create the adapter's driver key under
        // the Pnp Net Class Driver tree.
        //

        hr = HrSetupDiCreateDevRegKey (pcii->hdi,
                pcii->pdeid, DICS_FLAG_GLOBAL, 0, DIREG_DRV,
                NULL, NULL, phkeyInstance);
    }
    else
    {
        // Not a physical net adapter so the component key is
        // the instance key

        // First, create the instance GUID
        hr = CoCreateGuid (&pcii->InstanceGuid);

        // Now create the key
        if (S_OK == hr)
        {
            WCHAR szInstanceKeyPath[_MAX_PATH];

            CreateInstanceKeyPath (pcii->Class, pcii->InstanceGuid,
                    szInstanceKeyPath);

            hr = HrRegCreateKeyEx (HKEY_LOCAL_MACHINE,
                     szInstanceKeyPath,
                     REG_OPTION_NON_VOLATILE,
                     KEY_ALL_ACCESS,
                     NULL,
                     phkeyInstance,
                     NULL);
        }
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiGetPropertiesFromInf
//
//  Purpose:    Retrieves a set of the component's proerties from the inf
//                  file.
//
//  Arguments:
//      hinfFile [in] A handle to the component's inf file
//      pcii     [inout] The component info structure
//                       See compinfo.h for more info
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   14 Jun 1997
//
//  Notes:
//
HRESULT
HrCiGetPropertiesFromInf (
    IN HINF hinfFile,
    IN OUT COMPONENT_INSTALL_INFO* pcii)
{
    Assert (IsValidHandle (hinfFile));
    Assert (pcii);
    Assert (pcii->pszSectionName);

    // Find the inf line that contains Characteristics and retrieve it

    HRESULT hr = HrSetupGetFirstDword (hinfFile, pcii->pszSectionName,
            L"Characteristics", &pcii->dwCharacter);

    if ((S_OK == hr) &&
            (FIsPhysicalAdapter(pcii->Class, pcii->dwCharacter)))
    {
        hr = HrCiGetBusInfoFromInf (hinfFile, pcii);
    }
#ifdef DBG
    else if (FAILED(hr))
    {
        TraceTag(ttidError, "Inf contains no Characteristics field");
    }
#endif // DBG

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiIsInstalledComponent
//
//  Purpose:    Checks if the component is already installed
//
//
//  Arguments:
//      pcici  [in] A structure containing the component information
//                       See compinst.h for definition
//      phkey  [out] The registry instance key of the adapter
//                     during inf processing. only set if fcn returns S_OK
//
//  Returns:    HRESULT - S_OK if the component is already installed
//                        S_FALSE if the component is not already installed
//                        A win32 converted error otherwise
//
//  Author:     billbe   17 Sep 1997
//
//  Notes:
//
HRESULT
HrCiIsInstalledComponent (
    IN COMPONENT_INSTALL_INFO* pcii,
    OUT HKEY* phkey)
{
    HRESULT hr;

    Assert(pcii);

    if (phkey)
    {
        *phkey = NULL;
    }

    // If this is an enumerated component, we just check for NetCfgInstanceId
    // in the instance (driver) key.
    //
    if (FIsEnumerated (pcii->Class))
    {
        HKEY hkey;
        hr = HrSetupDiOpenDevRegKey (pcii->hdi, pcii->pdeid, DICS_FLAG_GLOBAL,
                0, DIREG_DRV, KEY_ALL_ACCESS, &hkey);

        if (S_OK == hr)
        {
            WCHAR szGuid[c_cchGuidWithTerm];
            DWORD cbGuid = sizeof (szGuid);
            hr = HrRegQuerySzBuffer (hkey, L"NetCfgInstanceId", szGuid,
                    &cbGuid);

            if (S_OK == hr)
            {
                IIDFromString (szGuid, &pcii->InstanceGuid);
                if (phkey)
                {
                    *phkey = hkey;
                }
            }
            else
            {
                RegCloseKey (hkey);
                hr = S_FALSE;
            }
        }
        else if ((SPAPI_E_KEY_DOES_NOT_EXIST == hr) ||
                (SPAPI_E_DEVINFO_NOT_REGISTERED == hr))

        {
            TraceTag(ttidClassInst, "Component is not known by Net Config");
            hr = S_FALSE;
        }
    }
    else
    {
        // For non-enumerated components, we check the netcfg "config blob" to
        // determine if this component is isntalled.
        CNetConfig NetConfig;
        hr = HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig);

        if (S_OK == hr)
        {
            CComponent* pComponent;
            pComponent = NetConfig.Core.Components.
                    PFindComponentByInfId(pcii->pszInfId, NULL);

            if (pComponent)
            {
                pcii->InstanceGuid = pComponent->m_InstanceGuid;
                if (phkey)
                {
                    hr = pComponent->HrOpenInstanceKey(KEY_ALL_ACCESS, phkey,
                            NULL, NULL);
                }
            }
            else
            {
                hr = S_FALSE;
            }
        }
    }

    TraceHr (ttidError, FAL, hr, S_FALSE == hr, "HrCiIsInstalledComponent");
    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   HrCiCreateInstanceKeyAndProcessMainInfSection
//
//  Purpose:    Processes a component's main inf section and
//              storing, in the registry, any extra information needed for
//              component initialization
//
//  Arguments:
//      hinf  [in] Handle to the component's inf file.
//      pcii  [inout] Will be filled with information about the
//                    component.
//      phkey [out] Handle to the component's registry instance key.
//
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   15 Nov 1996
//
//  Notes:
//
HRESULT
HrCiCreateInstanceKeyAndProcessMainInfSection(
    IN HINF hinf,
    IN COMPONENT_INSTALL_INFO* pcii,
    OUT HKEY* phkey)
{
#if defined(REMOTE_BOOT)
    GUID c_guidRemoteBoot;
    static const WCHAR c_szRemoteBootAdapterGuid[] =
            L"{54C7D140-09EF-11D1-B25A-F5FE627ED95E}";

    DEFINE_GUID(c_guidRemoteBoot, 0x54c7d140, 0x09ef, 0x11d1, 0xb2, 0x5a, 0xf5, 0xfe, 0x62, 0x7e, 0xd9, 0x5e);
#endif // defined(REMOTE_BOOT)

    Assert (IsValidHandle (hinf));
    Assert (pcii);
    Assert (phkey);

    // The properties retrieved here will be written to the registry
    // later.
    HRESULT hr = HrCiGetPropertiesFromInf (hinf, pcii);

    if (S_OK == hr)
    {
        BOOL fEnumerated = FIsEnumerated (pcii->Class);

        // If this component is enumerated, then we need to know if it
        // is a remote boot adapter.
        if (fEnumerated)
        {
            Assert (IsValidHandle (pcii->hdi));
            Assert (pcii->pdeid);

#if defined(REMOTE_BOOT)
            // If this adapter is a remote boot adapter, then we have
            // to use a pre-determined GUID
            //
            if (S_OK == HrIsRemoteBootAdapter(pcii->hdi, pcii->pdeid))
            {
                pcai->m_fRemoteBoot = TRUE;
                pcii->InstanceGuid = c_guidRemoteBoot;
            }
#endif // defined(REMOTE_BOOT)

        }

        // Is this a fresh install or a reinstall?
        hr = HrCiIsInstalledComponent(pcii, phkey);

        if (S_FALSE == hr)
        {
            hr = S_OK;

            // Fresh install
            //

            if (S_OK == hr)
            {
                // For non-physical components, the relative key will
                // be the driver instance key which is under the class
                // branch of the Network key. Its form is
                // <Class GUID>/<instance GUID>.
                // For physical components, the key is under
                // the Pnp class driver tree. The next call will
                // create this key

                hr = HrCiCreateInstanceKey(pcii, phkey);

                if (fEnumerated)
                {
                    // If  we don't have an instance
                    // guid (i.e. not remote boot adapter),
                    // get one
                    if (GUID_NULL == pcii->InstanceGuid)
                    {
                        hr = CoCreateGuid(&pcii->InstanceGuid);
#ifdef ENABLETRACE
                        WCHAR szGuid[c_cchGuidWithTerm];
                        StringFromGUID2(pcii->InstanceGuid, szGuid,
                                c_cchGuidWithTerm);
                        TraceTag(ttidClassInst, "NetCfg Instance Guid %S "
                                "generated for %S",
                                 szGuid,
                                 pcii->pszInfId);
#endif // ENABLETRACE
                    }
                }
            }
        }
        else if (S_OK == hr)
        {
            // This component is being reinstalled
            pcii->fPreviouslyInstalled = TRUE;
        }

        if (S_OK == hr)
        {
            // Now that the instance key is created, we need to run
            // the main inf sections
            //
            hr = HrCiDoCompleteSectionInstall(hinf, *phkey,
                    pcii->pszSectionName,
                    pcii->hwndParent, fEnumerated);

            // On failure of fresh installs, remove components
            if (FAILED(hr) && !pcii->fPreviouslyInstalled)
            {
                if (!fEnumerated)
                {
                    HrCiRemoveNonEnumeratedComponent (hinf, *phkey,
                        pcii->Class, pcii->InstanceGuid, NULL);
                }
            }
        }
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiDoOemFileCopyIfNeeded
//
//  Purpose: Calls HrSetupCopyOemInf if strInfPath is not already in the
//              inf directory.  This will copy an Oem inf to the inf
//              directory with a new name.
//
//  Arguments:
//      pszInfPath [in]  Path to the inf file
//      pszNewName [out] The new name of the copied inf file
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   15 May 1997
//
//  Notes:
//
HRESULT
HrCiDoOemFileCopyIfNeeded(
    IN PCWSTR pszInfPath,
    OUT PWSTR pszNewName)
{
    Assert (pszInfPath);
    Assert (pszNewName);

    HRESULT hr = S_OK;
    WCHAR szInfDir[_MAX_PATH] = {0};

    // fill buffer with path to %windir%
    GetSystemWindowsDirectory (szInfDir, _MAX_PATH);

    // the inf directory is %windir%\inf
    //
    wcscat (szInfDir, L"\\");
    wcscat (szInfDir, L"Inf");

    // Extract the directory from the filename
    //
    PWSTR pszEnd = wcsrchr (pszInfPath, L'\\');
    DWORD cch;
    if (pszEnd)
    {
        cch = pszEnd - pszInfPath;
    }
    else
    {
        cch = wcslen (pszInfPath);
    }

    // if the inf is not already in the inf directory, copy it there
    //
    if ((cch != wcslen (szInfDir)) ||
            (0 != _wcsnicmp (pszInfPath, szInfDir, cch)))
    {
        WCHAR szDestFilePath[_MAX_PATH];
        PWSTR pszDestFilename;
        hr = HrSetupCopyOemInfBuffer (pszInfPath, NULL, SPOST_PATH, 0,
                szDestFilePath, _MAX_PATH, &pszDestFilename);

        if (S_OK == hr)
        {
            wcscpy (pszNewName, pszDestFilename);
        }
    }
    else
    {
        // The inf is already in the right directory so just copy the
        // current filename component.
        if (pszEnd)
        {
            wcscpy (pszNewName, pszEnd + 1);
        }
        else
        {
            wcscpy (pszNewName, pszInfPath);
        }
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiInstallNonEnumeratedComponent
//
//  Purpose:    This function completes the installation of a non-enumerated
//                  component
//
//  Arguments:
//      hinf [in] SetupApi handle to an inf file
//      hkey [in] The registry instance key of the adapter
//                during inf processing.
//      pcii [in] A structure containing the component information
//
//  Returns:    HRESULT. S_OK if successful, or error code otherwise
//
//  Author:     billbe   28 Apr 1997
//
//  Notes:
//
HRESULT
HrCiInstallNonEnumeratedComponent (
    IN HINF hinf,
    IN HKEY hkey,
    IN COMPONENT_INSTALL_INFO* pcii)
{
    // Register the notification dll for this component,
    // if it exists.
    HRESULT hr = HrCiRegisterNotificationDll(hkey, CIRDF_REGISTER);

    // Device Installer Api handles OEM files for
    // enumerated components in InstallDevice
    // Since this component is non-enumerated
    // we need to handle any oem files
    // manually.
    //

    // Copy the inf file if needed then store
    // the new inf name
    // Note: if the inf file does not need to
    // be copied, the new name will be the
    // old name without the directory info.
    //

    if (S_OK == hr)
    {
        WCHAR szNewName[_MAX_PATH];;
        hr = HrCiDoOemFileCopyIfNeeded (pcii->pszInfFile, szNewName);
        if (S_OK == hr)
        {
            // set the new path value in the registry.
            hr = HrRegSetSz (hkey, REGSTR_VAL_INFPATH, szNewName);

            if ((S_OK == hr) && (NC_NETCLIENT == pcii->Class))
            {
                // if this is a network client, do appropriate processing.
                hr = HrCiAddNetProviderInfo (hinf, pcii->pszSectionName,
                        hkey, pcii->fPreviouslyInstalled);
            }
        }
    }

    // On failures of first time installs, remove the component.
    //
    if (FAILED(hr) && !pcii->fPreviouslyInstalled)
    {
        TraceTag (ttidClassInst, "Install canceled. Removing...");
        (VOID) HrCiRemoveNonEnumeratedComponent (hinf, hkey, pcii->Class,
                pcii->InstanceGuid, NULL);
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiInstallComponentInternal
//
//  Purpose: Installs a component
//
//  Arguments:
//      pcii [in, out] Will be filled with information about the
//                     component.
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   15 Nov 1996
//
//  Notes:
//
HRESULT
HrCiInstallComponentInternal (
    IN OUT COMPONENT_INSTALL_INFO* pcii)
{
    HRESULT hr = S_OK;
    HINF hinfInstallFile = NULL;
    HKEY hkeyInstance = NULL;

    TraceTag (ttidClassInst, "Installing %S from %S",
              pcii->pszInfId, pcii->pszInfFile);

    // Open the component's inf file.
    hr = HrSetupOpenInfFile (pcii->pszInfFile, NULL, INF_STYLE_WIN4,
            NULL, &hinfInstallFile);

    // Continue only if we have opened the file.
    if (S_OK == hr)
    {
        // The section we have currently might need to be decorated
        // with OS and Platform specific suffixes.  The next call
        // will return the actual decorated section name or our
        // current section name if the decorated one does not exist.
        //

        // Store the original section name pointer so we can restore
        // it after we have finished.
        PCWSTR pszOriginalSectionName = pcii->pszSectionName;

        // Now we get the actual section name.
        //
        WCHAR szActualSection[_MAX_PATH];
        hr = HrSetupDiGetActualSectionToInstallWithBuffer (hinfInstallFile,
                pcii->pszSectionName, szActualSection, _MAX_PATH, NULL,
                NULL);

        if (S_OK == hr)
        {
            pcii->pszSectionName = szActualSection;
            hr = HrCiCreateInstanceKeyAndProcessMainInfSection (
                hinfInstallFile, pcii, &hkeyInstance);

            if (S_OK == hr)
            {
                // Set up the registry with the component info.
                hr = HrCiRegSetComponentInformation (hkeyInstance, pcii);

                if (S_OK == hr)
                {
                    // We do different things during install based
                    // on whether PnP knows about the component
                    // (i.e. enumerated) or not.

                    if (FIsEnumerated (pcii->Class))
                    {
                        hr = HrCiInstallEnumeratedComponent (
                                hinfInstallFile, hkeyInstance, *pcii);
                    }
                    else
                    {
                        hr = HrCiInstallNonEnumeratedComponent (
                               hinfInstallFile, hkeyInstance, pcii);
                    }
                }
                RegSafeCloseKey(hkeyInstance);
            }
            // set the section name back
            pcii->pszSectionName = pszOriginalSectionName;
        }
        SetupCloseInfFile(hinfInstallFile);
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiCallClassInstallerToInstallComponent
//
//  Purpose:    This function invokes the class installer to install an
//              enumerated component.
//
//  Arguments:
//      hdi   [in] See Device Installer docs for more info.
//      pdeid [in]
//
//  Returns:    HRESULT. S_OK if successful, or error code otherwise
//
//  Author:     billbe   28 Apr 1997
//
//  Notes:  This should only be called while the INetCfg lock is held.
//
HRESULT
HrCiCallClassInstallerToInstallComponent(HDEVINFO hdi, PSP_DEVINFO_DATA pdeid)
{
    HRESULT hr;

    Assert(IsValidHandle(hdi));
    Assert(pdeid);

    // We need to register the device before we do any work on it.
    hr = HrSetupDiCallClassInstaller (DIF_REGISTERDEVICE, hdi, pdeid);

    if (S_OK == hr)
    {
        // Check if we can install of this component. i.e. is the inf
        // a valid Windows 2000 inf.
        hr = HrSetupDiCallClassInstaller (DIF_ALLOW_INSTALL, hdi, pdeid);

        if (S_OK == hr)
        {
            BOOL fFileCopy = TRUE;
            SP_DEVINSTALL_PARAMS deip;

            // Fu fu fu: SetupApi is ignoring DI_NOFILECOPY so we'll overcome
            // their shortcomings and do it ourselves.
            //
            hr = HrSetupDiGetDeviceInstallParams (hdi, pdeid, &deip);
            if (S_OK == hr)
            {
                if (deip.Flags & DI_NOFILECOPY)
                {
                    fFileCopy = FALSE;
                }
            }

            if (fFileCopy)
            {
                // Install needed files.
                hr = HrSetupDiCallClassInstaller (DIF_INSTALLDEVICEFILES, hdi,
                        pdeid);
            }

            if (S_OK == hr)
            {
                // Now that all files have been copied, we need to set the
                // no file copy flag.  Otherwise, setupapi will try to copy
                // files at each dif code.  This results in multiple (1 per
                // dif code) unsigned driver popups if the driver was
                // unsigned.
                // We'll only do this if the no copy file flag wasn't already
                // set. i.e. if fFileCopy is TRUE.
                //
                if (fFileCopy)
                {
                    // An error here isn't bad enough to stop installation.
                    //
                    HRESULT hrTemp;
                    hrTemp = HrSetupDiSetDeipFlags (hdi, pdeid, DI_NOFILECOPY,
                            SDDFT_FLAGS, SDFBO_OR);

                    TraceHr (ttidError, FAL, hrTemp, FALSE,
                            "HrCiCallClassInstallerToInstallComponent: "
                             "HrSetupDiSetDeipFlags");
                }

                // Device co-installers need to be registered at this point
                // so they can do work.
                hr = HrSetupDiCallClassInstaller (DIF_REGISTER_COINSTALLERS,
                        hdi, pdeid);

                if (S_OK == hr)
                {
                    hr = HrSetupDiCallClassInstaller (DIF_INSTALLINTERFACES,
                            hdi, pdeid);

                    if (S_OK == hr)
                    {
                        hr = HrSetupDiCallClassInstaller (DIF_INSTALLDEVICE,
                                hdi, pdeid);
                    }
                }
            }
        }

        // If we failed for any reason, we need to clean up since
        // we initiated this install.
        if (FAILED(hr))
        {
            ADAPTER_REMOVE_PARAMS arp;
            arp.fBadDevInst = TRUE;
            arp.fNotifyINetCfg = FALSE;

            CiSetReservedField (hdi, pdeid, &arp);
            HrSetupDiCallClassInstaller (DIF_REMOVE, hdi, pdeid);
            CiClearReservedField (hdi, pdeid);

        }
    }

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


//+--------------------------------------------------------------------------
//
//  Function:   HrCiInstallComponent
//
//  Purpose:    This function takes a Network Component's Id and its class
//              guid and gathers the information needed by
//              HrCiInstallComponent. Since it is called from INetCfg, we
//              have the write lock
//
//  Arguments:
//      Params [in] Component install params. See install.h
//      ppComponent [out] A created CComponent representing the installed
//                        component.
//      pdwNewCharacter [out] Optional pointer to a DWORD to receive the
//                            characteristics of the component.
//
//  Returns:    HRESULT. S_OK is successful, NETCFG_S_REBOOT if a reboot is
//                      needed to start the device, or an error code
//
//  Author:     billbe   16 Mar 1997
//
//  Notes:
//
HRESULT
HrCiInstallComponent (
    IN const COMPONENT_INSTALL_PARAMS& Params,
    OUT CComponent** ppComponent,
    OUT DWORD* pdwNewCharacter)
{
    Assert (FIsValidNetClass (Params.Class));
    Assert (Params.pszInfId && *Params.pszInfId);
    Assert (!Params.pComponent);

    HRESULT hr = S_OK;
    HDEVINFO hdi = NULL;
    SP_DEVINFO_DATA deid;
    const GUID* pguidClass = MAP_NETCLASS_TO_GUID[Params.Class];

    if (ppComponent)
    {
        *ppComponent = NULL;
    }
    if (pdwNewCharacter)
    {
        *pdwNewCharacter = 0;
    }

    // If we're about to install the component, it better not be in
    // lockdown.
    //
    Assert (!FIsComponentLockedDown (Params.pszInfId));

    // First create a device info set
    hr = HrSetupDiCreateDeviceInfoList (pguidClass, NULL, &hdi);

    if (S_OK == hr)
    {
        // This will create an node in the enum tree for this component.
        // If it is enumerated, we will register it which will make
        // it persist.  If non-enumerated, we will not register it and
        // the node will be deleted in the call to SetDiDestroyDeviceInfoList.
        //
        hr = HrCiGetDriverInfo (hdi, &deid, *pguidClass,
                Params.pszInfId, Params.pszInfFile);

        // Get the driver info for the component
        if (S_OK == hr)
        {
            BASIC_COMPONENT_DATA Data = {0};
            Data.Class = Params.Class;
            Data.pszInfId = Params.pszInfId;

            if (FIsEnumerated (Params.Class))
            {
                // If the component is enumerated, we will need a place to
                // store its pnp id.
                WCHAR szPnpId[MAX_DEVICE_ID_LEN];
                ADAPTER_OUT_PARAMS AdapterOutParams;

                ZeroMemory (&AdapterOutParams, sizeof(AdapterOutParams));

                // Net class components have to go through the device
                // installer hook (aka NetClassInstaller)
                //

                if (FInSystemSetup())
                {
                    // if we are in GUI mode we need to make the
                    // device install quiet and always copy from
                    // the source location even if the files are
                    // already present. We also need to set
                    // the in system setup flag.  This is what
                    // syssetup would do if it initiated the install
                    // so INetCfg initiated installs must do the same.
                    //
                    // We should also set the parent hwnd.
                    //

                    SP_DEVINSTALL_PARAMS deip;
                    HRESULT hrTemp = HrSetupDiGetDeviceInstallParams (
                            hdi, &deid, &deip);

                    if (S_OK == hr)
                    {
                        deip.hwndParent = Params.hwndParent;
                        deip.Flags |= DI_QUIETINSTALL | DI_FORCECOPY;
                        deip.FlagsEx |= DI_FLAGSEX_IN_SYSTEM_SETUP;

                        hrTemp = HrSetupDiSetDeviceInstallParams (
                                hdi, &deid, &deip);
                    }

                    TraceHr (ttidError, FAL, hrTemp, FALSE, "Error "
                            "getting and setting device params.");
                }

                CiSetReservedField (hdi, &deid, &AdapterOutParams);

                // Officially call the class installer to install
                // this device
                //
                hr = HrCiCallClassInstallerToInstallComponent (hdi, &deid);

                CiClearReservedField (hdi, &deid);

                Data.dwCharacter = AdapterOutParams.dwCharacter;
                Data.InstanceGuid = AdapterOutParams.InstanceGuid;

                if (S_OK == hr)
                {
                    hr = HrSetupDiGetDeviceInstanceId (hdi, &deid, szPnpId,
                            MAX_DEVICE_ID_LEN, NULL);

                    if (S_OK == hr)
                    {
                        Data.pszPnpId = szPnpId;
                    }
                }
            }
            else // Non-net class components
            {
                COMPONENT_INSTALL_INFO cii;
                PSP_DRVINFO_DETAIL_DATA pdridd = NULL;
                SP_DRVINFO_DATA drid;

                // Now get the driver's detailed information
                hr = HrCiGetDriverDetail (hdi, &deid, &drid, &pdridd);

                if (S_OK == hr)
                {
                    ZeroMemory (&cii, sizeof(cii));
                    cii.Class = Params.Class;
                    cii.pszInfId = Params.pszInfId;
                    cii.pszInfFile = pdridd->InfFileName;
                    cii.hwndParent = Params.hwndParent;
                    cii.pszDescription = drid.Description;
                    cii.pszSectionName = pdridd->SectionName;

                    HINF hinf;
                    hr = HrSetupOpenInfFile (pdridd->InfFileName, NULL,
                            INF_STYLE_WIN4, NULL, &hinf);

                    if (S_OK == hr)
                    {
                        // Make sure this is an NT5 inf network inf
                        //
                        hr = HrSetupIsValidNt5Inf (hinf);
                        SetupCloseInfFile (hinf);
                    }

                    if (S_OK == hr)
                    {
                        hr = HrCiInstallComponentInternal (&cii);
                        if (S_OK == hr)
                        {
                            Data.InstanceGuid = cii.InstanceGuid;
                            Data.dwCharacter = cii.dwCharacter;
                        }
                    }
                    MemFree (pdridd);
                }
            }

            if ((S_OK == hr) && ppComponent) // !previously installed
            {
                CComponent* pComponent;

                hr = CComponent::HrCreateInstance (
                        &Data,
                        CCI_ENSURE_EXTERNAL_DATA_LOADED,
                        Params.pOboToken,
                        &pComponent);

                if (S_OK == hr)
                {
                    *ppComponent = pComponent;
                }
            }

            if ((S_OK == hr) && pdwNewCharacter)
            {
                *pdwNewCharacter = Data.dwCharacter;
            }
        }

        SetupDiDestroyDeviceInfoList(hdi);
    }


#ifdef ENABLETRACE
    if (S_OK == hr)
    {
        TraceTag(ttidClassInst, "Component now installed!");
    }
#endif //ENABLETRACE

    TraceHr (ttidError, FAL, hr, FALSE,
        "HrCiInstallComponent (%S)", Params.pszInfId);
    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   SetBadDriverFlagIfNeededInList
//
//  Purpose: Enumerates a driver list setting the DNF_BAD_DRIVER flag
//           in every node that has a DNF_EXCLUDEFROMLIST flag.
//
//  Arguments:
//      hdi      [in] See Device Installer Api documentaion for details
//
//  Returns:    HRESULT. S_OK
//
//  Author:     billbe   24 Nov 1998
//
//  Notes: SetupDi forces us to use the DNF_BAD_DRIVER flag for non-netdevice
//         classes if we want to exclude them from the select device dialog.
//         This means to non-netclass components that
//         DNF_BAD_DRIVER = DNF_EXCLUDEFROMLIST.
//
VOID
SetBadDriverFlagIfNeededInList(HDEVINFO hdi)
{
    Assert(IsValidHandle(hdi));

    HRESULT                 hr = S_OK;
    SP_DRVINSTALL_PARAMS    drip;
    SP_DRVINFO_DATA         drid;
    DWORD                   dwIndex = 0;

    // Enumerate each driver in hdi
    while (S_OK == (hr = HrSetupDiEnumDriverInfo(hdi, NULL,
            SPDIT_CLASSDRIVER, dwIndex++, &drid)))
    {
        hr = HrSetupDiGetDriverInstallParams(hdi, NULL, &drid, &drip);

        if (S_OK == hr)
        {
            // If the driver already has the bad driver flag set,
            // go on to the next one.
            if (drip.Flags & DNF_BAD_DRIVER)
            {
                continue;
            }

            // If the driver has the exclude flag set, then set the
            // bad driver flag.
            if (drip.Flags & DNF_EXCLUDEFROMLIST)
            {
                drip.Flags |= DNF_BAD_DRIVER;
                (VOID) HrSetupDiSetDriverInstallParams(hdi, NULL, &drid,
                        &drip);
            }
        }
    }

    if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
    {
        hr = S_OK;
    }

    TraceHr (ttidError, FAL, hr, FALSE, "SetBadDriverFlagIfNeededInList");
}

//+--------------------------------------------------------------------------
//
//  Function:   HrCiExcludeNonNetClassDriverFromSelectUsingInfId
//
//  Purpose: Locates a driver in a driver list and sets its exclude from
//              select flag.
//
//  Arguments:
//      hdi      [in] See Device Installer Api documentaion for details
//      pszInfId [in] The INF id of the component to exclude
//
//  Returns:    HRESULT. S_OK
//
//  Author:     billbe   29 Oct 1998
//
//  Notes:
//
HRESULT
HrCiExcludeNonNetClassDriverFromSelectUsingInfId(
    IN HDEVINFO hdi,
    IN PCWSTR pszInfId)
{
    Assert(IsValidHandle(hdi));
    Assert(pszInfId);

    HRESULT                 hr = S_OK;
    SP_DRVINSTALL_PARAMS    drip;
    SP_DRVINFO_DATA         drid;
    PSP_DRVINFO_DETAIL_DATA pdridd;
    DWORD                   dwIndex = 0;

    // Enumerate each driver in hdi
    while (S_OK == (hr = HrSetupDiEnumDriverInfo (hdi, NULL,
            SPDIT_CLASSDRIVER, dwIndex++, &drid)))
    {
        (VOID) HrSetupDiGetDriverInstallParams (hdi, NULL, &drid, &drip);

        // If the driver is already excluded for some other reason
        // don't bother trying to determine if it should be excluded.
        // Note that setupdi forces us to use DNF_BAD_DRIVER to exclude
        // non-device drivers rather than using DNF_EXCLUDEFROMLIST.
        if (drip.Flags & DNF_BAD_DRIVER)
        {
            continue;
        }

        // Get driver detail info
        hr = HrSetupDiGetDriverInfoDetail (hdi, NULL, &drid, &pdridd);

        if (S_OK == hr)
        {
            // If the IDs match, exclude it from the dialog
            //
            if (0 == lstrcmpiW (pdridd->HardwareID, pszInfId))
            {
                // Non-device drivers can't use DNF_EXCLUDEFROMLIST
                // and must use DNF_BAD_DRIVER.
                drip.Flags |= DNF_BAD_DRIVER;
                (VOID) HrSetupDiSetDriverInstallParams (hdi, NULL,
                        &drid, &drip);
            }
            MemFree (pdridd);
        }
    }

    if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
    {
        hr = S_OK;
    }

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

//+---------------------------------------------------------------------------
//
//  Function:   ExcludeLockedDownComponents
//
//  Purpose:    A callback function compatible with EnumLockedDownComponents
//              that is used to exclude locked down components from
//              selection.  Called from HrCiPrepareSelectDeviceDialog.
//              This call back is called for each locked down component.
//
//  Arguments:
//      pszInfId     [in] the INF ID to exclude.
//      pvCallerData [in] the HDEVINFO cast to PVOID
//
//  Returns:    nothing
//
//  Author:     shaunco   24 May 1999
//
//  Notes:      The callback interface was chosen so that the class installer
//              is not burdended with the details of how/where the locked
//              down components are implemented.
//
VOID
CALLBACK
ExcludeLockedDownComponents (
    IN PCWSTR pszInfId,
    IN PVOID pvCallerData)
{
    Assert (pszInfId && *pszInfId);
    Assert (pvCallerData);

    HDEVINFO hdi = (HDEVINFO)pvCallerData;

    HrCiExcludeNonNetClassDriverFromSelectUsingInfId (hdi, pszInfId);
}

//+--------------------------------------------------------------------------
//
//  Function:   HrCiBuildExcludedDriverList
//
//  Purpose: Non-Net class components can only be installed once
//              So we need to iterate through the installed
//              components, find their matching driver node in
//              a Device Installer Api built driver list for the class,
//              and set their exclude from select flag.  This list
//              will then be given to SetupDiSelectDevice which
//              will not display the nodes with the exclude flag set.
//
//  Arguments:
//      hdi       [in] See Device Installer Api documentaion for details
//      guidClass [in] The class of components to build a driver list for
//      pNetCfg   [out] The current network configuration (i.e. what is
//                      installed).
//
//  Returns:    HRESULT. S_OK
//
//  Author:     billbe   10 Dec 1996
//
//  Notes:  Device Installer Api builds the driver list by rummaging
//              through the inf directory and finding the components
//              that are in files with the same class guid as the
//              HDEVINFO.  This is the same processing done
//              in SetupDiSelectDevice, but the process is
//              not repeated twice because we will give the
//              list we built here to SetupDiSelectDevice.
//
HRESULT
HrCiBuildExcludedDriverList(
    IN HDEVINFO hdi,
    IN NETCLASS Class,
    IN CNetConfig* pNetConfig)
{
    HRESULT hr;

    Assert(IsValidHandle(hdi));
    Assert(pNetConfig);

    // This might take some time.  We are doing the same work as
    // SetupDiSelectDevice would do. When we are done, we will
    // hand the driver list to SetupDiSelectDevice so it won't
    // need to rummage through the inf directory
    //
    CWaitCursor wc;

    // For non-device classes, we need to allow excluded drivers
    // in order to get a list returned.
    hr = HrSetupDiSetDeipFlags(hdi, NULL,
                    DI_FLAGSEX_ALLOWEXCLUDEDDRVS,
                    SDDFT_FLAGSEX, SDFBO_OR);

    if (S_OK == hr)
    {
#ifdef ENABLETRACE
        CBenchmark bmrk;
        bmrk.Start("SetupDiBuildDriverInfoList");
#endif //ENABLETRACE

        hr = HrSetupDiBuildDriverInfoList(hdi, NULL, SPDIT_CLASSDRIVER);

#ifdef ENABLETRACE
        bmrk.Stop();
        TraceTag(ttidBenchmark, "%s : %s seconds",
                bmrk.SznDescription(), bmrk.SznBenchmarkSeconds(2));
#endif //ENABLETRACE
    }

    // Go through the network configuration and hide already installed
    // components.  Note: We only do this the first time.  We show installed
    // components if the user selects Have Disk on the dialog.
    CComponent* pComponent;
    CComponentList::const_iterator iter;

    for (iter  = pNetConfig->Core.Components.begin();
         iter != pNetConfig->Core.Components.end();
         iter++)
    {
        pComponent = *iter;
        Assert (pComponent);

        if (Class == pComponent->Class())
        {
            // Hide the driver
            hr = HrCiExcludeNonNetClassDriverFromSelectUsingInfId(
                    hdi, pComponent->m_pszInfId);
        }
    }

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


//+--------------------------------------------------------------------------
//
//  Function:   HrCiSelectComponent
//
//  Purpose:    This function displays the Select Device dialog for the
//              class of components specified by guidClass.  Once the
//              component has been selected, it is installed.. Since
//              this fcn is called from INetCfg, we have the write lock.
//
//  Arguments:
//      Class           [in] The class of components to display in the
//                              Select Device dialog
//      hwndParent      [in] The HWND of the parent window, used to display
//                              the UI
//      pcfi            [in] A structure used to determine what
//                              components should be filtered out of
//                              the select dialog (defined in netcfg.h)
//      ppParams        [out] Params used to install the component.
//
//  Returns:    HRESULT. S_OK if successful, S_FALSE if the component
//                        selected is being reinstalled instead of fresh
//                        installed, an error code otherwise
//
//  Author:     billbe   11 Nov 1996
//
//  Notes:  Filtering is only performed when selecting protocols,
//              services, and clients.
//
HRESULT
HrCiSelectComponent(
    IN NETCLASS Class,
    IN HWND hwndParent,
    IN const CI_FILTER_INFO* pcfi,
    OUT COMPONENT_INSTALL_PARAMS** ppParams)
{
    Assert (ppParams);
    Assert (!FIsEnumerated (Class));

    HRESULT hr;
    HDEVINFO hdi;

    // We need to create a DeviceInfoSet item to use the SelectDevice dialog.
    hr = HrSetupDiCreateDeviceInfoList(
            MAP_NETCLASS_TO_GUID[Class], hwndParent, &hdi);

    if (S_OK == hr)
    {
        // call the class installer to bring up the select device dialog
        // for enumerated components.  This will notify any coinstallers
        //

        // This will be a map of component ids to instance guids
        // for all installed components of Class.
        CNetConfig NetConfig;
        hr = HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig);
        if (S_OK == hr)
        {
            hr = HrCiBuildExcludedDriverList (hdi, Class, &NetConfig);
        }

        if (S_OK == hr)
        {
            // Store the filter info in the hdi
            CiSetReservedField(hdi, NULL, pcfi);

            // We want the Have disk button, but if the call fails we can
            // still continue
            (VOID) HrSetupDiSetDeipFlags(hdi, NULL, DI_SHOWOEM,
                                         SDDFT_FLAGS, SDFBO_OR);

            // Bring up the dialog
            hr = HrSetupDiCallClassInstaller(DIF_SELECTDEVICE, hdi, NULL);

            if (S_OK == hr)
            {
                SP_DRVINFO_DATA drid;
                PSP_DRVINFO_DETAIL_DATA pdridd;

                // Now get the driver's detailed information
                hr = HrCiGetDriverDetail (hdi, NULL, &drid, &pdridd);

                if (S_OK == hr)
                {
                    DWORD cbInfId = CbOfSzAndTerm(pdridd->HardwareID);
                    DWORD cbInfFile = CbOfSzAndTerm(pdridd->InfFileName);

                    // Create a component install params structure so we
                    // can install the component.
                    hr = E_OUTOFMEMORY;
                    *ppParams = new (extrabytes, cbInfId + cbInfFile)
                            COMPONENT_INSTALL_PARAMS;

                    if (*ppParams)
                    {
                        ZeroMemory (*ppParams,
                                sizeof (COMPONENT_INSTALL_PARAMS));

                        (*ppParams)->Class = Class;
                        (*ppParams)->hwndParent = hwndParent;
                        (*ppParams)->pszInfId = (PCWSTR)(*ppParams + 1);
                        wcscpy ((PWSTR)(*ppParams)->pszInfId,
                                pdridd->HardwareID);

                        (*ppParams)->pszInfFile =
                                (PCWSTR)((BYTE*)(*ppParams)->pszInfId +
                                         cbInfId);

                        wcscpy ((PWSTR)(*ppParams)->pszInfFile,
                                pdridd->InfFileName);

                        hr = S_OK;
                    }
                    MemFree (pdridd);
                }
            }

            // Clear the field so we don't try to destroy it later
            // via DIF_DESTROYPRIVATEDATA
            CiClearReservedField(hdi, NULL);
        }
        SetupDiDestroyDeviceInfoList(hdi);
    }

    TraceHr (ttidError, FAL, hr, HRESULT_FROM_WIN32(ERROR_CANCELLED) == hr,
            "HrCiSelectComponent");
    return hr;
}


//+--------------------------------------------------------------------------
//
//  Function:   HrCiHideIrrelevantRasProtocols
//
//  Purpose:    Hides protocols from the SelectDevice dialog that RAS does
//                  not interact with.
//
//  Arguments:
//      hdi        [in] Contains a list of available drivers.
//                          See Device Installer Api documentation for
//                          more info
//      eFilter    [in] Either FC_RASSRV or FC_RASCLI.
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   18 May 1998
//
//  Notes:
//
HRESULT
HrCiHideIrrelevantRasProtocols (
    IN HDEVINFO hdi,
    IN CI_FILTER_COMPONENT eFilter)
{
    DWORD                   dwIndex = 0;
    SP_DRVINFO_DATA         drid;
    SP_DRVINSTALL_PARAMS    drip;
    PSP_DRVINFO_DETAIL_DATA pdridd;
    HRESULT                 hr;

    extern const WCHAR c_szInfId_MS_AppleTalk[];
    extern const WCHAR c_szInfId_MS_NetMon[];
    extern const WCHAR c_szInfId_MS_NWIPX[];
    extern const WCHAR c_szInfId_MS_TCPIP[];

    static const WCHAR* const c_aszServerProtocols[] = {
        c_szInfId_MS_AppleTalk,
        c_szInfId_MS_NetMon,
        c_szInfId_MS_NWIPX,
        c_szInfId_MS_TCPIP
    };

    static const WCHAR* const c_aszClientProtocols[] = {
        c_szInfId_MS_NetMon,
        c_szInfId_MS_NWIPX,
        c_szInfId_MS_TCPIP
    };

    Assert ((FC_RASSRV == eFilter) || (FC_RASCLI == eFilter));

    const WCHAR* const* aszProtocols;
    DWORD cProtocols;

    // What we show as available protocols to install differs between
    // ras server and ras client (aka Incoming connectoid and Dial-up).
    //
    if (FC_RASSRV == eFilter)
    {
        aszProtocols = c_aszServerProtocols;
        cProtocols = celems(c_aszServerProtocols);

    }
    else
    {
        aszProtocols = c_aszClientProtocols;
        cProtocols = celems(c_aszClientProtocols);
    }

    // Enumerate each driver in hdi
    while (S_OK == (hr = HrSetupDiEnumDriverInfo(hdi, NULL,
            SPDIT_CLASSDRIVER, dwIndex++, &drid)))
    {
        (VOID) HrSetupDiGetDriverInstallParams(hdi, NULL, &drid, &drip);

        // If the driver is already excluded for some other reason
        // don't bother trying to determine if it should be excluded
        // Note that setupdi forces us to use DNF_BAD_DRIVER to exclude
        // non-device drivers rather than using DNF_EXCLUDEFROMLIST.
        if (drip.Flags & DNF_BAD_DRIVER)
        {
            continue;
        }

        // Get driver detail info
        hr = HrSetupDiGetDriverInfoDetail(hdi, NULL, &drid, &pdridd);

        if (S_OK == hr)
        {
            // go through the list of relevant protocols to find which
            // ones can be shown
            //

            // Assume we are going to hide this protocol
            BOOL fHideProtocol = TRUE;
            for (DWORD i = 0; i < cProtocols; i++)
            {
                // If the protocol is on the guest list, we won't boot
                // it out
                //
                if (0 == _wcsicmp(aszProtocols[i], pdridd->HardwareID))
                {
                    fHideProtocol = FALSE;
                }
            }

            if (fHideProtocol)
            {
                // exclude from select
                // Note that setupdi forces us to use DNF_BAD_DRIVER to
                // exclude non-device drivers rather than using
                // DNF_EXCLUDEFROMLIST.
                drip.Flags |= DNF_BAD_DRIVER;
                (VOID) HrSetupDiSetDriverInstallParams(hdi, NULL,
                        &drid, &drip);
            }
            MemFree (pdridd);
        }
    }

    if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
    {
        hr = S_OK;
    }

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

//+--------------------------------------------------------------------------
//
//  Function:   HrCiHideIrrelevantDrivers
//
//  Purpose:    Enumerates a driver list, opening each driver file and
//                  processing its registry entries into a temporary key.
//                  The lower range of each driver is then examined for
//                  a match with pszUpperRange.  If no match is
//                  found, the driver's DNF_BAD_DRIVER flag is set
//                  which will prevent it from being shown in the
//                  Select Device Dialog
//
//  Arguments:
//      hdi           [in] Contains a list of available drivers.
//                          See Device Installer Api documentation for
//                          more info
//      pszUpperRange [in] The upper range will be used to hide irrelevant
//                         drivers.
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   7 May 1998
//
//  Notes:
//
HRESULT
HrCiHideIrrelevantDrivers(
    IN HDEVINFO hdi,
    IN PCWSTR pszUpperRange)
{
    Assert(IsValidHandle(hdi));
    Assert(pszUpperRange);

    static const WCHAR c_szRegKeyTemp[] =
            L"System\\CurrentControlSet\\Control\\Network\\FTempKey";

    // Create a temporary key so we can process each protocol's
    // registry entries in an effort to get its supported
    // lower range of interfaces
    HKEY hkeyTemp;
    HRESULT hr = HrRegCreateKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyTemp,
            REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
            &hkeyTemp, NULL);

    if (S_OK == hr)
    {
        DWORD                   dwIndex = 0;
        SP_DRVINFO_DATA         drid;
        SP_DRVINSTALL_PARAMS    drip;
        HKEY                    hkeyInterfaces;

        // Enumerate each driver in hdi
        while (S_OK == (hr = HrSetupDiEnumDriverInfo(hdi, NULL,
                SPDIT_CLASSDRIVER, dwIndex++, &drid)))
        {
            (VOID) HrSetupDiGetDriverInstallParams(hdi, NULL, &drid, &drip);

            // If the driver is already excluded for some other reason
            // don't bother trying to determine if it should be exluded.
            // Note that setupdi forces us to use DNF_BAD_DRIVER to exclude
            // non-device drivers rather than using DNF_EXCLUDEFROMLIST.
            if (drip.Flags & DNF_BAD_DRIVER)
            {
                continue;
            }

            // Get driver detail info
            PSP_DRVINFO_DETAIL_DATA pdridd = NULL;
            hr = HrSetupDiGetDriverInfoDetail(hdi, NULL, &drid, &pdridd);

            if (S_OK == hr)
            {
                HINF hinf = NULL;
                // Open the driver inf
                hr = HrSetupOpenInfFile(pdridd->InfFileName,
                        NULL, INF_STYLE_WIN4, NULL, &hinf);

                WCHAR szActual[_MAX_PATH];
                if (S_OK == hr)
                {
                    // Get the actual install section name (i.e. with
                    // os/platform extension if it exists)
                    hr = HrSetupDiGetActualSectionToInstallWithBuffer (hinf,
                            pdridd->SectionName, szActual, _MAX_PATH, NULL,
                            NULL);

                    if (S_OK == hr)
                    {
                        // Run the registry sections into the temporary key
                        hr = HrCiInstallFromInfSection(hinf, szActual,
                                hkeyTemp, NULL, SPINST_REGISTRY);
                    }
                }

                if (S_OK == hr)
                {
                    // Open the interfaces key of the driver
                    hr = HrRegOpenKeyEx(hkeyTemp, L"Ndi\\Interfaces",
                            KEY_ALL_ACCESS, &hkeyInterfaces);

                    if (S_OK == hr)
                    {
                        PWSTR pszLowerRange = NULL;

                        // Read the lower interfaces value.
                        //
                        hr = HrRegQuerySzWithAlloc (hkeyInterfaces,
                                L"LowerRange", &pszLowerRange);

                        // If we succeeded in reading the list and
                        // there is no match with one of the upper
                        // interfaces...
                        if ((S_OK == hr) &&
                                !FSubstringMatch (pszUpperRange,
                                        pszLowerRange, NULL, NULL))
                        {
                            // exclude from select
                            drip.Flags |= DNF_BAD_DRIVER;
                            (VOID) HrSetupDiSetDriverInstallParams(hdi,
                                    NULL, &drid, &drip);
                        }

                        // Clear lower interface list for next component
                        MemFree(pszLowerRange);

                        RegDeleteValue (hkeyInterfaces, L"LowerRange");
                        RegCloseKey(hkeyInterfaces);
                    }
                }
                SetupCloseInfFileSafe(hinf);
                MemFree (pdridd);
            }
        }

        if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
        {
            hr = S_OK;
        }

        RegCloseKey(hkeyTemp);
        HrRegDeleteKeyTree(HKEY_LOCAL_MACHINE, c_szRegKeyTemp);
    }

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


//+--------------------------------------------------------------------------
//
//  Function:   HrCiSetSelectDeviceDialogStrings
//
//  Purpose:    This function sets the strings displayed in the Select Device
//                  dialog based on the class of devices being selected.
//
//  Arguments:
//      hdi         [in] See Device Installer Api
//      pdeid       [in]
//      guidClass   [in] The class of device being selected
//
//  Returns:    HRESULT. S_OK if successful, an error code otherwise
//
//  Author:     billbe   11 Nov 1996
//
//  Notes:
//
HRESULT
HrCiSetSelectDeviceDialogStrings(
    IN HDEVINFO hdi,
    IN PSP_DEVINFO_DATA pdeid,
    IN const GUID& guidClass)
{
    Assert(IsValidHandle(hdi));

    SP_SELECTDEVICE_PARAMS  sdep;

    // The strings used in the dialog are specified through the
    // SP_SELECTDEVICE_PARAMS structure
    //
    HRESULT hr = HrSetupDiGetFixedSizeClassInstallParams(hdi, pdeid,
           (PSP_CLASSINSTALL_HEADER)&sdep, sizeof(sdep));

    if (FAILED(hr))
    {
        // If the error is ERROR_NO_CLASSINSTALL_PARAMS then this function
        // didn't really fail since it is possible
        if (SPAPI_E_NO_CLASSINSTALL_PARAMS == hr)
        {
            hr = S_OK;
        }
    }
    else if (DIF_SELECTDEVICE != sdep.ClassInstallHeader.InstallFunction)
    {
        TraceTag(ttidClassInst, "Incorrect function in Class Install Header "
                 "Expected DIF_SELECTDEVICE, got %lX",
                 sdep.ClassInstallHeader.InstallFunction);
    }


    BOOL fHaveDiskShown = FALSE;
    if (S_OK == hr)
    {
        // Get the install params and check if the DI_SHOWOEM flag is set
        // if so, the Have Disk button will be shown
        //
        SP_DEVINSTALL_PARAMS deip;
        // If the call fails we can still go on unfazed.
        (VOID) HrSetupDiGetDeviceInstallParams(hdi, pdeid, &deip);
        if (deip.Flags & DI_SHOWOEM)
        {
            fHaveDiskShown = TRUE;
        }

        // Now we set the strings based on the type of component we are
        // selecting
        if (GUID_DEVCLASS_NETCLIENT == guidClass)
        {
            wcscpy (sdep.Title, SzLoadIds (IDS_SELECTDEVICECLIENTTITLE));

            wcscpy (sdep.ListLabel,
                    SzLoadIds (IDS_SELECTDEVICECLIENTLISTLABEL));

            wcscpy (sdep.Instructions,
                    SzLoadIds (IDS_SELECTDEVICECLIENTINSTRUCTIONS));

        }
        else if (GUID_DEVCLASS_NETSERVICE == guidClass)
        {
            wcscpy (sdep.Title, SzLoadIds (IDS_SELECTDEVICESERVICETITLE));

            wcscpy (sdep.ListLabel,
                    SzLoadIds (IDS_SELECTDEVICESERVICELISTLABEL));

            wcscpy (sdep.Instructions,
                    SzLoadIds (IDS_SELECTDEVICESERVICEINSTRUCTIONS));

        }
        else if (GUID_DEVCLASS_NETTRANS == guidClass)
        {
            wcscpy (sdep.Title, SzLoadIds (IDS_SELECTDEVICEPROTOCOLTITLE));

            wcscpy (sdep.ListLabel,
                    SzLoadIds (IDS_SELECTDEVICEPROTOCOLLISTLABEL));

            wcscpy (sdep.Instructions,
                SzLoadIds (IDS_SELECTDEVICEPROTOCOLINSTRUCTIONS));
        }
        else if (GUID_DEVCLASS_NET == guidClass)
        {
            wcscpy (sdep.Title, SzLoadIds (IDS_SELECTDEVICEADAPTERTITLE));

            wcscpy (sdep.SubTitle,
                    SzLoadIds (IDS_SELECTDEVICEADAPTERSUBTITLE));

            wcscpy (sdep.ListLabel,
                    SzLoadIds (IDS_SELECTDEVICEADAPTERLISTLABEL));

            wcscpy (sdep.Instructions,
                    SzLoadIds (IDS_SELECTDEVICEADAPTERINSTRUCTIONS));
        }
        else if (GUID_DEVCLASS_INFRARED == guidClass)
        {
            wcscpy (sdep.Title, SzLoadIds (IDS_SELECTDEVICEINFRAREDTITLE));

            wcscpy (sdep.SubTitle,
                    SzLoadIds (IDS_SELECTDEVICEINFRAREDSUBTITLE));

            wcscpy (sdep.ListLabel,
                    SzLoadIds (IDS_SELECTDEVICEINFRAREDLISTLABEL));

            wcscpy (sdep.Instructions,
                    SzLoadIds (IDS_SELECTDEVICEINFRAREDINSTRUCTIONS));
        }
        else
        {
            // We should never get here
            AssertSz(FALSE, "Invalid Class");
        }

        // If the Have Disk button is shown, we need to add instructions for
        // it
        if (fHaveDiskShown)
        {
            wcscat (sdep.Instructions, SzLoadIds (IDS_HAVEDISK_INSTRUCTIONS));
        }

        sdep.ClassInstallHeader.InstallFunction = DIF_SELECTDEVICE;

        // Now we update the parameters.
        hr = HrSetupDiSetClassInstallParams (hdi, pdeid,
                (PSP_CLASSINSTALL_HEADER)&sdep,
                sizeof(SP_SELECTDEVICE_PARAMS));
    }

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


//+--------------------------------------------------------------------------
//
//  Function:   HrCiPrepareSelectDeviceDialog
//
//  Purpose:    Sets the strings that will appear in the Select Device
//                  dialog based on class type.  Also, filters out components
//                  based on filtering criteria (note: only for non-net
//                  class components
//
//  Arguments:
//      hdi    [in] See Device Installer Api documentation for more info
//      pdeid  [in]
//
//  Returns:    HRESULT. S_OK if successful, error code otherwise
//
//  Author:     billbe   26 Jun 1997
//
//  Notes:
//
HRESULT
HrCiPrepareSelectDeviceDialog(
    IN HDEVINFO hdi,
    IN PSP_DEVINFO_DATA pdeid)
{
    Assert(IsValidHandle(hdi));

    GUID                guidClass;
    CI_FILTER_INFO*     pcfi;
    HRESULT             hr = S_OK;
    static const WCHAR  c_szNetwareInfId[] = L"MS_NwClient";
    static const WCHAR  c_szQosInfId[] = L"MS_PSched";

    if (pdeid)
    {
        // Get the class guid from the specified device element
        guidClass = pdeid->ClassGuid;
    }
    else
    {
        // otherwise, get it from the hdi
        hr = HrSetupDiGetDeviceInfoListClass (hdi, &guidClass);
    }

    if ((S_OK == hr) && !FIsEnumerated (guidClass))
    {
        // This might take some time.  We are doing the same work as
        // SetupDiSelectDevice would do. When we are done, we will
        // hand the driver list to SetupDiSelectDevice so it won't
        // need to rummage through the inf directory
        //
        CWaitCursor wc;

        // For non-device classes, we need to allow excluded drivers
        // in order to get a list returned.
        hr = HrSetupDiSetDeipFlags(hdi, NULL,
                        DI_FLAGSEX_ALLOWEXCLUDEDDRVS,
                        SDDFT_FLAGSEX, SDFBO_OR);

        if (S_OK == hr)
        {
    #ifdef ENABLETRACE
            CBenchmark bmrk;
            bmrk.Start("SetupDiBuildDriverInfoList");
    #endif //ENABLETRACE

            // If we have already built a driver list, this will return
            // immediately.
            //
            hr = HrSetupDiBuildDriverInfoList(hdi, NULL, SPDIT_CLASSDRIVER);

    #ifdef ENABLETRACE
            bmrk.Stop();
            TraceTag(ttidBenchmark, "%s : %s seconds",
                    bmrk.SznDescription(), bmrk.SznBenchmarkSeconds(2));
    #endif //ENABLETRACE
        }

        if (S_OK == hr)
        {
            // Go through every driver node and set DNF_BAD_DRIVER
            // if DNF_EXCLUDEFROMLIST is set. Note: SetupDi forces us
            // to do this for non netclass driver lists.
            SetBadDriverFlagIfNeededInList(hdi);

            // Exclude components that are in lockdown.
            //
            EnumLockedDownComponents (ExcludeLockedDownComponents, hdi);

            SP_DEVINSTALL_PARAMS deip;
            hr = HrSetupDiGetDeviceInstallParams (hdi, pdeid, &deip);

            if (S_OK == hr)
            {
                pcfi = (CI_FILTER_INFO*)deip.ClassInstallReserved;

                // if filter info was present and we are selecting protocols...
                if (pcfi)
                {
                    if (GUID_DEVCLASS_NETTRANS == guidClass)
                    {
                        // If the filter is for lan or atm and pvReserved is
                        // not null...
                        if (((FC_LAN == pcfi->eFilter) ||
                                (FC_ATM == pcfi->eFilter))
                             && pcfi->pvReserved)
                        {
                            // Hide any drivers that can't bind to pvReserved
                            hr = HrCiHideIrrelevantDrivers(hdi,
                                    (PCWSTR)pcfi->pvReserved);

                        }
                        else if ((FC_RASSRV == pcfi->eFilter) ||
                                (FC_RASCLI == pcfi->eFilter))
                        {
                            // Hide from the select dialog any protocols RAS does
                            // not support
                            hr = HrCiHideIrrelevantRasProtocols (hdi,
                                    pcfi->eFilter);
                        }
                    }
                    else if ((GUID_DEVCLASS_NETCLIENT == guidClass) &&
                            (FC_ATM == pcfi->eFilter))
                    {
                        // ATM adapters don't bind to Netware Client so
                        // we need to try to hide it from the dialog
                        (VOID) HrCiExcludeNonNetClassDriverFromSelectUsingInfId(
                                hdi, c_szNetwareInfId);
                    }
                    else if ((GUID_DEVCLASS_NETSERVICE == guidClass) &&
                             (FC_ATM == pcfi->eFilter))
                    {
                        // ATM adapters don't bind to QoS so try to hide it
                        (VOID) HrCiExcludeNonNetClassDriverFromSelectUsingInfId(
                                hdi, c_szQosInfId);
                    }
                }
            }
        }
    }

    if (S_OK == hr)
    {

        // Set the strings for the Select Device dialog.
        // This is done by changing the parameters in the DeviceInfoSet.
        // The next call will create this InfoSet
        // If the call fails, we can still go on, we'll just have
        // slightly odd descriptions in the dialog.  This is done after
        // the section above because strings change based on the existence
        // of the Have Disk button
        (VOID) HrCiSetSelectDeviceDialogStrings(hdi, pdeid, guidClass);

        // Now we need to indicate that we created a class install params
        // header in the structures and set the select device dialog strings
        // in it.  If the call fails, we can still proceed though the
        // dialog will appear a bit strange
        (VOID) HrSetupDiSetDeipFlags(hdi, pdeid,
                              DI_USECI_SELECTSTRINGS | DI_CLASSINSTALLPARAMS,
                              SDDFT_FLAGS, SDFBO_OR);
    }


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

HRESULT
HrCiInstallFilterDevice (
    IN HDEVINFO hdi,
    IN PCWSTR pszInfId,
    IN CComponent* pAdapter,
    IN CComponent* pFilter,
    IN CFilterDevice** ppFilterDevice)
{
    HRESULT hr;
    SP_DEVINFO_DATA deid;

    Assert (hdi);
    Assert (pszInfId && *pszInfId);
    Assert (pAdapter);
    Assert (FIsEnumerated(pAdapter->Class()));
    Assert (pFilter);
    Assert (pFilter->FIsFilter());
    Assert (NC_NETSERVICE == pFilter->Class());
    Assert (ppFilterDevice);

    *ppFilterDevice = NULL;

    // Initialize the devinfo data corresponding to the driver the
    // caller wants us to install.
    //
    hr = HrCiGetDriverInfo (hdi, &deid, *MAP_NETCLASS_TO_GUID[NC_NET],
            pszInfId, NULL);

    if (S_OK == hr)
    {
        ADAPTER_OUT_PARAMS AdapterOutParams;

        ZeroMemory (&AdapterOutParams, sizeof(AdapterOutParams));

        CiSetReservedField (hdi, &deid, &AdapterOutParams);

        // Perform the installation.
        //
        hr = HrCiCallClassInstallerToInstallComponent (hdi, &deid);

        CiClearReservedField (hdi, &deid);

        if (S_OK == hr)
        {
            WCHAR szInstanceGuid[c_cchGuidWithTerm];
            INT cch;
            HKEY hkeyInstance;

            // Convert the instance guid to a string.
            //
            cch = StringFromGUID2 (
                    AdapterOutParams.InstanceGuid,
                    szInstanceGuid,
                    c_cchGuidWithTerm);
            Assert (c_cchGuidWithTerm == cch);

            // Open the instance key of the newly installed device
            // so we can write the instance guid and the back pointer
            // to the filter.
            //
            hr = HrSetupDiOpenDevRegKey (hdi, &deid,
                    DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_WRITE,
                    &hkeyInstance);

            if (S_OK == hr)
            {
                // Write the instance guid.
                //
                hr = HrRegSetSz (hkeyInstance, L"NetCfgInstanceId",
                        szInstanceGuid);

                // Write the inf id of the parent filter.
                //
                hr = HrRegSetSz (hkeyInstance, L"FilterInfId",
                        pFilter->m_pszInfId);

                RegCloseKey (hkeyInstance);
            }

            // Set the friendly name to include the adapter being
            // filtered.
            //
            if (S_OK == hr)
            {
                PWSTR pszFilterDesc;

                hr = HrSetupDiGetDeviceRegistryPropertyWithAlloc (
                        hdi, &deid, SPDRP_DEVICEDESC,
                        NULL, (BYTE**)&pszFilterDesc);

                if (S_OK == hr)
                {
                    #define SZ_NAME_SEP L" - "

                    PWSTR pszName;
                    ULONG cb;

                    // sizeof(SZ_NAME_SEP) includes the NULL-terminator
                    // so that will automatically add room for the
                    // NULL-terminator we need to allocate for pszName.
                    //
                    cb = CbOfSzSafe (pAdapter->Ext.PszDescription()) +
                         sizeof(SZ_NAME_SEP) +
                         CbOfSzSafe (pszFilterDesc);

                    pszName = (PWSTR)MemAlloc (cb);
                    if (pszName)
                    {
                        wcscpy (pszName, pAdapter->Ext.PszDescription());
                        wcscat (pszName, SZ_NAME_SEP);
                        wcscat (pszName, pszFilterDesc);

                        Assert (cb == CbOfSzAndTerm(pszName));

                        hr = HrSetupDiSetDeviceRegistryProperty (
                                hdi, &deid,
                                SPDRP_FRIENDLYNAME,
                                (const BYTE*)pszName,
                                cb);

                        MemFree (pszName);
                    }

                    MemFree (pszFilterDesc);
                }

                // If the above fails, its not a big deal.
                //
                hr = S_OK;
            }

            if (S_OK == hr)
            {
                hr = CFilterDevice::HrCreateInstance (
                        pAdapter,
                        pFilter,
                        &deid,
                        szInstanceGuid,
                        ppFilterDevice);
            }
        }
    }

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

HRESULT
HrCiRemoveFilterDevice (
    IN HDEVINFO hdi,
    IN SP_DEVINFO_DATA* pdeid)
{
    HRESULT hr;
    ADAPTER_REMOVE_PARAMS arp = {0};

    Assert (hdi);
    Assert (pdeid);

    CiSetReservedField (hdi, pdeid, &arp);

    hr = HrSetupDiCallClassInstaller (DIF_REMOVE, hdi, pdeid);

    CiClearReservedField (hdi, pdeid);

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