|
|
#include <pch.h>
#pragma hdrstop
#include "persist.h"
#include "ncreg.h"
#include "ncsetup.h"
#include "util.h"
HRESULT HrAddOrRemoveWinsockDependancy( IN HINF hinfInstallFile, IN PCWSTR pszSectionName);
HRESULTHrLoadAndAddComponentFromInstanceKey ( IN HKEY hkey, IN const GUID* pInstanceGuid, IN NETCLASS Class, IN PCWSTR pszPnpId OPTIONAL, IN OUT CNetConfig* pNetConfig){ HRESULT hr; BASIC_COMPONENT_DATA Data; CComponent* pComponent; WCHAR szInfId [_MAX_PATH]; WCHAR szMiniportId [_MAX_PATH]; ULONG cbInfId;
Assert (hkey); Assert (pInstanceGuid); Assert (FIsValidNetClass (Class)); Assert (FImplies(pszPnpId, *pszPnpId)); Assert (pNetConfig);
ZeroMemory (&Data, sizeof(Data));
hr = HrRegQueryDword (hkey, L"Characteristics", &Data.dwCharacter); if (S_OK == hr) { // If the component is a filter, copy Ndi\MiniportId to
// Ndi\FilterDeviceInfId.
//
if (Data.dwCharacter & NCF_FILTER) { HKEY hkeyNdi;
hr = HrRegOpenKeyEx ( hkey, L"Ndi", KEY_READ | KEY_WRITE, &hkeyNdi);
if (S_OK == hr) { HKEY hkeyInterfaces; DWORD cbMiniportId = sizeof(szMiniportId);
hr = HrRegQuerySzBuffer ( hkeyNdi, L"MiniportId", szMiniportId, &cbMiniportId);
if (S_OK == hr) { (VOID) HrRegSetSz ( hkeyNdi, L"FilterDeviceInfId", szMiniportId); }
if (FInSystemSetup()) { // Need to update LowerExclude for filters (the only one
// being PSched) so we prevent PSched from binding to
// every adapter on the machine. This only needs to
// happen during GUI setup and when we detect no Config
// binary because this happens way before INFs get re-run.)
//
hr = HrRegOpenKeyEx ( hkeyNdi, L"Interfaces", KEY_WRITE, &hkeyInterfaces);
if (S_OK == hr) { (VOID) HrRegSetSz ( hkeyInterfaces, L"LowerExclude", L"ndiscowan, ndiswan, ndiswanasync, " L"ndiswanipx, ndiswannbf");
RegCloseKey (hkeyInterfaces); } }
RegCloseKey (hkeyNdi); hr = S_OK; } }
cbInfId = sizeof(szInfId); hr = HrRegQuerySzBuffer (hkey, L"ComponentId", szInfId, &cbInfId); if (S_OK == hr) { // Wanarp needs its refcounts key deleted in case we are
// loaded before netupgrd.inf is run.
//
if (0 == _wcsicmp(L"ms_wanarp", szInfId)) { (VOID)HrRegDeleteKey (hkey, L"RefCounts"); }
Data.InstanceGuid = *pInstanceGuid; Data.Class = Class; Data.pszInfId = szInfId; Data.pszPnpId = pszPnpId;
// It is important to make sure we can load the external data
// for two reasons:
// 1) If we have a failure reading critical data that we
// need in order to function, we want to know about it
// now, before we add it to the component list.
// 2) For filter devices which will be subsequently upgraded,
// we need to search for specific components by BindForm
// and BindName which are external data loaded by the
// following call.
//
hr = CComponent::HrCreateInstance ( &Data, CCI_ENSURE_EXTERNAL_DATA_LOADED, NULL, &pComponent); if (S_OK == hr) { // Add the component and the stack entries, but don't
// send any notifications to notify objects.
//
hr = pNetConfig->Core.HrAddComponentToCore ( pComponent, INS_SORTED); } } }
TraceHr (ttidError, FAL, hr, FALSE, "HrLoadAndAddComponentFromInstanceKey"); return hr;}
BOOLFUpgradeFilterDeviceInstanceKey ( IN CNetConfig* pNetConfig, IN HKEY hkeyInstance, IN PCWSTR pszFilterName){ CComponent* pFilter;
// The new binding engine uses FilterInfId located in under the instance
// key instead of FilterName under Ndi.
//
pFilter = pNetConfig->Core.Components.PFindComponentByBindForm ( NC_NETSERVICE, pszFilterName);
if (pFilter) { (VOID) HrRegSetSz (hkeyInstance, L"FilterInfId", pFilter->m_pszInfId);
return TRUE; } return FALSE;}
HRESULTHrLoadComponentReferencesFromLegacy ( IN OUT CNetConfig* pNetConfig){ HRESULT hr = S_OK; CComponentList::iterator iter; CComponent* pComponent; HKEY hkeyInstance;
Assert (pNetConfig);
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
hr = pComponent->HrOpenInstanceKey (KEY_READ, &hkeyInstance, NULL, NULL);
if (S_OK == hr) { HKEY hkeyRefCounts;
hr = HrRegOpenKeyEx (hkeyInstance, L"RefCounts", KEY_READ, &hkeyRefCounts);
if (S_OK == hr) { DWORD dwIndex; WCHAR szValueName [_MAX_PATH]; DWORD cchValueName; DWORD dwType; DWORD dwRefCount; DWORD cbData; CComponent* pRefdByComponent; GUID InstanceGuid;
for (dwIndex = 0; S_OK == hr; dwIndex++) { cchValueName = celems(szValueName); cbData = sizeof(dwRefCount);
hr = HrRegEnumValue (hkeyRefCounts, dwIndex, szValueName, &cchValueName, &dwType, (LPBYTE)&dwRefCount, &cbData);
if (S_OK == hr) { if (0 == _wcsicmp (L"User", szValueName)) { hr = pComponent->Refs.HrAddReferenceByUser (); } else if ((L'{' == *szValueName) && (S_OK == IIDFromString (szValueName, &InstanceGuid)) && (NULL != (pRefdByComponent = pNetConfig->Core.Components.PFindComponentByInstanceGuid(&InstanceGuid)))) { hr = pComponent->Refs.HrAddReferenceByComponent ( pRefdByComponent); } else if (NULL != (pRefdByComponent = pNetConfig-> Core.Components.PFindComponentByInfId ( szValueName, NULL))) { hr = pComponent->Refs.HrAddReferenceByComponent ( pRefdByComponent); } else { hr = pComponent->Refs.HrAddReferenceBySoftware ( szValueName); } } } if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) { hr = S_OK; }
RegCloseKey (hkeyRefCounts); }
RegCloseKey (hkeyInstance); } }
// If the instance key or the refcounts key don't exist, there is not
// much we can do about it. Don't fail for these reasons.
//
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) { hr = S_OK; }
TraceHr (ttidError, FAL, hr, FALSE, "HrLoadComponentReferencesFromLegacy"); return hr;}
VOIDUpgradeConnection ( IN const GUID& InstanceGuid, IN PCWSTR pszPnpId){ HRESULT hr; WCHAR szPath[_MAX_PATH]; HKEY hkeyConn;
Assert (pszPnpId && *pszPnpId);
// Connections uses a pnp id value as their back pointer to the pnp
// tree.
//
CreateInstanceKeyPath (NC_NET, InstanceGuid, szPath); wcscat (szPath, L"\\Connection"); hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, szPath, KEY_READ_WRITE, &hkeyConn);
if (S_OK == hr) { HrRegSetSz (hkeyConn, L"PnpInstanceId", pszPnpId); }
RegCloseKey(hkeyConn);}
HRESULTHrLoadNetworkConfigurationFromLegacy ( OUT CNetConfig* pNetConfig){ HRESULT hr; NETCLASS Class; PCWSTR pszSubtree; HKEY hkeySubtree; DWORD dwIndex; HKEY hkeyInstance; GUID InstanceGuid; UINT PassNumber;
// Get the value for whether WAN adapters comes first or last in
// adapter order. We need to give this to the stack table so it will
// know which way to order things.
//
Assert (FALSE == pNetConfig->Core.StackTable.m_fWanAdaptersFirst);
hr = HrOpenNetworkKey ( KEY_READ, &hkeySubtree);
if (S_OK == hr) { DWORD dwValue;
hr = HrRegQueryDword (hkeySubtree, L"WanAdaptersFirst", &dwValue);
if (S_OK == hr) { pNetConfig->Core.StackTable.m_fWanAdaptersFirst = !!dwValue; }
RegCloseKey (hkeySubtree); }
// We need two passes to correctly upgrade everything. Since filter
// devices reference an adapter, we need to have already read the
// information for all adapters before we can read information about
// a filter device and create a memory representation for it which
// references the memory representation of the adapter which it filters.
//
// The following structure should make this more clear. For each
// element in this array, we enumerate components in the specified
// class. Note that NC_NET is reference twice -- once for pass one
// and once for pass two. The code below uses the pass number to
// know whether it should be ignoring filter devices (in pass one)
// or ignoring adapters (in pass two, because they were already handled
// in pass one.) If it isn't clear by now, don't touch this code. ;-)
//
static const struct { NETCLASS Class; UINT PassNumber; } aPassInfo [] = { { NC_NET, 1 }, { NC_INFRARED, 1 }, { NC_NETTRANS, 1 }, { NC_NETCLIENT, 1 }, { NC_NETSERVICE, 1 }, { NC_NET, 2 }, };
for (UINT i = 0; i < celems(aPassInfo); i++) { Class = aPassInfo[i].Class; PassNumber = aPassInfo[i].PassNumber;
Assert (FIsValidNetClass(Class));
pszSubtree = MAP_NETCLASS_TO_NETWORK_SUBTREE[Class];
if (!FIsEnumerated (Class)) { hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, pszSubtree, KEY_READ, &hkeySubtree);
if (S_OK == hr) { DWORD cchGuid; WCHAR szInstanceGuid [c_cchGuidWithTerm]; FILETIME ftLastWrite;
for (dwIndex = 0; S_OK == hr; dwIndex++) { cchGuid = celems(szInstanceGuid);
hr = HrRegEnumKeyEx ( hkeySubtree, dwIndex, szInstanceGuid, &cchGuid, NULL, NULL, &ftLastWrite);
if ((S_OK == hr) && ((c_cchGuidWithTerm-1) == cchGuid)) { hr = IIDFromString (szInstanceGuid, &InstanceGuid); if (S_OK == hr) { hr = HrRegOpenKeyEx ( hkeySubtree, szInstanceGuid, KEY_READ, &hkeyInstance);
if (S_OK == hr) { hr = HrLoadAndAddComponentFromInstanceKey ( hkeyInstance, &InstanceGuid, Class, NULL, pNetConfig);
RegCloseKey (hkeyInstance); } } else { // Delete the key?
}
// Ignore any errors during the loop
hr = S_OK; } } if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) { hr = S_OK; }
RegCloseKey (hkeySubtree); } } else { HDEVINFO hdi;
hr = HrSetupDiGetClassDevs (MAP_NETCLASS_TO_GUID[Class], NULL, NULL, DIGCF_PROFILE, &hdi);
if (S_OK == hr) { SP_DEVINFO_DATA deid; WCHAR szPnpId [2 * _MAX_PATH]; WCHAR szFilterName [_MAX_PATH]; BOOL fr;
for (dwIndex = 0; S_OK == hr; dwIndex++) { hr = HrSetupDiEnumDeviceInfo (hdi, dwIndex, &deid);
if (S_OK == hr) { fr = SetupDiGetDeviceInstanceId ( hdi, &deid, szPnpId, celems(szPnpId), NULL);
if (fr) { // We open with KEY_WRITE because we will be
// adding a new value to filter devices we
// upgrade.
//
hr = HrSetupDiOpenDevRegKey ( hdi, &deid, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_WRITE | KEY_READ, &hkeyInstance);
if (S_OK == hr) { LONG lr; ULONG cbGuid = sizeof(GUID);
lr = RegQueryGuid ( hkeyInstance, L"NetCfgInstanceId", &InstanceGuid, &cbGuid);
if (!lr) { BOOL fIsFilterDevice; HKEY hkeyNdi;
fIsFilterDevice = FALSE;
hr = HrRegOpenKeyEx ( hkeyInstance, L"Ndi", KEY_READ, &hkeyNdi);
if (S_OK == hr) { DWORD cbFilterName = sizeof(szFilterName);
hr = HrRegQuerySzBuffer ( hkeyNdi, L"FilterName", szFilterName, &cbFilterName);
if (S_OK == hr) { fIsFilterDevice = TRUE; }
RegCloseKey (hkeyNdi); }
// If it's a filter device, ignore it in
// pass one and handle it in pass two.
//
if (fIsFilterDevice && (2 == PassNumber)) { FUpgradeFilterDeviceInstanceKey ( pNetConfig, hkeyInstance, szFilterName); }
// If it's not a filter device, handle it
// in pass one and ignore it in pass two.
//
else if (!fIsFilterDevice && (1 == PassNumber)) { UpgradeConnection (InstanceGuid, szPnpId);
hr = HrLoadAndAddComponentFromInstanceKey ( hkeyInstance, &InstanceGuid, Class, szPnpId, pNetConfig); } }
RegCloseKey (hkeyInstance); } }
// Ignore any errors during the loop
hr = S_OK; } } if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) { hr = S_OK; }
SetupDiDestroyDeviceInfoList (hdi); } } }
if (S_OK == hr) { hr = HrLoadComponentReferencesFromLegacy (pNetConfig); }
if (S_OK == hr) { CComponentList::iterator iter; CComponent* pComponent; CBindPath BindPath; CBindingSet BindSet; HKEY hkeyParent; HKEY hkeyDisabled;
// Upgrade disabled bindings.
//
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
// Open the parent of the linkage key depending on what type
// of component this is.
//
if (FIsEnumerated (pComponent->Class()) || !pComponent->FHasService()) { hr = pComponent->HrOpenInstanceKey (KEY_READ, &hkeyParent, NULL, NULL); } else { hr = pComponent->HrOpenServiceKey (KEY_READ, &hkeyParent); }
// Open the Linkage\Disabled key.
//
if (S_OK == hr) { hr = HrRegOpenKeyEx (hkeyParent, L"Linkage\\Disabled", KEY_READ, &hkeyDisabled);
if (S_OK == hr) { PWSTR pmszBindPath;
hr = HrRegQueryMultiSzWithAlloc ( hkeyDisabled, L"BindPath", &pmszBindPath);
if (S_OK == hr) { PWSTR pszBindPath; PCWSTR pszBindName; PWSTR pszNext; CComponent* pOther;
// Get the components current bindings as they
// exist in the new engine. We won't disable
// any bindings that don't exist in this set.
//
(VOID) pNetConfig->Core.HrGetComponentBindings ( pComponent, GBF_DEFAULT, &BindSet);
// Iterate the multi-sz of disabled bindpaths.
//
for (pszBindPath = pmszBindPath; *pszBindPath; pszBindPath += wcslen(pszBindPath) + 1) { // The bindpath will start with this component
// that has the disabled bindings.
//
BindPath.Clear(); BindPath.HrAppendComponent (pComponent);
for (pszBindName = GetNextStringToken (pszBindPath, L"_", &pszNext); pszBindName && *pszBindName; pszBindName = GetNextStringToken (NULL, L"_", &pszNext)) { pOther = pNetConfig->Core.Components. PFindComponentByBindName ( NC_INVALID, pszBindName);
if (!pOther) { break; }
BindPath.HrAppendComponent (pOther); }
// If the bindpath is valid, disable it.
//
if (BindSet.FContainsBindPath (&BindPath)) { pNetConfig->Core.HrDisableBindPath (&BindPath); } }
MemFree (pmszBindPath); }
RegCloseKey (hkeyDisabled); }
RegCloseKey (hkeyParent); } }
// If we can't upgrade disabled bindings, no biggee.
//
hr = S_OK; }
TraceHr (ttidError, FAL, hr, FALSE, "HrLoadNetworkConfigurationFromLegacy"); return hr;}
|
