You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3457 lines
115 KiB
3457 lines
115 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// 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};
|
|
|
|
// The temporary key used for dumping a component's registry entries. This is used
|
|
// during the pruning of inapplicable protocols and filter services from the select
|
|
// dialog.
|
|
static const WCHAR c_szRegKeyTemp[] =
|
|
L"System\\CurrentControlSet\\Control\\Network\\FTempKey";
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
// 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 = (DWORD)(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);
|
|
|
|
// 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: HrCiHideIrrelevantFilterServices
|
|
//
|
|
// Purpose: Enumerates a driver list, opening each driver file and
|
|
// processing its registry entries into a temporary key.
|
|
// Only filter services are filtered here. If the component is
|
|
// a filter service (characteristics|NCF_FILTER)
|
|
// the FilterMediaTypes and the LowerExclude attributes are examined
|
|
// to see if the filter service can bind to the adapter. The filter
|
|
// services which cannot bind to the adapter are culled from
|
|
// the select dialog
|
|
//
|
|
// Arguments:
|
|
// hdi [in] Contains a list of available drivers.
|
|
// See Device Installer Api documentation for
|
|
// more info
|
|
// pAdapter [in] Pointer to a CComponent object representing the
|
|
// adapter for which filter services are to be hidden.
|
|
//
|
|
// Returns: HRESULT. S_OK if successful, error code otherwise
|
|
//
|
|
// Author: sumeetb October 17, 2001
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrCiHideIrrelevantFilterServices(
|
|
IN HDEVINFO hdi,
|
|
IN const CComponent * const pAdapter)
|
|
{
|
|
Assert(IsValidHandle(hdi));
|
|
Assert(pAdapter);
|
|
|
|
// Create a temporary key so we can process each filter's
|
|
// registry entries in an effort to get its FilterMediaTypes and
|
|
// LowerExclude attributes
|
|
|
|
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)))
|
|
{
|
|
BOOL fCanBind = TRUE;
|
|
|
|
(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
|
|
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);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
WCHAR szActual[_MAX_PATH];
|
|
// 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)
|
|
{
|
|
DWORD dwCharacteristics = 0;
|
|
|
|
hr = HrSetupGetFirstDword (hinf, szActual,
|
|
L"Characteristics", &dwCharacteristics);
|
|
|
|
if (S_OK == hr )
|
|
{
|
|
if (dwCharacteristics & NCF_FILTER)
|
|
{
|
|
// it is a filter.
|
|
// Run the registry sections into the temporary key
|
|
hr = HrCiInstallFromInfSection(hinf, szActual,
|
|
hkeyTemp, NULL, SPINST_REGISTRY);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrRegOpenKeyEx(hkeyTemp, L"Ndi\\Interfaces",
|
|
KEY_ALL_ACCESS, &hkeyInterfaces);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
// check filter attributes - FilterMediaTypes and
|
|
// LowerExclude to see if the filter can bind to
|
|
// the adapter
|
|
|
|
PWSTR pszFilterMediaTypes = NULL;
|
|
PWSTR pszLowerExclude = NULL;
|
|
|
|
(VOID) HrRegQuerySzWithAlloc (hkeyInterfaces,
|
|
L"FilterMediaTypes", &pszFilterMediaTypes);
|
|
(VOID) HrRegQuerySzWithAlloc (hkeyInterfaces,
|
|
L"LowerExclude", &pszLowerExclude);
|
|
|
|
fCanBind = pAdapter->FCanDirectlyBindToFilter(
|
|
pszFilterMediaTypes,
|
|
pszLowerExclude);
|
|
|
|
MemFree(pszFilterMediaTypes);
|
|
MemFree(pszLowerExclude);
|
|
|
|
// clean up the relevant keys from the
|
|
// registry for the filter
|
|
RegDeleteValue (hkeyInterfaces, L"FilterMediaTypes");
|
|
RegDeleteValue (hkeyInterfaces, L"LowerExclude");
|
|
RegCloseKey(hkeyInterfaces);
|
|
} // end open Interface key
|
|
} // end install from inf section
|
|
} // end if filter
|
|
} // end get Characteristics
|
|
} // end get actual install section.
|
|
SetupCloseInfFileSafe(hinf);
|
|
} // end open inf file
|
|
|
|
if (!fCanBind)
|
|
{
|
|
drip.Flags |= DNF_BAD_DRIVER;
|
|
(VOID) HrSetupDiSetDriverInstallParams(hdi, NULL, &drid, &drip);
|
|
}
|
|
MemFree (pdridd);
|
|
} // end get driver detail
|
|
} // end while
|
|
|
|
if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
RegCloseKey(hkeyTemp);
|
|
HrRegDeleteKeyTree(HKEY_LOCAL_MACHINE, c_szRegKeyTemp);
|
|
} // end create temp key
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrCiHideIrrelevantFilterServices");
|
|
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)((CComponent *)pcfi->pvReserved)->Ext.PszUpperRange());
|
|
|
|
}
|
|
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) &&
|
|
(pcfi->pvReserved))
|
|
{
|
|
// Hide any filters that can't bind to this adapter
|
|
hr = HrCiHideIrrelevantFilterServices(hdi,
|
|
(CComponent *)pcfi->pvReserved);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|