|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1999.
//
// File: F I L T D E V S . C P P
//
// Contents: Implements the basic datatype for a collection of filter
// devices.
//
// Notes:
//
// Author: shaunco 15 Jan 1999
//
//----------------------------------------------------------------------------
#include <pch.h>
#pragma hdrstop
#include "classinst.h"
#include "filtdevs.h"
#include "nceh.h"
#include "ncreg.h"
#include "ncstl.h"
#include "ncsetup.h"
CFilterDevices::CFilterDevices ( IN CNetConfigCore* pCore){ Assert (pCore);
ZeroMemory (this, sizeof(*this));
m_pCore = pCore;}
CFilterDevices::~CFilterDevices (){ // Free had better have been called before this.
//
Assert (this); Assert (!m_hdi); Assert (!m_pmszFilterClasses); Assert (empty());}
HRESULTCFilterDevices::HrInsertFilterDevice ( IN CFilterDevice* pDevice){ HRESULT hr;
Assert (this); Assert (pDevice);
// Assert there is not already a device in the list with the
// same instance guid.
//
Assert (!PFindFilterDeviceByInstanceGuid (pDevice->m_szInstanceGuid));
// Assert there is not already a device in the list with the
// same parent filter AND the same filtered adapter.
//
Assert (!PFindFilterDeviceByAdapterAndFilter ( pDevice->m_pAdapter, pDevice->m_pFilter));
NC_TRY { push_back (pDevice); hr = S_OK; } NC_CATCH_BAD_ALLOC { hr = E_OUTOFMEMORY; }
TraceHr (ttidError, FAL, hr, FALSE, "CFilterDevices::HrInsertFilterDevice"); return hr;}
HRESULTCFilterDevices::HrPrepare (){ HRESULT hr; HKEY hkeyNetwork;
// Reserve room for 8 different filters in our internal member.
// We use this component list at various times as "scratch space" when
// figuring out which filters are enabled for an adapter.
//
hr = m_Filters.HrReserveRoomForComponents (8); if (S_OK != hr) { goto finished; }
hr = m_BindPathsToRebind.HrReserveRoomForBindPaths (8); if (S_OK != hr) { goto finished; }
// Load the FilterClasses multi-sz.
//
hr = HrOpenNetworkKey (KEY_READ, &hkeyNetwork);
if (S_OK == hr) { hr = HrRegQueryMultiSzWithAlloc ( hkeyNetwork, L"FilterClasses", &m_pmszFilterClasses);
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) { Assert (!m_pmszFilterClasses); hr = S_OK; }
RegCloseKey (hkeyNetwork); }
finished:
TraceHr (ttidError, FAL, hr, FALSE, "CFilterDevices::HrPrepare"); return hr;}
CFilterDevice*CFilterDevices::PFindFilterDeviceByAdapterAndFilter ( IN const CComponent* pAdapter, IN const CComponent* pFilter) const{ const_iterator iter; CFilterDevice* pDevice;
Assert (this); Assert (pAdapter); Assert (pFilter); Assert (FIsEnumerated(pAdapter->Class())); Assert (NC_NETSERVICE == pFilter->Class()); Assert (pFilter->FIsFilter());
for (iter = begin(); iter != end(); iter++) { pDevice = *iter; Assert (pDevice);
if ((pAdapter == pDevice->m_pAdapter) && (pFilter == pDevice->m_pFilter)) { return pDevice; } }
return NULL;}
DWORDCFilterDevices::MapFilterClassToOrdinal ( IN PCWSTR pszFilterClass){ DWORD Ordinal; DWORD dwIndex; DWORD cStrings;
Assert (pszFilterClass);#if DBG
Ordinal = 0;#endif
// If the class is found in the list, return its position.
//
if (FGetSzPositionInMultiSzSafe ( pszFilterClass, m_pmszFilterClasses, &dwIndex, NULL, &cStrings)) { Ordinal = dwIndex + 1; } else { HRESULT hr; PWSTR pmszNew; BOOL fChanged;
// We're adding another string, so compute the new ordinal value
// for return.
//
Ordinal = cStrings + 1;
// String was not found, so we append it at the end.
// It is important to insert at the end so we don't have to
// change the ordinals of any existing filters that already
// had their ordinal computed.
//
hr = HrAddSzToMultiSz (pszFilterClass, m_pmszFilterClasses, STRING_FLAG_ENSURE_AT_END, 0, &pmszNew, &fChanged);
if (S_OK == hr) { HKEY hkeyNetwork;
// It better have changed because we didn't find the string
// above.
//
Assert (fChanged);
// Out with the old. In with the new.
//
MemFree (m_pmszFilterClasses); m_pmszFilterClasses = pmszNew;
// Save it back to the registry.
//
hr = HrOpenNetworkKey (KEY_WRITE, &hkeyNetwork);
if (S_OK == hr) { hr = HrRegSetMultiSz ( hkeyNetwork, L"FilterClasses", m_pmszFilterClasses);
Assert (S_OK == hr);
RegCloseKey (hkeyNetwork); } } }
// By definition, Ordinal is 1-based. This is so that when stored
// in CComponent, we know we have to load the filter class and get
// its ordinal if CComponent::FilterClassOrdinal is zero. i.e. zero
// is a sentinel value that means we need to do work and when non-zero
// means we don't have to do that work again.
//
Assert (Ordinal != 0); return Ordinal;}
CFilterDevice*CFilterDevices::PFindFilterDeviceByInstanceGuid ( IN PCWSTR pszInstanceGuid) const{ const_iterator iter; CFilterDevice* pDevice;
Assert (this); Assert (pszInstanceGuid && *pszInstanceGuid);
for (iter = begin(); iter != end(); iter++) { pDevice = *iter; Assert (pDevice);
if (0 == wcscmp(pszInstanceGuid, pDevice->m_szInstanceGuid)) { return pDevice; } }
return NULL;}
HRESULTCFilterDevices::HrLoadFilterDevice ( IN SP_DEVINFO_DATA* pdeid, IN HKEY hkeyInstance, IN PCWSTR pszFilterInfId, OUT BOOL* pfRemove){ HRESULT hr; CComponent* pAdapter; CComponent* pFilter; WCHAR szInstanceGuid [c_cchGuidWithTerm]; DWORD cbBuffer;
Assert (pszFilterInfId && *pszFilterInfId); Assert (pfRemove);
*pfRemove = FALSE;
// Initialize these to NULL. If we don't find them below, they will
// remain NULL and this will tell us something.
//
pAdapter = NULL; pFilter = NULL;
cbBuffer = sizeof(szInstanceGuid); hr = HrRegQuerySzBuffer ( hkeyInstance, L"NetCfgInstanceId", szInstanceGuid, &cbBuffer);
if (S_OK == hr) { HKEY hkeyLinkage;
// Read the RootDevice registry value for this filter device. The
// last entry in that multi-sz will be the bindname of the adapter
// being filtered.
//
hr = HrRegOpenKeyEx ( hkeyInstance, L"Linkage", KEY_READ, &hkeyLinkage);
if (S_OK == hr) { PWSTR pmszRootDevice;
hr = HrRegQueryMultiSzWithAlloc ( hkeyLinkage, L"RootDevice", &pmszRootDevice);
if (S_OK == hr) { PCWSTR pszScan; PCWSTR pszLastDevice = NULL;
// Scan to the last string in the multi-sz and note it.
//
for (pszScan = pmszRootDevice; *pszScan; pszScan += wcslen(pszScan) + 1) { pszLastDevice = pszScan; }
// The last string in the multi-sz is the bindname of the
// adapter being filtered.
//
if (pszLastDevice) { pAdapter = m_pCore->Components.PFindComponentByBindName ( NC_NET, pszLastDevice); if (!pAdapter) { hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND); } }
MemFree (pmszRootDevice); }
RegCloseKey (hkeyLinkage); }
if (S_OK == hr) { // Should have the adapter if no error.
//
Assert (pAdapter);
// Get the enabled filters for the adapter.
//
hr = m_pCore->HrGetFiltersEnabledForAdapter (pAdapter, &m_Filters); if (S_OK == hr) { // Use pszFilterInfId to find the parent filter component for
// this filter device. If it is not found, it probably means
// the entire filter is in the process of being removed.
// (Or the registry was messed with.)
//
pFilter = m_pCore->Components.PFindComponentByInfId ( pszFilterInfId, NULL);
// If the filter corresponding to this device is still
// installed and is enabled over the adapter, then we'll
// insert the device into our list. Otherwise, we're going
// to remove it.
//
if (pFilter && m_Filters.FComponentInList (pFilter)) { CFilterDevice* pFilterDevice;
// Create an instance of the filter device class to
// represent this filter device.
//
hr = CFilterDevice::HrCreateInstance ( pAdapter, pFilter, pdeid, szInstanceGuid, &pFilterDevice);
if (S_OK == hr) { // Add the filter device to our list of filter devices.
//
hr = HrInsertFilterDevice (pFilterDevice);
if (S_OK != hr) { delete pFilterDevice; } } } else { *pfRemove = TRUE;
Assert (pszFilterInfId && *pszFilterInfId); Assert (pAdapter);
g_pDiagCtx->Printf (ttidBeDiag, " Removing filter device for %S over %S adapter\n", pszFilterInfId, pAdapter->m_pszPnpId);
// Since we will be removing a filter device from the
// chain, we need to rebind the protocols above the
// adapter we are removing the filter device for.
//
// So, get the upper bindings of the adapter (bindpaths
// are only 2 levels deep) and add them to the bind set
// that we will rebind later on.
//
hr = m_pCore->HrGetComponentUpperBindings ( pAdapter, GBF_ADD_TO_BINDSET | GBF_PRUNE_DISABLED_BINDINGS, &m_BindPathsToRebind); } } } }
TraceHr (ttidError, FAL, hr, HRESULT_FROM_WIN32(ERROR_NOT_FOUND) == hr, "CFilterDevices::HrLoadFilterDevice"); return hr;}
VOIDCFilterDevices::LoadAndRemoveFilterDevicesIfNeeded (){ HRESULT hr; SP_DEVINFO_DATA deid; DWORD dwIndex; DWORD cbBuffer; WCHAR szFilterInfId [_MAX_PATH];
Assert (this); Assert (m_pCore); Assert (!m_hdi); Assert (empty());
// Filter devices can only be of net class.
//
hr = HrSetupDiGetClassDevs (&GUID_DEVCLASS_NET, NULL, NULL, DIGCF_PROFILE, &m_hdi);
if (S_OK != hr) { return; }
Assert (m_hdi);
// Enumerate all net class devices from setupapi.
//
for (dwIndex = 0; S_OK == hr; dwIndex++) { hr = HrSetupDiEnumDeviceInfo (m_hdi, dwIndex, &deid);
if (S_OK == hr) { HKEY hkeyInstance;
hr = HrSetupDiOpenDevRegKey ( m_hdi, &deid, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ, &hkeyInstance);
if (S_OK == hr) { // If the device has a "FilterInfId" value under its
// instance key, its one of ours.
//
cbBuffer = sizeof(szFilterInfId); hr = HrRegQuerySzBuffer ( hkeyInstance, L"FilterInfId", szFilterInfId, &cbBuffer);
if (S_OK == hr) { BOOL fRemove;
// Load the rest of the filter device, and add it to
// our list. If this fails for any reason, remove the
// filter device because its of no use to us anymore.
//
hr = HrLoadFilterDevice ( &deid, hkeyInstance, szFilterInfId, &fRemove);
if ((S_OK != hr) || fRemove) { if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, " Removing filter device for %S\n", szFilterInfId); }
(VOID) HrCiRemoveFilterDevice (m_hdi, &deid); hr = S_OK; } }
//else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
//{
// Not a filter device. Skip it.
//}
RegCloseKey (hkeyInstance); }
// Allow the loop to continue;
//
hr = S_OK; } } if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) { hr = S_OK; }
g_pDiagCtx->Printf (ttidBeDiag, " Loaded %d filter devices\n", size());}
VOIDCFilterDevices::InstallFilterDevicesIfNeeded (){ HRESULT hr; CComponentList::iterator iterAdapter; CComponentList::iterator iterFilter; CComponent* pAdapter; CComponent* pFilter; HKEY hkeyInstance; HKEY hkeyNdi; DWORD cbBuffer; BOOL fAddDevice; BOOL fAddedDeviceForAdapter; WCHAR szFilterDeviceInfId [_MAX_PATH]; WCHAR szFilterClass [_MAX_PATH];
Assert (this); Assert (m_pCore);
// If, for some reason, we couldn't get m_hdi up in
// RemoveFilterDevicesIfNeeded, we can't proceed.
//
if (!m_hdi) { return; }
// For all adapters (because filters possibly bind to any adapter)
// we get the filters enabled for each. For each on of these filters
// that don't already have an associated filter device for the adapter,
// we create a new one and associated it.
//
for (iterAdapter = m_pCore->Components.begin(); iterAdapter != m_pCore->Components.end(); iterAdapter++) { pAdapter = *iterAdapter; Assert (pAdapter);
// Skip components that are not network adapters.
//
if (NC_NET != pAdapter->Class()) { continue; }
hr = m_pCore->HrGetFiltersEnabledForAdapter (pAdapter, &m_Filters);
if (S_OK != hr) { // More than likely, we are out of memory.
//
TraceHr (ttidError, FAL, hr, FALSE, "HrGetFiltersEnabledForAdapter failed in " "InstallFilterDevicesIfNeeded. Adapter=%S", pAdapter->m_pszPnpId); break; }
// We haven't yet added any devices for this adapter.
//
fAddedDeviceForAdapter = FALSE;
// For each of the filters enabled for this adapter, install
// a filter device if needed and make sure the filter has its
// ordinal position with respect other filters read from the
// registry. We need m_dwFilterClassOrdinal to be valid (non-zero)
// before we sort the filter devices when writing their bindings.
//
for (iterFilter = m_Filters.begin(); iterFilter != m_Filters.end(); iterFilter++) { pFilter = *iterFilter; Assert (pFilter);
// If there isn't a filter device for the current adapter
// and filter, we need to install one.
//
fAddDevice = !PFindFilterDeviceByAdapterAndFilter ( pAdapter, pFilter);
// If we don't need to add a filter device and we already
// have the ordinal position of the filter, we can continue with
// the next filter for this adapter.
//
if (!fAddDevice && (0 != pFilter->m_dwFilterClassOrdinal)) { continue; }
*szFilterDeviceInfId = 0;
// Open the instance key of the filter so we can read
// a few values.
//
hr = pFilter->HrOpenInstanceKey (KEY_READ, &hkeyInstance, NULL, NULL);
if (S_OK == hr) { // Open the Ndi key.
//
hr = HrRegOpenKeyEx (hkeyInstance, L"Ndi", KEY_READ, &hkeyNdi);
if (S_OK == hr) { if (0 == pFilter->m_dwFilterClassOrdinal) { // Read the filter class and convert it to an
// ordinal based on its position in the
// filter classes list.
//
cbBuffer = sizeof(szFilterClass);
hr = HrRegQuerySzBuffer (hkeyNdi, L"FilterClass", szFilterClass, &cbBuffer);
if (S_OK == hr) { pFilter->m_dwFilterClassOrdinal = MapFilterClassToOrdinal (szFilterClass); } }
if (fAddDevice) { // Read the ind id of the filter device.
//
cbBuffer = sizeof(szFilterDeviceInfId);
hr = HrRegQuerySzBuffer ( hkeyNdi, L"FilterDeviceInfId", szFilterDeviceInfId, &cbBuffer); }
RegCloseKey (hkeyNdi); }
RegCloseKey (hkeyInstance); }
if ((S_OK == hr) && fAddDevice) { CFilterDevice* pFilterDevice;
Assert (*szFilterDeviceInfId);
g_pDiagCtx->Printf (ttidBeDiag, " Installing filter device for %S over %S adapter\n", pFilter->m_pszInfId, pAdapter->m_pszPnpId);
hr = HrCiInstallFilterDevice (m_hdi, szFilterDeviceInfId, pAdapter, pFilter, &pFilterDevice);
if (S_OK == hr) { hr = HrInsertFilterDevice (pFilterDevice); if (S_OK == hr) { fAddedDeviceForAdapter = TRUE; } else { delete pFilterDevice; } } } }
// If we added at least one filter device in the chain for this
// adapter, we'll need to unbind the adapter from whatever it is
// currently bound to before we start the filter device.
//
if (fAddedDeviceForAdapter) { // So, get the upper bindings of the adapter (bindpaths
// are only 2 levels deep) and add them to the bind set
// that we will rebind later on.
//
hr = m_pCore->HrGetComponentUpperBindings ( pAdapter, GBF_ADD_TO_BINDSET | GBF_PRUNE_DISABLED_BINDINGS, &m_BindPathsToRebind); } }}
INT__cdeclCompareFilterDevices ( const VOID* pv1, const VOID* pv2){ CFilterDevice* pDevice1 = *((CFilterDevice**)pv1); CFilterDevice* pDevice2 = *((CFilterDevice**)pv2);
if (pDevice1->m_pAdapter == pDevice2->m_pAdapter) { Assert (pDevice1->m_pFilter != pDevice2->m_pFilter);
if (pDevice1->m_pFilter->m_dwFilterClassOrdinal == pDevice2->m_pFilter->m_dwFilterClassOrdinal) { AssertSz (0, "We have two filters of the same class installed."); return 0; }
return (pDevice1->m_pFilter->m_dwFilterClassOrdinal < pDevice2->m_pFilter->m_dwFilterClassOrdinal) ? -1 : 1; }
return (pDevice1->m_pAdapter < pDevice2->m_pAdapter) ? -1 : 1;
/*
if (pDevice1->m_pFilter == pDevice2->m_pFilter) { Assert (pDevice1->m_pAdapter != pDevice2->m_pAdapter);
return (pDevice1->m_pAdapter < pDevice2->m_pAdapter) ? -1 : 1; }
if (pDevice1->m_pFilter->m_dwFilterClassOrdinal == pDevice2->m_pFilter->m_dwFilterClassOrdinal) { AssertSz (0, "We have two filters of the same class installed."); return 0; }
return (pDevice1->m_pFilter->m_dwFilterClassOrdinal < pDevice2->m_pFilter->m_dwFilterClassOrdinal) ? -1 : 1;*/}
VOIDCFilterDevices::SortForWritingBindings (){ Assert (this);
// If we're empty, there is nothing to do.
//
if (empty()) { return; }
qsort (begin(), size(), sizeof(CFilterDevice*), CompareFilterDevices);}
VOIDCFilterDevices::StartFilterDevices (){ HRESULT hr; CFilterDevices::reverse_iterator iter; CFilterDevice* pDevice;
Assert (this); Assert (m_pCore);
// If we're empty, there is nothing to do.
//
if (empty()) { return; }
// If we're not empty, we must have had m_hdi to insert something.
//
Assert (m_hdi);
for (iter = rbegin(); iter != rend(); iter++) { pDevice = *iter; Assert (pDevice);
g_pDiagCtx->Printf (ttidBeDiag, " %S filter over %S adapter\n", pDevice->m_pFilter->m_pszInfId, pDevice->m_pAdapter->m_pszPnpId);
hr = HrSetupDiSendPropertyChangeNotification ( m_hdi, &pDevice->m_deid, DICS_START, DICS_FLAG_CONFIGSPECIFIC, 0);
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, " Failed to start filter device for " "%S over %S adapter\n", pDevice->m_pFilter->m_pszInfId, pDevice->m_pAdapter->m_pszPnpId); } }}
VOIDCFilterDevices::Free (){ Assert (this);
MemFree (m_pmszFilterClasses); m_pmszFilterClasses = NULL;
SetupDiDestroyDeviceInfoListSafe (m_hdi); m_hdi = NULL;
FreeCollectionAndItem (*this);
// Do NOT free m_BindPathsToRebind. This is used even after ApplyChanges
// calls Free.
//
}
|
