|
|
#include "pch.h"
#pragma hdrstop
#include "adapter.h"
#include "diag.h"
#include "inetcfg.h"
#include "lanamap.h"
#include "ncreg.h"
#include "ncsetup.h"
#include "netcfg.h"
#include "persist.h"
#include "util.h"
#include <conio.h> // _kbhit
//move to classinst.cpp
HRESULTHrCiDoCompleteSectionInstall( HINF hinfFile, HKEY hkeyRelative, PCWSTR szSection, HWND hwndParent, BOOL fEnumerated);
class CNetCfgInternalDiagnostic{public: static VOID DoCreateReleaseDiagnostic ( IN const DIAG_OPTIONS* pOptions, BOOL fPrime);
static VOID DoEnumAllDiagnostic ( IN const DIAG_OPTIONS* pOptions);
static VOID DoSaveLoadDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig);
static VOID DoWriteLockDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig);
static VOID CmdFullDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig);};
VOIDPromptForLeakCheck ( IN const DIAG_OPTIONS* pOptions, IN PCSTR psz){ if (pOptions->fLeakCheck) { g_pDiagCtx->Printf (ttidBeDiag, psz); while (!_kbhit()) { Sleep (50); } _getch (); g_pDiagCtx->Printf (ttidBeDiag, "\n"); }}
HRESULTHrCreateINetCfg ( IN BOOL fAcquireWriteLock, OUT CImplINetCfg** ppINetCfg){ HRESULT hr; CImplINetCfg* pINetCfg;
hr = CComCreator<CComObject <CImplINetCfg> >::CreateInstance( NULL, IID_INetCfg, (VOID**)&pINetCfg); if (S_OK == hr) { if (fAcquireWriteLock) { hr = pINetCfg->AcquireWriteLock (100, L"ncdiag", NULL);
if (S_FALSE == hr) { g_pDiagCtx->Printf (ttidBeDiag, "The write lock could not be acquired.\n"); } else if (NETCFG_E_NEED_REBOOT == hr) { g_pDiagCtx->Printf (ttidBeDiag, "A reboot is required before any futher " "changes can be made.\n"); } }
if (S_OK == hr) { hr = pINetCfg->Initialize (NULL); if (S_OK == hr) { *ppINetCfg = pINetCfg; } }
if (S_OK != hr) { ReleaseObj (pINetCfg->GetUnknown()); } } return hr;}
HRESULTHrFindBindPath ( IN CImplINetCfg* pINetCfg, IN PCWSTR pszPathToken, OUT INetCfgBindingPath** ppIPath, OUT INetCfgComponentBindings** ppIOwner){ HRESULT hr; const WCHAR szDelim[] = L"->"; WCHAR szBindPath [_MAX_PATH]; PCWSTR pszInfId; PWSTR pszNext; INetCfgComponent* pIComp;
*ppIPath = NULL;
if (ppIOwner) { *ppIOwner = NULL; }
wcscpy (szBindPath, pszPathToken); pszInfId = GetNextStringToken (szBindPath, szDelim, &pszNext);
hr = pINetCfg->FindComponent (pszInfId, &pIComp); if (S_OK == hr) { INetCfgComponentBindings* pIBind;
hr = pIComp->QueryInterface (IID_INetCfgComponentBindings, (VOID**)&pIBind); if (S_OK == hr) { IEnumNetCfgBindingPath* pIEnumPath;
hr = pIBind->EnumBindingPaths (EBP_BELOW, &pIEnumPath); if (S_OK == hr) { INetCfgBindingPath* rgIPath [256]; ULONG cIPath;
hr = pIEnumPath->Next (celems(rgIPath), rgIPath, &cIPath); if (SUCCEEDED(hr) && cIPath) { for (ULONG iPath = 0; (iPath < cIPath) && !(*ppIPath); iPath++) { PWSTR pszToken;
hr = rgIPath[iPath]->GetPathToken (&pszToken); if (S_OK == hr) { if (0 == wcscmp (pszPathToken, pszToken)) { AddRefObj (rgIPath[iPath]); *ppIPath = rgIPath[iPath];
if (ppIOwner) { INetCfgComponent* pICompOwner;
hr = rgIPath[0]->GetOwner(&pICompOwner); Assert (S_OK == hr);
pICompOwner->QueryInterface ( IID_INetCfgComponentBindings, (VOID**)ppIOwner);
ReleaseObj (pICompOwner); } } CoTaskMemFree (pszToken); } }
ReleaseIUnknownArray(cIPath, (IUnknown**)rgIPath); hr = S_OK; }
ReleaseObj (pIEnumPath); }
ReleaseObj (pIBind); }
ReleaseObj (pIComp); } else if (S_FALSE == hr) { hr = S_OK; }
return hr;}
// This test ensures proper circular reference behavior between CNetConfig
// and CImplINetCfg.
// The following is performed:
// create a CNetConfig and have it create its INetCfg for the notify objects.
// AddRef its INetCfg
// destroy the CNetConfig
// Try to Uninitialize the INetCfg which should fail because it never
// owned its internal CNetConfig pointer.
// Release the INetCfg and ensure that nothing is leaked.
//
VOIDCNetCfgInternalDiagnostic::DoCreateReleaseDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN BOOL fPrime){ HRESULT hr; CImplINetCfg* pINetCfg = NULL;
if (!fPrime) { PromptForLeakCheck (pOptions, "Create/Release diagnostic...(dump heap)"); }
// Scoping brackets so that NetConfig will be created and destroyed
// in this scope.
//
{ CNetConfig NetConfig;
hr = HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig); if (S_OK == hr) { // Shouldn't have internal INetCfg created yet.
//
Assert (!NetConfig.Notify.m_pINetCfg);
hr = NetConfig.Notify.HrEnsureNotifyObjectsInitialized (); if (S_OK == hr) { // Should now have internal INetCfg created.
//
Assert (NetConfig.Notify.m_pINetCfg); pINetCfg = NetConfig.Notify.m_pINetCfg;
// INetCfg should be pointing back to our CNetConfig object.
//
Assert (&NetConfig == pINetCfg->m_pNetConfig);
// Let's hang on to it and see what happens after we let
// the parent CNetConfig be destroyed.
//
pINetCfg = NetConfig.Notify.m_pINetCfg; AddRefObj (pINetCfg->GetUnknown()); } } }
if ((S_OK == hr) && pINetCfg) { // Now that CNetConfig is destroyed, it should not be pointing to
// any CNetConfig object.
//
Assert (!pINetCfg->m_pNetConfig);
hr = pINetCfg->Uninitialize(); Assert (NETCFG_E_NOT_INITIALIZED == hr);
ReleaseObj (pINetCfg->GetUnknown()); }
if (NETCFG_E_NOT_INITIALIZED == hr) { g_pDiagCtx->Printf (ttidBeDiag, "Passed Create/Release diagnostic.\n"); } else { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Create/Release diagnostic.\n"); }
if (!fPrime) { PromptForLeakCheck (pOptions, "Create/Release diagnostic...(dump heap and compare)"); }}
VOIDCNetCfgInternalDiagnostic::DoEnumAllDiagnostic ( IN const DIAG_OPTIONS* pOptions){ HRESULT hr; CImplINetCfg* pINetCfg;
PromptForLeakCheck (pOptions, "Enumerate All diagnostic...(dump heap)");
hr = HrCreateINetCfg (FALSE, &pINetCfg); if (S_OK == hr) { IEnumNetCfgComponent* pIEnum;
hr = pINetCfg->EnumComponents (NULL, &pIEnum); if (S_OK == hr) { INetCfgComponent* rgIComp[128]; ULONG cIComp;
hr = pIEnum->Next (celems(rgIComp), rgIComp, &cIComp); if (SUCCEEDED(hr) && cIComp) { INetCfgComponentBindings* pIBind; IEnumNetCfgBindingPath* pIEnumPath; INetCfgBindingPath* rgIPath[256]; PWSTR pszInfId; ULONG cIPath; ULONG cIPathTotal = 0; ULONG cIIntTotal = 0;
for (ULONG iComp = 0; iComp < cIComp; iComp++) { hr = rgIComp[iComp]->GetId (&pszInfId); if (S_OK == hr) { hr = (*pszInfId) ? S_OK : E_FAIL; if (S_OK != hr) { break; }
hr = rgIComp[iComp]->QueryInterface (IID_INetCfgComponentBindings, (VOID**)&pIBind); if (S_OK == hr) { hr = pIBind->EnumBindingPaths (EBP_BELOW, &pIEnumPath); if (S_OK == hr) { hr = pIEnumPath->Next (celems(rgIPath), rgIPath, &cIPath); if (SUCCEEDED(hr)) { for (ULONG iPath = 0; iPath < cIPath; iPath++) { ULONG ulDepth; hr = rgIPath[iPath]->GetDepth(&ulDepth); if (S_OK == hr) { IEnumNetCfgBindingInterface* pIEnumInt; INetCfgBindingInterface* rgIInt[128]; ULONG cIInt;
hr = rgIPath[iPath]->EnumBindingInterfaces (&pIEnumInt); if (S_OK == hr) { hr = pIEnumInt->Next (celems(rgIInt), rgIInt, &cIInt); if (SUCCEEDED(hr)) { cIIntTotal += cIInt; ReleaseIUnknownArray(cIInt, (IUnknown**)rgIInt); } else if (S_FALSE == hr) { hr = S_OK; }
ReleaseObj (pIEnumInt); } } }
cIPathTotal += cIPath; ReleaseIUnknownArray(cIPath, (IUnknown**)rgIPath); hr = S_OK; }
ReleaseObj (pIEnumPath); }
ReleaseObj (pIBind); }
CoTaskMemFree (pszInfId); }
if (S_OK != hr) { break; } }
ReleaseIUnknownArray(cIComp, (IUnknown**)rgIComp);
// Note: Total bindpaths are not total unique bindpaths.
// (A component's bindpaths which end in ms_ipx have
// ms_ipx's lower bindings added. These additional
// bindings are counted for every component which has
// bindpaths that end in ms_ipx.)
//
g_pDiagCtx->Printf (ttidBeDiag, "Passed Enumerate All diagnostic. (%d components, %d (non-unique) bindpaths, %d interfaces)\n", cIComp, cIPathTotal, cIIntTotal); } else if (S_FALSE == hr) { hr = S_OK; }
ReleaseObj (pIEnum); } HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Enumerate All diagnostic.\n"); }
PromptForLeakCheck (pOptions, "Enumerate All diagnostic...(dump heap and compare)");}
VOIDCNetCfgInternalDiagnostic::DoSaveLoadDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; BOOL fClearDisabledBindings = FALSE; CBindingSet BindingSet; CComponentList::iterator iter; CComponent* pComponent;
// Generate a full set of bindings so we test persisting them as
// disabled bindings, but only if we don't already have disabled
// bindings.
//
if (0 == pNetConfig->Core.DisabledBindings.CountBindPaths()) { fClearDisabledBindings = TRUE;
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
hr = pNetConfig->Core.HrGetComponentBindings ( pComponent, GBF_ADD_TO_BINDSET, &pNetConfig->Core.DisabledBindings); if (S_OK != hr) return; } }
PBYTE pbBuf; ULONG cbBuf;
hr = HrSaveNetworkConfigurationToBufferWithAlloc ( pNetConfig, &pbBuf, &cbBuf); if (S_OK == hr) { CNetConfig NetConfigCopy;
hr = HrLoadNetworkConfigurationFromBuffer ( pbBuf, cbBuf, &NetConfigCopy); if (S_OK == hr) { PBYTE pbBufCopy; ULONG cbBufCopy;
hr = HrSaveNetworkConfigurationToBufferWithAlloc ( &NetConfigCopy, &pbBufCopy, &cbBufCopy); if (S_OK == hr) { if ((cbBufCopy == cbBuf) && (0 == memcmp(pbBufCopy, pbBuf, cbBuf))) { g_pDiagCtx->Printf (ttidBeDiag, "Passed Save/Load diagnostic. (%d bytes)\n", cbBuf); } else { g_pDiagCtx->Printf (ttidBeDiag, "FAILED compare for Save/Load diagnostic.\n"); }
MemFree (pbBufCopy); } }
MemFree (pbBuf); }
// Leave the disabled bindings as we found them.
//
if (fClearDisabledBindings) { pNetConfig->Core.DisabledBindings.Clear(); }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Save/Load diagnostic.\n"); }}
VOIDCNetCfgInternalDiagnostic::DoWriteLockDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CImplINetCfg* pINetCfg; BOOL fFailed = FALSE;
PromptForLeakCheck (pOptions, "WriteLock diagnostic...(dump heap)");
hr = CComCreator<CComObject <CImplINetCfg> >::CreateInstance( NULL, IID_INetCfg, (VOID**)&pINetCfg); if (S_OK == hr) { PWSTR psz;
hr = pINetCfg->IsWriteLocked (&psz); if (S_FALSE != hr) fFailed = TRUE; if (psz) fFailed = TRUE;
hr = pINetCfg->AcquireWriteLock (100, L"ncdiag", &psz); if (S_OK != hr) fFailed = TRUE; if (psz) fFailed = TRUE;
if (S_OK == hr) { hr = pINetCfg->IsWriteLocked (&psz); if (S_OK != hr) fFailed = TRUE; if (!psz) fFailed = TRUE;
if (S_OK == hr) { if (0 != wcscmp(L"ncdiag", psz)) { fFailed = TRUE; } }
CoTaskMemFree (psz);
hr = pINetCfg->ReleaseWriteLock (); if (S_OK != hr) fFailed = TRUE;
hr = pINetCfg->IsWriteLocked (&psz); if (S_FALSE != hr) fFailed = TRUE; if (psz) fFailed = TRUE; }
ReleaseObj (pINetCfg->GetUnknown()); }
if (!fFailed) { PromptForLeakCheck (pOptions, "WriteLock diagnostic...(dump heap and compare)"); g_pDiagCtx->Printf (ttidBeDiag, "Passed WriteLock diagnostic.\n"); } else { g_pDiagCtx->Printf (ttidBeDiag, "FAILED WriteLock diagnostic.\n"); }}
VOIDCNetCfgInternalDiagnostic::CmdFullDiagnostic ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ DoCreateReleaseDiagnostic (pOptions, TRUE); if (pOptions->fLeakCheck) { DoCreateReleaseDiagnostic (pOptions, FALSE); }
DoEnumAllDiagnostic (pOptions);
DoSaveLoadDiagnostic (pOptions, pNetConfig);
DoWriteLockDiagnostic (pOptions, pNetConfig);}
VOIDCmdAddComponent ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CImplINetCfg* pINetCfg;
PromptForLeakCheck (pOptions, "Add component...(dump heap)");
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgClassSetup* pSetup;
hr = pINetCfg->QueryNetCfgClass ( &pOptions->ClassGuid, IID_INetCfgClassSetup, (VOID**)&pSetup);
if (S_OK == hr) { OBO_TOKEN OboToken; INetCfgComponent* pIComp;
ZeroMemory (&OboToken, sizeof(OboToken)); OboToken.Type = OBO_USER;
hr = pSetup->Install ( pOptions->pszInfId, &OboToken, 0, 0, NULL, NULL, &pIComp);
if (SUCCEEDED(hr)) { ReleaseObj (pIComp); }
if (NETCFG_S_REBOOT == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S was installed, but a reboot is required.\n", pOptions->pszInfId); } else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "The INF file for %S could not be found.\n", pOptions->pszInfId); }
ReleaseObj (pSetup); }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Add component.\n"); }
PromptForLeakCheck (pOptions, "Add component...(dump heap and compare)");}
VOIDCmdAddRemoveStress ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CImplINetCfg* pINetCfg; NETCLASS Class; PCWSTR pszInfId; PRODUCT_FLAVOR Flavor; BOOL fPrompted;
static const struct { NETCLASS Class; PCWSTR pszInfId; BOOL fServerOnly; } aPassInfo [] = { { NC_NETCLIENT, L"ms_msclient", FALSE }, { NC_NETCLIENT, L"ms_nwclient", FALSE },// { NC_NETSERVICE, L"ms_fpnw", FALSE }, // requries copy files
{ NC_NETSERVICE, L"ms_netbios", FALSE }, { NC_NETSERVICE, L"ms_nwsapagent", FALSE }, { NC_NETSERVICE, L"ms_psched", FALSE }, { NC_NETSERVICE, L"ms_server", FALSE },// { NC_NETSERVICE, L"ms_wlbs", FALSE },
{ NC_NETTRANS, L"ms_appletalk", FALSE }, { NC_NETTRANS, L"ms_atmarps", TRUE }, { NC_NETTRANS, L"ms_atmlane", FALSE }, { NC_NETTRANS, L"ms_atmuni", FALSE }, { NC_NETTRANS, L"ms_irda", FALSE },// { NC_NETTRANS, L"ms_isotpsys", FALSE },
{ NC_NETTRANS, L"ms_rawwan", FALSE },// { NC_NETTRANS, L"ms_streams", FALSE },
// { NC_NETTRANS, L"ms_tcpip", FALSE },
};
GetProductFlavor (NULL, &Flavor);
fPrompted = FALSE;
g_pDiagCtx->SetFlags ( DF_SHOW_CONSOLE_OUTPUT | DF_DONT_START_SERVICES | DF_DONT_DO_PNP_BINDS | DF_SUPRESS_E_NEED_REBOOT);
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { UINT cSkip = 0;
for (BOOL fInstall = TRUE; !_kbhit() && (S_OK == hr); fInstall = !fInstall) { for (UINT i = cSkip; (i < celems(aPassInfo)) && (S_OK == hr); i += (1 + cSkip)) { INetCfgClassSetup* pSetup; INetCfgComponent* pIComp;
if (aPassInfo[i].fServerOnly && (PF_WORKSTATION == Flavor)) { continue; }
Class = aPassInfo[i].Class; pszInfId = aPassInfo[i].pszInfId;
if (fInstall) { g_pDiagCtx->Printf (ttidBeDiag, "--------------------\n" "Installing %S\n", pszInfId);
hr = pINetCfg->QueryNetCfgClass ( MAP_NETCLASS_TO_GUID[Class], IID_INetCfgClassSetup, (VOID**)&pSetup);
if (S_OK == hr) { OBO_TOKEN OboToken;
ZeroMemory (&OboToken, sizeof(OboToken)); OboToken.Type = OBO_USER;
hr = pSetup->Install ( pszInfId, &OboToken, 0, 0, NULL, NULL, &pIComp);
if (SUCCEEDED(hr)) { ReleaseObj (pIComp); }
if (NETCFG_S_REBOOT == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S was installed, but a reboot is required.\n", pszInfId); }
ReleaseObj (pSetup); } } else { hr = pINetCfg->FindComponent (pszInfId, &pIComp); if (S_OK == hr) { GUID ClassGuid;
g_pDiagCtx->Printf (ttidBeDiag, "--------------------\n" "Removing %S\n", pszInfId);
hr = pIComp->GetClassGuid (&ClassGuid); if (S_OK == hr) { hr = pINetCfg->QueryNetCfgClass ( &ClassGuid, IID_INetCfgClassSetup, (VOID**)&pSetup);
if (S_OK == hr) { OBO_TOKEN OboToken;
ZeroMemory (&OboToken, sizeof(OboToken)); OboToken.Type = OBO_USER;
hr = pSetup->DeInstall ( pIComp, &OboToken, NULL);
if (NETCFG_S_REBOOT == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S was removed, but a reboot is required.\n", pszInfId); }
if (NETCFG_S_STILL_REFERENCED == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S is still referenced\n", pszInfId); }
if (E_INVALIDARG == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S is installed, but not on behalf of " "the user, so we can't remove it. (Proceeding.)\n", pszInfId); }
ReleaseObj (pSetup); } }
ReleaseObj (pIComp); } else if (S_FALSE == hr) { hr = S_OK; } } }
cSkip++; if (cSkip >= celems(aPassInfo)) { cSkip = 0; }
g_pDiagCtx->Printf (ttidBeDiag, "\n");
if (!fPrompted) { PromptForLeakCheck (pOptions, "Add/Remove stress...(dump heap)"); fPrompted = TRUE; } }
if (S_OK == hr) { _getch (); }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Add/Remove stress component.\n"); }
if (fPrompted) { PromptForLeakCheck (pOptions, "Add/Remove stress...(dump heap and compare)"); }}
VOIDCmdCleanup ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; NETCLASS Class; PCWSTR pszSubtree; HKEY hkeySubtree; DWORD dwIndex; HKEY hkeyInstance; GUID InstanceGuid; BOOL fDeleteKey; WCHAR szInfPath [_MAX_PATH]; WCHAR szInfSection [_MAX_PATH]; DWORD cbData;
static const struct { NETCLASS Class; PCWSTR pszSubtree; } aPassInfo [] = { { NC_NET, NULL }, { NC_INFRARED, NULL }, { NC_NETTRANS, NULL }, { NC_NETCLIENT, NULL }, { NC_NETSERVICE, NULL }, { NC_NET, L"System\\CurrentControlSet\\Control\\Network\\{4d36e972-e325-11ce-bfc1-08002be10318}" }, };
for (UINT i = 0; i < celems(aPassInfo); i++) { Class = aPassInfo[i].Class; pszSubtree = aPassInfo[i].pszSubtree;
Assert (FIsValidNetClass(Class));
if (!pszSubtree) { pszSubtree = MAP_NETCLASS_TO_NETWORK_SUBTREE[Class]; }
// Play it safe and assume we don't be deleting anything.
//
fDeleteKey = FALSE;
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++) { fDeleteKey = FALSE;
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) { if (!pNetConfig->Core.Components.PFindComponentByInstanceGuid(&InstanceGuid)) { fDeleteKey = TRUE;
hr = HrRegOpenKeyEx ( hkeySubtree, szInstanceGuid, KEY_READ, &hkeyInstance);
if (S_OK == hr) { *szInfPath = 0; *szInfSection = 0;
cbData = sizeof(szInfPath); HrRegQuerySzBuffer (hkeyInstance, REGSTR_VAL_INFPATH, szInfPath, &cbData);
cbData = sizeof(szInfSection) - sizeof(L".Remove"); HrRegQuerySzBuffer (hkeyInstance, REGSTR_VAL_INFSECTION, szInfSection, &cbData);
if (*szInfPath && *szInfSection) { HINF hinf;
hr = HrSetupOpenInfFile ( szInfPath, NULL, INF_STYLE_WIN4, NULL, &hinf);
if (S_OK == hr) { wcscat (szInfSection, L".Remove");
g_pDiagCtx->Printf (ttidBeDiag, "Running %S...\n", szInfSection);
hr = HrCiDoCompleteSectionInstall( hinf, hkeyInstance, szInfSection, NULL, FIsEnumerated(Class));
SetupCloseInfFile (hinf); }
}
RegCloseKey (hkeyInstance); } } }
if (fDeleteKey) { g_pDiagCtx->Printf (ttidBeDiag, "Deleting tree %S...\n", szInstanceGuid); (VOID) HrRegDeleteKeyTree (hkeySubtree, szInstanceGuid); fDeleteKey = FALSE;
// Back the index up by one since we just
// delete the current element.
//
dwIndex--; } } } 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]; 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) { if (!pNetConfig->Core.Components.PFindComponentByPnpId(szPnpId)) { g_pDiagCtx->Printf (ttidBeDiag, "Removing %S...\n", szPnpId);
ADAPTER_REMOVE_PARAMS arp = {0}; CiSetReservedField (hdi, &deid, &arp); hr = HrSetupDiCallClassInstaller ( DIF_REMOVE, hdi, &deid); CiClearReservedField (hdi, &deid); } } } } if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) { hr = S_OK; }
SetupDiDestroyDeviceInfoList (hdi); } } }}
VOIDCmdRemoveComponent ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CImplINetCfg* pINetCfg;
PromptForLeakCheck (pOptions, "Remove component...(dump heap)");
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgComponent* pIComp;
hr = pINetCfg->FindComponent (pOptions->pszInfId, &pIComp); if (S_OK == hr) { GUID ClassGuid;
hr = pIComp->GetClassGuid (&ClassGuid); if (S_OK == hr) { INetCfgClassSetup* pSetup;
hr = pINetCfg->QueryNetCfgClass ( &ClassGuid, IID_INetCfgClassSetup, (VOID**)&pSetup);
if (S_OK == hr) { OBO_TOKEN OboToken;
ZeroMemory (&OboToken, sizeof(OboToken)); OboToken.Type = OBO_USER;
hr = pSetup->DeInstall ( pIComp, &OboToken, NULL);
if (NETCFG_S_REBOOT == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S was removed, but a reboot is required.\n", pOptions->pszInfId); }
if (NETCFG_S_STILL_REFERENCED == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S is still referenced\n", pOptions->pszInfId); }
if (E_INVALIDARG == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S is installed, but not on behalf of " "the user, so it was not removed.\n", pOptions->pszInfId); }
ReleaseObj (pSetup); } }
ReleaseObj (pIComp); } else if (S_FALSE == hr) { g_pDiagCtx->Printf (ttidBeDiag, "%S was not found.\n", pOptions->pszInfId); hr = S_OK; }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); } else if (NETCFG_E_NEED_REBOOT == hr) { hr = S_OK; }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Remove component.\n"); }
PromptForLeakCheck (pOptions, "Remove component...(dump heap and compare)");}
VOIDCmdUpdateComponent ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CImplINetCfg* pINetCfg;
PromptForLeakCheck (pOptions, "Update component...(dump heap)");
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgComponent* pIComp;
hr = pINetCfg->FindComponent (pOptions->pszInfId, &pIComp); if (S_OK == hr) { INetCfgInternalSetup* pSetup;
hr = pINetCfg->GetUnknown()->QueryInterface ( IID_INetCfgInternalSetup, (VOID**)&pSetup);
if (S_OK == hr) { hr = pSetup->UpdateNonEnumeratedComponent ( pIComp, NSF_POSTSYSINSTALL, 0);
if (S_OK == hr) { hr = pINetCfg->Apply ();
if (NETCFG_S_REBOOT == hr) { hr = S_OK; g_pDiagCtx->Printf (ttidBeDiag, "%S was removed, but a reboot is required.\n", pOptions->pszInfId); } }
ReleaseObj (pSetup); }
ReleaseObj (pIComp); } else if (S_FALSE == hr) { g_pDiagCtx->Printf (ttidBeDiag, "%S was not found.\n", pOptions->pszInfId); hr = S_OK; }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); } else if (NETCFG_E_NEED_REBOOT == hr) { hr = S_OK; }
if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED Update component.\n"); }
PromptForLeakCheck (pOptions, "Update component...(dump heap and compare)");}
VOIDCmdRemoveReferences ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ Assert (pOptions->pszInfId);
CComponent* pComponent;
pComponent = pNetConfig->Core.Components.PFindComponentByInfId ( pOptions->pszInfId, NULL);
if (pComponent) { pComponent->Refs.RemoveAllReferences();
HrSaveNetworkConfigurationToRegistry (pNetConfig); }}
VOIDCmdShowBindings ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr = S_OK;
CComponent* pComponent; CBindingSet BindingSet; tstring strBindingSet;
if (SHOW_DISABLED == pOptions->ShowBindParam) { pNetConfig->Core.DisabledBindings.Printf (ttidBeDiag, NULL); return; } else if (CST_BY_NAME == pOptions->CompSpecifier.Type) { pComponent = pNetConfig->Core.Components.PFindComponentByPnpId ( pOptions->CompSpecifier.pszInfOrPnpId);
if (!pComponent) { pComponent = pNetConfig->Core.Components.PFindComponentByInfId ( pOptions->CompSpecifier.pszInfOrPnpId, NULL); }
if (!pComponent) { g_pDiagCtx->Printf (ttidBeDiag, "Component not found."); return; }
if (SHOW_BELOW == pOptions->ShowBindParam) { hr = pNetConfig->Core.HrGetComponentBindings ( pComponent, GBF_DEFAULT, &BindingSet); } else if (SHOW_INVOLVING == pOptions->ShowBindParam) { hr = pNetConfig->Core.HrGetBindingsInvolvingComponent ( pComponent, GBF_DEFAULT, &BindingSet); } if ((SHOW_UPPER == pOptions->ShowBindParam) && FIsEnumerated(pComponent->Class())) { hr = pNetConfig->Core.HrGetComponentUpperBindings ( pComponent, GBF_DEFAULT, &BindingSet); } } else if (CST_ALL == pOptions->CompSpecifier.Type) { CComponentList::const_iterator iter;
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
hr = pNetConfig->Core.HrGetComponentBindings ( pComponent, GBF_ADD_TO_BINDSET, &BindingSet); if (S_OK != hr) break; } }
if ((S_OK == hr) && !BindingSet.FIsEmpty()) { BindingSet.Printf (ttidBeDiag, NULL); }}
VOIDCmdShowComponents ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CComponentList::const_iterator iter; const CComponent* pComponent; WCHAR szBuffer [256]; CHAR* pszNetClass; UINT CountRefdBy; UINT i;
hr = pNetConfig->HrEnsureExternalDataLoadedForAllComponents (); if (S_OK != hr) { return; }
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
StringFromGUID2 (pComponent->m_InstanceGuid, szBuffer, celems(szBuffer));
switch (pComponent->Class()) { case NC_NET: pszNetClass = "NET "; break;
case NC_INFRARED: pszNetClass = "INFRARED "; break;
case NC_NETTRANS: pszNetClass = "TRANSPORT"; break;
case NC_NETCLIENT: pszNetClass = "CLIENT "; break;
case NC_NETSERVICE: pszNetClass = "SERVICE "; break;
default: pszNetClass = "(Invalid)"; break; }
tstring strChars;
SzFromCharacteristics(pComponent->m_dwCharacter, &strChars);
g_pDiagCtx->Printf (ttidBeDiag, "\n" "%S %S\n" // InfId PnpId
" Description: %S\n" " Class: %s\n" " Character: (0x%08x) %S\n" " Guid: %S\n" " NotifyObject?: %s\n" " BindForm: %S\n" " BindName: %S\n" " Service (CoServices): %S (%S)\n" " Ref'd by User?: %s\n", pComponent->m_pszInfId, (pComponent->m_pszPnpId) ? pComponent->m_pszPnpId : L"", (pComponent->Ext.PszDescription()) ? pComponent->Ext.PszDescription() : L"<no description>", pszNetClass, pComponent->m_dwCharacter, strChars.c_str(), szBuffer, pComponent->Ext.FHasNotifyObject() ? "Yes" : "No", (pComponent->Ext.PszBindForm()) ? pComponent->Ext.PszBindForm() : L"<default>", pComponent->Ext.PszBindName(), (pComponent->Ext.PszService()) ? pComponent->Ext.PszService() : L"(none)", (pComponent->Ext.PszCoServices()) ? pComponent->Ext.PszCoServices() : L"none", (pComponent->Refs.FIsReferencedByUser()) ? "Yes" : "No");
CountRefdBy = pComponent->Refs.CountComponentsReferencedBy(); if (CountRefdBy) { *szBuffer = 0;
for (i = 0; i < CountRefdBy; i++) { CComponent* pRefdBy; pRefdBy = pComponent->Refs.PComponentReferencedByAtIndex(i); Assert (pRefdBy);
wcscat (szBuffer, pRefdBy->PszGetPnpIdOrInfId()); wcscat (szBuffer, L" "); } } else { wcscpy (szBuffer, L"(none)"); } g_pDiagCtx->Printf (ttidBeDiag, " Ref'd by Components: %S\n", szBuffer);
CountRefdBy = pComponent->Refs.CountSoftwareReferencedBy(); if (CountRefdBy) { *szBuffer = 0;
for (i = 0; i < CountRefdBy; i++) { const CWideString* pRefdBy; pRefdBy = pComponent->Refs.PSoftwareReferencedByAtIndex(i); Assert (pRefdBy);
wcscat (szBuffer, pRefdBy->c_str()); wcscat (szBuffer, L" "); } } else { wcscpy (szBuffer, L"(none)"); } g_pDiagCtx->Printf (ttidBeDiag, " Ref'd by Software: %S\n", szBuffer);
} g_pDiagCtx->Printf (ttidBeDiag, "\n");}
VOIDCmdShowStackTable ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ const CStackEntry* pStackEntry;
g_pDiagCtx->Printf (ttidBeDiag, "\n%15s | %s\n" "---------------------------------\n", "Upper", "Lower");
for (pStackEntry = pNetConfig->Core.StackTable.begin(); pStackEntry != pNetConfig->Core.StackTable.end(); pStackEntry++) { g_pDiagCtx->Printf (ttidBeDiag, "%15S | %S\n", pStackEntry->pUpper->PszGetPnpIdOrInfId(), pStackEntry->pLower->PszGetPnpIdOrInfId()); }
g_pDiagCtx->Printf (ttidBeDiag, "\n"); g_pDiagCtx->Printf (ttidBeDiag, "WAN adapters are ordered %s\n\n", (pNetConfig->Core.StackTable.m_fWanAdaptersFirst) ? "first" : "last");}
VOIDCmdShowLanAdapterPnpIds ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CComponentList::const_iterator iter; const CComponent* pComponent;
hr = pNetConfig->HrEnsureExternalDataLoadedForAllComponents (); if (S_OK != hr) { return; }
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
if (!FSubstringMatch (pComponent->Ext.PszUpperRange (), L"ndis5", NULL, NULL)) { continue; }
g_pDiagCtx->Printf (ttidBeDiag, "%S\n", pComponent->m_pszPnpId); }}
VOIDCmdEnableOrDisableBinding ( IN const DIAG_OPTIONS* pOptions, IN BOOL fEnable){ HRESULT hr; CImplINetCfg* pINetCfg;
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgBindingPath* pIPath;
hr = HrFindBindPath (pINetCfg, pOptions->pszBindPath, &pIPath, NULL); if ((S_OK == hr) && pIPath) { pIPath->Enable (fEnable);
ReleaseObj (pIPath); }
hr = pINetCfg->Apply (); if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED to %s binding\n", (fEnable) ? "enable" : "disable"); }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }}
VOIDCmdMoveBinding ( IN const DIAG_OPTIONS* pOptions){ HRESULT hr; CImplINetCfg* pINetCfg;
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgBindingPath* pIPath; INetCfgBindingPath* pIOtherPath; INetCfgComponentBindings* pIOwner;
hr = HrFindBindPath (pINetCfg, pOptions->pszBindPath, &pIPath, &pIOwner); if ((S_OK == hr) && pIPath) { if (0 == _wcsicmp(pOptions->pszOtherBindPath, L"null")) { pIOtherPath = NULL; } else { hr = HrFindBindPath (pINetCfg, pOptions->pszOtherBindPath, &pIOtherPath, NULL); }
if (S_OK == hr) { if (pOptions->fMoveBefore) { hr = pIOwner->MoveBefore (pIPath, pIOtherPath); } else { hr = pIOwner->MoveAfter (pIPath, pIOtherPath); }
ReleaseObj (pIOtherPath); }
ReleaseObj (pIPath); ReleaseObj (pIOwner); }
hr = pINetCfg->Apply (); if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED to move binding\n"); }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }}
VOIDCmdWriteBindings ( IN const DIAG_OPTIONS* pOptions OPTIONAL, IN CNetConfig* pNetConfig){ HRESULT hr; CComponentList::const_iterator iter; const CComponent* pComponent; CRegistryBindingsContext RegBindCtx;
hr = RegBindCtx.HrPrepare (pNetConfig); if (S_OK != hr) { return; }
for (iter = pNetConfig->Core.Components.begin(); iter != pNetConfig->Core.Components.end(); iter++) { pComponent = *iter; Assert (pComponent);
hr = RegBindCtx.HrWriteBindingsForComponent (pComponent); }}
VOIDCmdSetWanOrder ( IN const DIAG_OPTIONS* pOptions){ HRESULT hr; CImplINetCfg* pINetCfg;
hr = HrCreateINetCfg (TRUE, &pINetCfg); if (S_OK == hr) { INetCfgSpecialCase* pSpecialCase;
hr = pINetCfg->GetUnknown()->QueryInterface ( IID_INetCfgSpecialCase, (VOID**)&pSpecialCase); Assert (S_OK == hr);
hr = pSpecialCase->SetWanAdaptersFirst (pOptions->fWanAdaptersFirst);
ReleaseObj (pSpecialCase);
hr = pINetCfg->Apply (); if (S_OK != hr) { g_pDiagCtx->Printf (ttidBeDiag, "FAILED to move binding\n"); }
HRESULT hrT = pINetCfg->Uninitialize (); Assert (S_OK == hrT);
ReleaseObj (pINetCfg->GetUnknown()); }}
VOIDCmdShowLanaDiag ( IN const DIAG_OPTIONS* pOptions){ CLanaMap LanaMap; HRESULT hr;
hr = LanaMap.HrLoadLanaMap();
if (S_OK == hr) { g_pDiagCtx->Printf (ttidBeDiag, "NetBios Bindings and Lana Information\n" "-------------------------------------\n"); CWideString str; LanaMap.Dump (&str); g_pDiagCtx->Printf (ttidBeDiag, "%S", str.c_str());
HKEY hkeyNetBios; hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, L"System\\currentcontrolset\\services\\netbios\\parameters", KEY_READ, &hkeyNetBios);
if (S_OK == hr) { DWORD MaxLana; hr = HrRegQueryDword (hkeyNetBios, L"MaxLana", &MaxLana); if (S_OK == hr) { g_pDiagCtx->Printf (ttidBeDiag, "\nMaximum Lana: %d\n", MaxLana); } RegCloseKey (hkeyNetBios); } }}
HRESULTHrPrintComponentDescriptionsFromBindPath ( IN PCWSTR pszBindPath, IN CNetConfig* pNetConfig){ HRESULT hr = S_OK; PCWSTR pszBindName; PCWSTR pszEnd; DWORD cchComponent; CComponent* pComponent; WCHAR szComponentBindName[_MAX_PATH] = {0};
Assert (pszBindPath && *pszBindPath);
GetFirstComponentFromBindPath (pszBindPath, &pszBindName, &cchComponent);
while (pszBindName && *pszBindName) { wcsncpy (szComponentBindName, pszBindName, cchComponent);
pComponent = pNetConfig->Core.Components. PFindComponentByBindName (NC_INVALID, szComponentBindName);
if (pComponent) { g_pDiagCtx->Printf (ttidBeDiag, "-->%S", pComponent->Ext.PszDescription()); }#ifdef ENABLETRACE
else { g_pDiagCtx->Printf (ttidBeDiag, "%S", szComponentBindName); }#endif // ENABLETRACE
pszBindName = wcschr (pszBindName, L'_'); if (pszBindName) { pszBindName++; pszEnd = wcschr (pszBindName, L'_'); if (pszEnd) { cchComponent = (DWORD)(pszEnd - pszBindName); } else { cchComponent = wcslen (pszBindName); } } }
TraceHr (ttidError, FAL, hr, FALSE, "HrPrintComponentDescriptionsFromBindPath"); return hr;}
VOIDCmdShowLanaPaths ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; CLanaMap LanaMap; PCWSTR pszBindPath; CLanaEntry* pEntry;
PromptForLeakCheck (pOptions, "Show Lana UI info diagnostic...(dump heap)"); hr = pNetConfig->HrEnsureExternalDataLoadedForAllComponents(); if (S_OK != hr) { return; }
hr = LanaMap.HrLoadLanaMap(); if (S_OK == hr) { PCWSTR pszBindName; PCWSTR pszEnd; DWORD cchComponent; CComponent* pComponent; WCHAR szComponentBindName[_MAX_PATH] = {0}; for (pEntry = LanaMap.begin(); pEntry != LanaMap.end(); pEntry++) { if (1 == pEntry->RegLanaEntry.Exported) { g_pDiagCtx->Printf (ttidNcDiag, "Lana: %3d\n", pEntry->RegLanaEntry.LanaNumber);
pszBindPath = pEntry->pszBindPath; GetFirstComponentFromBindPath (pszBindPath, &pszBindName, &cchComponent);
while (pszBindName && *pszBindName) { wcsncpy (szComponentBindName, pszBindName, cchComponent); szComponentBindName[cchComponent] = 0;
pComponent = pNetConfig->Core.Components. PFindComponentByBindName (NC_INVALID, szComponentBindName);
if (pComponent) { g_pDiagCtx->Printf (ttidNcDiag, "-->%S", pComponent->Ext.PszDescription()); } #ifdef ENABLETRACE
else { g_pDiagCtx->Printf (ttidNcDiag, "-->%S", szComponentBindName); } #endif // ENABLETRACE
pszBindName = wcschr (pszBindName, L'_'); if (pszBindName) { pszBindName++; pszEnd = wcschr (pszBindName, L'_'); if (pszEnd) { cchComponent = (DWORD)(pszEnd - pszBindName); } else { cchComponent = wcslen (pszBindName); } } }
if (FAILED(hr)) { break; }
g_pDiagCtx->Printf (ttidNcDiag, "\n\n"); } } } PromptForLeakCheck (pOptions, "Show Lana UI info diagnostic...(dump heap and compare)");}
VOIDCmdSetLanaNumber ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ CLanaMap LanaMap; HRESULT hr;
hr = pNetConfig->HrEnsureExternalDataLoadedForAllComponents(); if (S_OK != hr) { return; }
hr = LanaMap.HrLoadLanaMap();
if (S_OK == hr) { if (pOptions->OldLanaNumber != pOptions->NewLanaNumber) { hr = LanaMap.HrSetLanaNumber (pOptions->OldLanaNumber, pOptions->NewLanaNumber); if (S_OK == hr) { hr = LanaMap.HrWriteLanaConfiguration ( pNetConfig->Core.Components);
g_pDiagCtx->Printf (ttidNcDiag, "\nLana changed.\n"); } } else { g_pDiagCtx->Printf (ttidNcDiag, "\nNo change.\n"); } }
if (S_OK != hr) { if (HRESULT_FROM_WIN32(ERROR_OBJECT_NOT_FOUND) == hr) { g_pDiagCtx->Printf (ttidNcDiag, "\nThe old lana number is not currently " "assigned to a bind path.\n"); } else if (HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) == hr) { g_pDiagCtx->Printf (ttidNcDiag, "\nThe new lana number is currently assigned " "to a bind path.\n"); } else { g_pDiagCtx->Printf (ttidNcDiag, "\nError %X occurred\n", hr); } }}
VOIDCmdRewriteLanaInfo ( IN const DIAG_OPTIONS* pOptions, IN CNetConfig* pNetConfig){ HRESULT hr; const CComponent* pComponent; CRegistryBindingsContext RegBindCtx;
hr = RegBindCtx.HrPrepare (pNetConfig); if (S_OK == hr) { pComponent = pNetConfig->Core.Components. PFindComponentByInfId (L"MS_NetBios", NULL);
if (pComponent) { hr = RegBindCtx.HrWriteBindingsForComponent (pComponent); } else { g_pDiagCtx->Printf (ttidNcDiag, "\nNetBios is not installed.\n"); } }}
EXTERN_CVOIDWINAPINetCfgDiagFromCommandArgs ( IN DIAG_OPTIONS* pOptions){ Assert (pOptions); Assert (pOptions->pDiagCtx); g_pDiagCtx = pOptions->pDiagCtx;
CNetConfig NetConfig; HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig);
switch (pOptions->Command) { case CMD_SHOW_BINDINGS: CmdShowBindings (pOptions, &NetConfig); break;
case CMD_SHOW_COMPONENTS: CmdShowComponents (pOptions, &NetConfig); break;
case CMD_SHOW_STACK_TABLE: CmdShowStackTable (pOptions, &NetConfig); break;
case CMD_SHOW_LAN_ADAPTER_PNPIDS: CmdShowLanAdapterPnpIds (pOptions, &NetConfig); break;
case CMD_ADD_COMPONENT: CmdAddComponent (pOptions, &NetConfig); break;
case CMD_REMOVE_COMPONENT: CmdRemoveComponent (pOptions, &NetConfig); break;
case CMD_UPDATE_COMPONENT: CmdUpdateComponent (pOptions, &NetConfig); break;
case CMD_REMOVE_REFS: CmdRemoveReferences (pOptions, &NetConfig); break;
case CMD_ENABLE_BINDING: CmdEnableOrDisableBinding (pOptions, TRUE); break;
case CMD_DISABLE_BINDING: CmdEnableOrDisableBinding (pOptions, FALSE); break;
case CMD_MOVE_BINDING: CmdMoveBinding (pOptions); break;
case CMD_WRITE_BINDINGS: CmdWriteBindings (pOptions, &NetConfig); break;
case CMD_SET_WANORDER: CmdSetWanOrder (pOptions); break;
case CMD_FULL_DIAGNOSTIC: CNetCfgInternalDiagnostic::CmdFullDiagnostic (pOptions, &NetConfig); break;
case CMD_CLEANUP: CmdCleanup (pOptions, &NetConfig); break;
case CMD_ADD_REMOVE_STRESS: CmdAddRemoveStress (pOptions, &NetConfig); break; default: break; }
g_pDiagCtx = NULL;}
EXTERN_CVOIDWINAPINetCfgDiagRepairRegistryBindings ( IN FILE* pLogFile){ HRESULT hr; BOOL fCoUninitialize = TRUE;
hr = CoInitializeEx (NULL, COINIT_DISABLE_OLE1DDE | COINIT_APARTMENTTHREADED); if (FAILED(hr)) { fCoUninitialize = FALSE; if (RPC_E_CHANGED_MODE == hr) { hr = S_OK; } else { fprintf(pLogFile, "CoInitializeEx failed. (hr=0x%08x)\n", hr); } }
if (SUCCEEDED(hr)) { CDiagContext DiagCtx; CNetConfig NetConfig;
DiagCtx.SetFlags (DF_REPAIR_REGISTRY_BINDINGS); DiagCtx.SetLogFile (pLogFile); g_pDiagCtx = &DiagCtx;
hr = HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig); if (S_OK == hr) { CmdWriteBindings (NULL, &NetConfig); } else { fprintf(pLogFile, "Failed to load network configuration " "from the registry. (hr=0x%08x)\n", hr); }
g_pDiagCtx = NULL;
if (fCoUninitialize) { CoUninitialize (); } }}
EXTERN_CVOIDWINAPILanaCfgFromCommandArgs ( IN DIAG_OPTIONS* pOptions){ Assert (pOptions); Assert (pOptions->pDiagCtx); g_pDiagCtx = pOptions->pDiagCtx;
CNetConfig NetConfig; HrLoadNetworkConfigurationFromRegistry (KEY_READ, &NetConfig);
switch (pOptions->Command) { case CMD_SHOW_LANA_DIAG: CmdShowLanaDiag (pOptions); break; case CMD_SHOW_LANA_PATHS: CmdShowLanaPaths (pOptions, &NetConfig); break; case CMD_SET_LANA_NUMBER: CmdSetLanaNumber (pOptions, &NetConfig); break; case CMD_REWRITE_LANA_INFO: CmdRewriteLanaInfo (pOptions, &NetConfig); break; default: break; }
g_pDiagCtx = NULL;}
|
