1749 lines
54 KiB
C++
1749 lines
54 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1999.
|
|
//
|
|
// File: M O D I F Y . C P P
|
|
//
|
|
// Contents: Routines used to setup modifications to the network
|
|
// configuration.
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: shaunco 15 Jan 1999
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include <pch.h>
|
|
#pragma hdrstop
|
|
#include "classinst.h"
|
|
#include "filtdevs.h"
|
|
#include "guisetup.h"
|
|
#include "inetcfg.h"
|
|
#include "lockdown.h"
|
|
#include "ncmsz.h"
|
|
#include "ncreg.h"
|
|
#include "ncsvc.h"
|
|
#include "ndispnp.h"
|
|
#include "netcfg.h"
|
|
#include "persist.h"
|
|
#include "pnpbind.h"
|
|
#include "pszarray.h"
|
|
#include "util.h"
|
|
#include "wscfg.h"
|
|
#include "ncwins.h"
|
|
#include "ncperms.h"
|
|
|
|
CNetConfig*
|
|
CModifyContext::PNetConfig ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
CNetConfig* pNetConfig;
|
|
|
|
Assert ((LONG_PTR)this > FIELD_OFFSET(CNetConfig, ModifyCtx));
|
|
|
|
// Get our containing CNetConfig pointer.
|
|
//
|
|
pNetConfig = CONTAINING_RECORD(this, CNetConfig, ModifyCtx);
|
|
pNetConfig->Core.DbgVerifyData ();
|
|
|
|
return pNetConfig;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrDirtyComponent (
|
|
IN const CComponent* pComponent)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (pComponent);
|
|
|
|
m_hr = m_DirtyComponents.HrInsertComponent (pComponent,
|
|
INS_IGNORE_IF_DUP | INS_SORTED);
|
|
|
|
#if DBG
|
|
m_fComponentExplicitlyDirtied = TRUE;
|
|
#endif
|
|
|
|
TraceHr (ttidError, FAL, m_hr, FALSE,
|
|
"CModifyContext::HrDirtyComponentAndComponentsAbove");
|
|
return m_hr;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrDirtyComponentAndComponentsAbove (
|
|
IN const CComponent* pComponent)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
GCCONTEXT Ctx;
|
|
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (pComponent);
|
|
|
|
// And insert the component itself.
|
|
//
|
|
m_hr = HrDirtyComponent (pComponent);
|
|
|
|
// Only dirty the ones above if this component doesn't have the
|
|
// NCF_DONTEXPOSELOWER characteristic.
|
|
//
|
|
if ((S_OK == m_hr) && !(pComponent->m_dwCharacter & NCF_DONTEXPOSELOWER))
|
|
{
|
|
// Initialize the members of our context structure for recursion.
|
|
//
|
|
ZeroMemory (&Ctx, sizeof(Ctx));
|
|
Ctx.pStackTable = &(PNetConfig()->Core.StackTable);
|
|
Ctx.pComponents = &m_DirtyComponents;
|
|
|
|
// Insert all of the component above.
|
|
//
|
|
GetComponentsAboveComponent (pComponent, &Ctx);
|
|
m_hr = Ctx.hr;
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, m_hr, FALSE,
|
|
"CModifyContext::HrDirtyComponentAndComponentsAbove");
|
|
return m_hr;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrApplyIfOkOrCancel (
|
|
IN BOOL fApply)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
CNetConfig* pNetConfig;
|
|
|
|
Assert (m_fPrepared);
|
|
pNetConfig = PNetConfig();
|
|
|
|
// Only apply if the context result is S_OK.
|
|
//
|
|
if (fApply && (S_OK == m_hr))
|
|
{
|
|
// Setupapi calls that we make during ApplyChanges have the
|
|
// potential to return control to our clients windows message loop.
|
|
// When this happens, and our clients are poorly written, they
|
|
// may try to re-enter us on the same thread. This is disaster
|
|
// waiting to happen, so we need to prevent it by raising our
|
|
// reentrancy protection level before we start apply changes.
|
|
//
|
|
pNetConfig->Notify.PINetCfg()->RaiseRpl (RPL_DISALLOW);
|
|
|
|
ApplyChanges ();
|
|
|
|
pNetConfig->Notify.PINetCfg()->LowerRpl (RPL_DISALLOW);
|
|
|
|
// Delete those components from m_CoreStartedWith that are not
|
|
// in the current core and reset the modify context.
|
|
//
|
|
m_CoreStartedWith.Components.FreeComponentsNotInOtherComponentList (
|
|
&pNetConfig->Core.Components);
|
|
m_CoreStartedWith.Clear();
|
|
|
|
hr = S_OK;
|
|
|
|
// Return the correct HRESULT to the caller. If we've successfully
|
|
// applied, but need a reboot, return so.
|
|
//
|
|
if (m_fRebootRecommended || m_fRebootRequired)
|
|
{
|
|
hr = NETCFG_S_REBOOT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Cancel and release all notify objects. Do this for what is
|
|
// in the core as well as what we started with. (There will
|
|
// be some overlap, but they will only be released once.)
|
|
// We need to do both sets so we don't miss releasing components
|
|
// that have been removed. (Removed components won't be in
|
|
// current core, but they will be in the core that we started
|
|
// with.) Likewise, if we just released the core we started with,
|
|
// we'd miss releasing those components that were added.)
|
|
//
|
|
pNetConfig->Notify.ReleaseAllNotifyObjects (pNetConfig->Core.Components, TRUE);
|
|
pNetConfig->Notify.ReleaseAllNotifyObjects (m_CoreStartedWith.Components, TRUE);
|
|
|
|
// Delete those components from m_CoreStartedWith that are not
|
|
// in the current core. Then delete all the components in the
|
|
// current core and reload from our persistent storage.
|
|
// (This has the nice effect of invalidating all outstanding
|
|
// INetCfgComponent interfaces.)
|
|
//
|
|
m_CoreStartedWith.Components.FreeComponentsNotInOtherComponentList (
|
|
&pNetConfig->Core.Components);
|
|
pNetConfig->Core.Free ();
|
|
|
|
// Eject both cores (didn't you just know this metaphor was coming ;-)
|
|
// and reload the core from our persisted binary. This magically,
|
|
// and completely rolls everything back.
|
|
//
|
|
m_CoreStartedWith.Clear();
|
|
pNetConfig->Core.Clear();
|
|
|
|
// Return reason for failure through hr.
|
|
//
|
|
hr = m_hr;
|
|
|
|
// Reload the configuration and, if successful, it means m_hr
|
|
// will be S_OK. If unsuccessful, m_hr will be the error and will
|
|
// prevent subsequent operations.
|
|
//
|
|
m_hr = HrLoadNetworkConfigurationFromRegistry (KEY_READ, pNetConfig);
|
|
}
|
|
|
|
// Very important to set m_fPrepared back to FALSE so that HrPrepare gets
|
|
// called for the next modifcation and correctly copy the core etc.
|
|
//
|
|
m_fPrepared = FALSE;
|
|
m_AddedBindPaths.Clear();
|
|
m_DeletedBindPaths.Clear();
|
|
m_DirtyComponents.Clear();
|
|
#if DBG
|
|
m_fComponentExplicitlyDirtied = FALSE;
|
|
#endif
|
|
|
|
Assert (!m_fPrepared);
|
|
Assert (m_CoreStartedWith.FIsEmpty());
|
|
Assert (m_AddedBindPaths.FIsEmpty());
|
|
Assert (m_DeletedBindPaths.FIsEmpty());
|
|
Assert (m_DirtyComponents.FIsEmpty());
|
|
Assert (0 == m_ulRecursionDepth);
|
|
Assert (!m_fComponentExplicitlyDirtied);
|
|
|
|
Assert ((S_OK == hr) || (NETCFG_S_REBOOT == hr) || FAILED(hr));
|
|
TraceHr (ttidError, FAL, hr, NETCFG_S_REBOOT == hr,
|
|
"CModifyContext::HrApplyIfOkOrCancel");
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrPrepare ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
Assert (S_OK == m_hr);
|
|
Assert (!m_fPrepared);
|
|
Assert (m_CoreStartedWith.FIsEmpty());
|
|
Assert (m_AddedBindPaths.FIsEmpty());
|
|
Assert (m_DeletedBindPaths.FIsEmpty());
|
|
Assert (m_DirtyComponents.FIsEmpty());
|
|
Assert (0 == m_ulRecursionDepth);
|
|
Assert (!m_fComponentExplicitlyDirtied);
|
|
|
|
CNetConfig* pThis;
|
|
|
|
pThis = PNetConfig();
|
|
|
|
// Prepare the bind context. This will ensure all of the external
|
|
// data for all components is loaded as well as all ensuring that
|
|
// all notify objects have been initialized.
|
|
//
|
|
m_hr = m_RegBindCtx.HrPrepare (pThis);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Snapshot the current core so that we know what we started with.
|
|
// We will use the differences when we apply (if we get that far).
|
|
//
|
|
m_hr = m_CoreStartedWith.HrCopyCore (&pThis->Core);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reserve room for 64 components in the core.
|
|
// (64 * 4 = 256 bytes on 32-bit platforms)
|
|
//
|
|
m_hr = pThis->Core.Components.HrReserveRoomForComponents (64);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reserve room for 64 stack entries in the core.
|
|
// (64 * (4 + 4) = 512 bytes on 32-bit platforms)
|
|
//
|
|
m_hr = pThis->Core.StackTable.HrReserveRoomForEntries (64);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reserve room in our added list for 64 bindpaths of 8 components.
|
|
// (64 * 16 = 1K bytes on 32-bit platforms)
|
|
//
|
|
m_hr = m_AddedBindPaths.HrReserveRoomForBindPaths (64);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reserve room in our deleted list for 64 bindpaths of 8 components.
|
|
// (64 * 16 = 1K bytes on 32-bit platforms)
|
|
//
|
|
m_hr = m_DeletedBindPaths.HrReserveRoomForBindPaths (64);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reserve room for 64 components in the dirty component list.
|
|
// (64 * 4) = 256 bytes on 32-bit platforms)
|
|
//
|
|
m_hr = m_DirtyComponents.HrReserveRoomForComponents (64);
|
|
if (S_OK != m_hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
m_fPrepared = TRUE;
|
|
|
|
finished:
|
|
TraceHr (ttidError, FAL, m_hr, FALSE, "CModifyContext::HrPrepare");
|
|
return m_hr;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrBeginBatchOperation ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (0 == m_ulRecursionDepth);
|
|
|
|
TraceTag (ttidBeDiag, "Begin batch operation...");
|
|
|
|
PushRecursionDepth();
|
|
return m_hr;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrEndBatchOperation (
|
|
IN EBO_FLAG Flag)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
|
|
Assert (m_fPrepared);
|
|
Assert (1 == m_ulRecursionDepth);
|
|
|
|
if (EBO_COMMIT_NOW == Flag)
|
|
{
|
|
TraceTag (ttidBeDiag, "End batch (commiting changes)...");
|
|
|
|
hr = HrPopRecursionDepth ();
|
|
}
|
|
else
|
|
{
|
|
Assert (EBO_DEFER_COMMIT_UNTIL_APPLY == Flag);
|
|
|
|
TraceTag (ttidBeDiag, "End batch (deferring commit until Apply)...");
|
|
|
|
m_ulRecursionDepth = 0;
|
|
hr = S_OK;
|
|
}
|
|
|
|
Assert (0 == m_ulRecursionDepth);
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"CModifyContext::HrEndBatchOperation");
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CModifyContext::PushRecursionDepth ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
|
|
m_ulRecursionDepth++;
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrPopRecursionDepth ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
Assert (m_fPrepared);
|
|
Assert (m_ulRecursionDepth > 0);
|
|
|
|
m_ulRecursionDepth--;
|
|
|
|
if (0 != m_ulRecursionDepth)
|
|
{
|
|
return m_hr;
|
|
}
|
|
|
|
// We're at the top-level of the install or remove modifcation so
|
|
// apply or cancel the changes depending on the state of the context
|
|
// result.
|
|
//
|
|
HRESULT hr;
|
|
|
|
hr = HrApplyIfOkOrCancel (S_OK == m_hr);
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"CModifyContext::HrPopRecursionDepth");
|
|
return hr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// This is a convenience method to find and process Winsock Remove
|
|
// section for a component which is about to be removed.
|
|
|
|
HRESULT
|
|
CModifyContext::HrProcessWinsockRemove(IN const CComponent *pComponent)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HINF hinf = NULL;
|
|
HKEY hkeyInstance = NULL;
|
|
HRESULT hr;
|
|
|
|
Assert(pComponent);
|
|
|
|
hr = pComponent->HrOpenInfFile(&hinf);
|
|
if (S_OK == hr)
|
|
{
|
|
static const WCHAR c_szRemoveSectionSuffix[] = L".Remove";
|
|
|
|
// We get the remove section name and process all relevant sections
|
|
WCHAR szRemoveSection[_MAX_PATH];
|
|
DWORD cbBuffer = sizeof (szRemoveSection);
|
|
|
|
hr = pComponent->HrOpenInstanceKey (KEY_READ,
|
|
&hkeyInstance, NULL, NULL);
|
|
|
|
if(S_OK == hr)
|
|
{
|
|
hr = HrRegQuerySzBuffer (hkeyInstance, REGSTR_VAL_INFSECTION,
|
|
szRemoveSection, &cbBuffer);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
//HrAddOrRemoveWinsockDependancy processes the winsock
|
|
//remove section in the given inf file and then calls
|
|
//MigrateWinsockConfiguration which will cause the
|
|
//necessary PnP notifications to be issued to the
|
|
//interested application.
|
|
wcscat (szRemoveSection, c_szRemoveSectionSuffix);
|
|
|
|
hr = HrAddOrRemoveWinsockDependancy (hinf, szRemoveSection);
|
|
}
|
|
RegSafeCloseKey (hkeyInstance);
|
|
}
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"CModifyContext::HrProcessWinsockRemove (%S)",
|
|
pComponent->PszGetPnpIdOrInfId());
|
|
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CModifyContext::ApplyChanges ()
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
CNetConfig* pNetConfig;
|
|
CComponentList::const_iterator iter;
|
|
CComponent* pComponent;
|
|
CFilterDevices FilterDevices (&PNetConfig()->Core);
|
|
CPszArray ServiceNames;
|
|
CServiceManager ServiceManager;
|
|
PCWSTR pszService;
|
|
BOOL fRebootNeeded;
|
|
BOOL fMigrateWinsock;
|
|
BOOL fModifyFilterDevices;
|
|
BOOL fSignalNetworkProviderLoaded;
|
|
BOOL fUserIsNetConfigOps;
|
|
BOOL fCallCoFreeUnusedLibraries;
|
|
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (0 == m_ulRecursionDepth);
|
|
|
|
pNetConfig = PNetConfig();
|
|
|
|
fMigrateWinsock = FALSE;
|
|
fModifyFilterDevices = FALSE;
|
|
fSignalNetworkProviderLoaded = FALSE;
|
|
fUserIsNetConfigOps = FIsUserNetworkConfigOps();
|
|
fCallCoFreeUnusedLibraries = FALSE;
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 0: Prepare m_AddedBindPaths, m_DeletedBindPaths, and
|
|
// m_DirtyComponents.
|
|
//
|
|
|
|
// Add the bindpaths that were once disabled, but are now enabled, to
|
|
// m_AddedBindPaths. We do this so that PnP notifications are sent for
|
|
// them.
|
|
//
|
|
m_hr = m_AddedBindPaths.HrAddBindPathsInSet1ButNotInSet2 (
|
|
&m_CoreStartedWith.DisabledBindings,
|
|
&pNetConfig->Core.DisabledBindings);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Add the bindpaths that were once enabled, but are now disabled, to
|
|
// m_DeletedBindPaths. We do this so that PnP notifications are sent for
|
|
// them.
|
|
//
|
|
m_hr = m_DeletedBindPaths.HrAddBindPathsInSet1ButNotInSet2 (
|
|
&pNetConfig->Core.DisabledBindings,
|
|
&m_CoreStartedWith.DisabledBindings);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// m_fDirtyComponents should be empty unless we've explicitly dirtied
|
|
// one or more. If m_fDirtyComponents were not empty, it would probably
|
|
// mean we forgot to clear it after the last Apply or Cancel.
|
|
// Conversely, m_DirtyComponents better not be empty if we've explicitly
|
|
// dirtied one or more.
|
|
//
|
|
Assert (FIff(!m_fComponentExplicitlyDirtied, m_DirtyComponents.FIsEmpty()));
|
|
|
|
// Dirty the affected components (owners and adapters in bindpaths of
|
|
// length 2) from the added and deleted bindpaths. We need to write
|
|
// bindings for these components.
|
|
//
|
|
m_hr = m_AddedBindPaths.HrGetAffectedComponentsInBindingSet (
|
|
&m_DirtyComponents);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_hr = m_DeletedBindPaths.HrGetAffectedComponentsInBindingSet (
|
|
&m_DirtyComponents);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Dirty components that exist in the current core, but not in the core
|
|
// we started with. (These are added components).
|
|
//
|
|
m_hr = m_DirtyComponents.HrAddComponentsInList1ButNotInList2 (
|
|
&pNetConfig->Core.Components,
|
|
&m_CoreStartedWith.Components);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Dirty components that exist in the core we started with, but not in
|
|
// the current core. (These are removed components).
|
|
//
|
|
m_hr = m_DirtyComponents.HrAddComponentsInList1ButNotInList2 (
|
|
&m_CoreStartedWith.Components,
|
|
&pNetConfig->Core.Components);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 0: The following components are dirty:\n");
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
if (!pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %-12S (removed)\n",
|
|
pComponent->PszGetPnpIdOrInfId());
|
|
}
|
|
else if (!m_CoreStartedWith.Components.FComponentInList (pComponent))
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %-12S (installed)\n",
|
|
pComponent->PszGetPnpIdOrInfId());
|
|
}
|
|
else
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %S\n",
|
|
pComponent->PszGetPnpIdOrInfId());
|
|
}
|
|
}
|
|
|
|
// Reserve room for 32 pointers to service names. We use this buffer
|
|
// to start and stop services.
|
|
//
|
|
m_hr = ServiceNames.HrReserveRoomForPointers (32);
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// See if we are going to modify any filter devices. If we are,
|
|
// we'll go through all of the steps of loading filter devices, removing
|
|
// any we don't need, installing any new ones, and binding them all up.
|
|
// We only modify filter devices if the user is a normal admin and not
|
|
// a netcfgop.
|
|
//
|
|
// This test could be further refined to see if we had any filters which
|
|
// were dirty or if we had any dirty adapters which are filtered.
|
|
//
|
|
if (!fUserIsNetConfigOps)
|
|
{
|
|
fModifyFilterDevices = pNetConfig->Core.FContainsFilterComponent() ||
|
|
m_CoreStartedWith.FContainsFilterComponent();
|
|
}
|
|
else
|
|
{
|
|
Assert(!fModifyFilterDevices);
|
|
}
|
|
|
|
if (fModifyFilterDevices)
|
|
{
|
|
// Allow the filter devices structure to reserve whatever memory it
|
|
// may need.
|
|
//
|
|
m_hr = FilterDevices.HrPrepare ();
|
|
if (S_OK != m_hr)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
pNetConfig->Core.DisabledBindings.Printf (ttidBeDiag,
|
|
" The following bindings are currently disabled:\n");
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 1: Save the network configuration binary.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 1: Save the network configuration binary.\n");
|
|
|
|
HrSaveNetworkConfigurationToRegistry (pNetConfig);
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 2: Write the static bindings for all changed components.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 2: Write the following static bindings.\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// If any protocols are dirty, we'll want to migrate winsock
|
|
// configuration later.
|
|
//
|
|
if (NC_NETTRANS == pComponent->Class())
|
|
{
|
|
fMigrateWinsock = TRUE;
|
|
}
|
|
|
|
// If the component is in the core, write its bindings.
|
|
// If it is not in the core, it means it has been removed and
|
|
// we should therefore remove its bindings.
|
|
//
|
|
if (pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
hr = m_RegBindCtx.HrWriteBindingsForComponent (pComponent);
|
|
|
|
// Remember any errors, but continue.
|
|
//
|
|
if (S_OK != hr)
|
|
{
|
|
Assert (FAILED(hr));
|
|
m_hr = hr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Only delete if we're not installing another version of this
|
|
// component that has a duplicate PnpId. If we had already
|
|
// written the bindings for the newly installed one, and then
|
|
// deleted the ones for the removed (yet duplicate PnpId), we'd
|
|
// effectivly delete the bindings for the new one too. See the
|
|
// comments at step 6 for how we can get into this case.
|
|
//
|
|
if (!FIsEnumerated (pComponent->Class()) ||
|
|
!pNetConfig->Core.Components.PFindComponentByPnpId (
|
|
pComponent->m_pszPnpId))
|
|
{
|
|
// There's no reason to fail if we can't delete the bindings.
|
|
// The entire component is about to be tossed anyway.
|
|
//
|
|
(VOID) m_RegBindCtx.HrDeleteBindingsForComponent (pComponent);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 3: Notify ApplyRegistryChanges
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 3: Notify: apply registry changes\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
pComponent->Notify.ApplyRegistryChanges (
|
|
pNetConfig->Notify.PINetCfg(),
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %S notify object wants a reboot\n",
|
|
pComponent->m_pszInfId);
|
|
}
|
|
}
|
|
|
|
// Migrate Winsock configuration if needed.
|
|
// Important to do this after the LANA map is written, afer Notify Applys
|
|
// are called, but before any services are started.
|
|
//
|
|
if (fMigrateWinsock)
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, "Migrating winsock configuration.\n");
|
|
(VOID) HrMigrateWinsockConfiguration ();
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 4: Unbind deleted bindpaths.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 4: Unbind the following deleted bindings:\n");
|
|
|
|
if (!m_DeletedBindPaths.FIsEmpty())
|
|
{
|
|
// We don't need to send UNBIND notifications for bindpaths that
|
|
// involve adapters that have been removed. They will be unbound
|
|
// automatically when the adapter is uninstalled. (For the case
|
|
// when the class installer is notifying us of a removed adapter,
|
|
// its important NOT to try to send an UNBIND notification because
|
|
// the adapter has already been uninstalled (hence unbound) and
|
|
// our notification might come back in error causing us to need
|
|
// a reboot uneccessary.
|
|
//
|
|
// So, remove the bindpaths in m_DeletedBindPaths that involve
|
|
// adapters that have been removed.
|
|
//
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// If its enumerated, and not in the current core, its a
|
|
// removed adapter.
|
|
//
|
|
if (FIsEnumerated (pComponent->Class()) &&
|
|
!pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
m_DeletedBindPaths.RemoveBindPathsWithComponent (pComponent);
|
|
}
|
|
}
|
|
|
|
m_DeletedBindPaths.SortForPnpUnbind ();
|
|
|
|
m_RegBindCtx.PnpBindOrUnbindBindPaths (UNBIND,
|
|
&m_DeletedBindPaths,
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 5: Stop services for removed components.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 5: Stop the following services:\n");
|
|
|
|
Assert (0 == ServiceNames.Count());
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// Ignore enumerated components because they will have their drivers
|
|
// stopped automatically (if appropriate) when they are removed.
|
|
// Ignore components that are in the current core (not being removed).
|
|
//
|
|
if (FIsEnumerated (pComponent->Class()) ||
|
|
pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Winsock remove section needs to be processed for every
|
|
// component that is being removed in order to update
|
|
// Transport key for the winsock registry settings
|
|
|
|
HrProcessWinsockRemove (pComponent);
|
|
|
|
// If its a protcol, send an UNLOAD before trying to stop the service.
|
|
//
|
|
|
|
if ((NC_NETTRANS == pComponent->Class()) || (NCF_NDIS_PROTOCOL & pComponent->m_dwCharacter))
|
|
{
|
|
// Unload can fail as a lot of drivers do not support it.
|
|
// Treat it as an 'FYI' indication and don't set the reboot
|
|
// flag if it fails.
|
|
//
|
|
(VOID) HrPnpUnloadDriver (NDIS, pComponent->Ext.PszBindName());
|
|
}
|
|
|
|
// Ignore components that don't have any services.
|
|
if (!pComponent->Ext.PszCoServices())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
for (pszService = pComponent->Ext.PszCoServices();
|
|
*pszService;
|
|
pszService += wcslen(pszService) + 1)
|
|
{
|
|
(VOID)ServiceNames.HrAddPointer (pszService);
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %S", pszService);
|
|
}
|
|
g_pDiagCtx->Printf (ttidBeDiag, "\n");
|
|
}
|
|
|
|
if (ServiceNames.Count() > 0)
|
|
{
|
|
static const CSFLAGS CsStopFlags =
|
|
{
|
|
FALSE, // FALSE means don't start
|
|
SERVICE_CONTROL_STOP, // use this control instead
|
|
15000, // wait up to 15 seconds...
|
|
SERVICE_STOPPED, // ... for service to reach this state
|
|
FALSE, //
|
|
};
|
|
|
|
hr = ServiceManager.HrControlServicesAndWait (
|
|
ServiceNames.Count(),
|
|
ServiceNames.begin(),
|
|
&CsStopFlags);
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
m_fRebootRequired = TRUE;
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " some service failed to stop (hr = 0x%08X)\n",
|
|
hr);
|
|
|
|
// Unfortunately, there is no easy way to get back which service
|
|
// did not stop and then to figure out which component contains
|
|
// that service. Sooo, we'll just put every component that is
|
|
// being removed in lockdown. This isn't a big deal when the UI
|
|
// is doing the removal because it only removes things one at a
|
|
// time.
|
|
//
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
if (FIsEnumerated (pComponent->Class()) ||
|
|
!pComponent->Ext.PszCoServices() ||
|
|
pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
LockdownComponentUntilNextReboot (pComponent->m_pszInfId);
|
|
}
|
|
}
|
|
|
|
ServiceNames.Clear();
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 5a: Uninstall filters first.
|
|
//
|
|
|
|
if (fModifyFilterDevices)
|
|
{
|
|
g_pDiagCtx->Printf(ttidBeDiag, "Step 5a: Remove filter devices:\n");
|
|
|
|
// Order is of utmost importance here. Remove must be called first
|
|
// because it initializes some state internal to FilterDevices. Start
|
|
// must come after Write and Write obviously has to come after all
|
|
// new filter devices are installed.
|
|
//
|
|
FilterDevices.LoadAndRemoveFilterDevicesIfNeeded ();
|
|
}
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 6: Uninstall removed components.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 6: Uninstall the following components:\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// If the component is in the core, ignore it.
|
|
// If it is not in the core, it means it has been removed and
|
|
// we should therefore remove its bindings.
|
|
//
|
|
if (pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// If this is an enumerated component whose PnpId matches that of
|
|
// a component in the current core, we've run into a special case.
|
|
// This can happen when the external data (like the NetCfgInstanceId)
|
|
// is corrupted and the class installer was told to update the
|
|
// component. The class installer is really told to "install" the
|
|
// component, but if it already exists as determined by the presence
|
|
// of NetCfgInstanceId, the class installer translates it to "update".
|
|
// Without the key, the class installer thinks its installing
|
|
// a new one. We detect the duplicate PnpId and remove the "prior"
|
|
// so we can install the "new". This "prior" instance is what we
|
|
// are finalizing the remove of, but if we call HrCiRemoveComponent,
|
|
// it just removes the same PnpId that the class installer told us
|
|
// to install. By not calling HrCiRemoveComponent for this case,
|
|
// the "prior" instance key gets reused implicitly by the "new"
|
|
// instance.
|
|
//
|
|
if (FIsEnumerated (pComponent->Class()) &&
|
|
pNetConfig->Core.Components.PFindComponentByPnpId (
|
|
pComponent->m_pszPnpId))
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
" Skip removal of %S because a duplicate was installed\n",
|
|
pComponent->m_pszPnpId);
|
|
|
|
continue;
|
|
}
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
" %S\n", pComponent->PszGetPnpIdOrInfId());
|
|
|
|
hr = HrCiRemoveComponent (pComponent, &pComponent->m_strRemoveSection);
|
|
|
|
// We can ignore SPAPI_E_NO_SUCH_DEVINST because the class installer
|
|
// may have already removed it and is just notifying us.
|
|
//
|
|
if ((S_OK != hr) && (SPAPI_E_NO_SUCH_DEVINST != hr))
|
|
{
|
|
m_fRebootRequired = TRUE;
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " ^^^ needs a reboot (hr = 0x%08X)\n",
|
|
hr);
|
|
}
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 6a: Modify filter devices.
|
|
//
|
|
if (fModifyFilterDevices)
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, "Step 6a: Modify filter devices:\n");
|
|
|
|
FilterDevices.InstallFilterDevicesIfNeeded ();
|
|
|
|
(VOID)m_RegBindCtx.HrWriteBindingsForFilterDevices (&FilterDevices);
|
|
|
|
PruneNdisWanBindPathsIfActiveRasConnections (
|
|
&FilterDevices.m_BindPathsToRebind,
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
}
|
|
|
|
m_RegBindCtx.PnpBindOrUnbindBindPaths (UNBIND,
|
|
&FilterDevices.m_BindPathsToRebind,
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
}
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, "Step 6b: Starting filter devices:\n");
|
|
|
|
FilterDevices.StartFilterDevices ();
|
|
FilterDevices.Free ();
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 7: Start services for added components.
|
|
//
|
|
Assert (0 == ServiceNames.Count());
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 7: Start the following drivers/services:\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// If the component is in the core we started with, ignore it.
|
|
// If it is not in the core we started with, it means it is newly
|
|
// installed we should therefore start its services.
|
|
//
|
|
if (m_CoreStartedWith.Components.FComponentInList (pComponent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// If we've added a network client, we'll need to signal the
|
|
// network provider loaded event after we've started its service.
|
|
//
|
|
if (NC_NETCLIENT == pComponent->Class())
|
|
{
|
|
fSignalNetworkProviderLoaded = TRUE;
|
|
}
|
|
|
|
if (FIsEnumerated (pComponent->Class()))
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %S\n", pComponent->m_pszPnpId);
|
|
|
|
hr = pComponent->HrStartOrStopEnumeratedComponent (DICS_START);
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " ^^^ needs a reboot (hr = 0x%08X)\n",
|
|
hr);
|
|
}
|
|
|
|
if (FIsPhysicalNetAdapter (pComponent->Class(),
|
|
pComponent->m_dwCharacter) && FInSystemSetup())
|
|
{
|
|
ProcessAdapterAnswerFileIfExists (pComponent);
|
|
}
|
|
}
|
|
else if (pComponent->Ext.PszCoServices())
|
|
{
|
|
for (pszService = pComponent->Ext.PszCoServices();
|
|
*pszService;
|
|
pszService += wcslen(pszService) + 1)
|
|
{
|
|
(VOID)ServiceNames.HrAddPointer (pszService);
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " %S", pszService);
|
|
}
|
|
g_pDiagCtx->Printf (ttidBeDiag, "\n");
|
|
|
|
// If we're in system setup, then exclude whatever services
|
|
// the component has marked as such.
|
|
//
|
|
if (FInSystemSetup())
|
|
{
|
|
ExcludeMarkedServicesForSetup (pComponent, &ServiceNames);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((ServiceNames.Count() > 0) &&
|
|
!(g_pDiagCtx->Flags() & DF_DONT_START_SERVICES))
|
|
{
|
|
static const CSFLAGS CsStartFlags =
|
|
{
|
|
TRUE, // TRUE means start
|
|
0,
|
|
20000, // wait up to 20 seconds...
|
|
SERVICE_RUNNING, // ... for service to reach this state
|
|
TRUE, // ignore demand-start and disabled
|
|
};
|
|
|
|
hr = ServiceManager.HrControlServicesAndWait (
|
|
ServiceNames.Count(),
|
|
ServiceNames.begin(),
|
|
&CsStartFlags);
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag, " some service failed to start (hr = 0x%08X)\n",
|
|
hr);
|
|
}
|
|
}
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 8: Bind added bindpaths.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 8: Bind the following added bindings:\n");
|
|
|
|
if (fModifyFilterDevices)
|
|
{
|
|
hr = m_AddedBindPaths.HrAppendBindingSet (
|
|
&FilterDevices.m_BindPathsToRebind);
|
|
if (S_OK != hr)
|
|
{
|
|
// Well, that's not good, but there is nothing we can do about
|
|
// it now. (Most likely we ran out of memory.)
|
|
}
|
|
}
|
|
|
|
if (!m_AddedBindPaths.FIsEmpty())
|
|
{
|
|
CBindPath* pBindPath;
|
|
|
|
// We don't need to send BIND notifications for bindpaths that
|
|
// involve adapters that have been newly installed. They will be
|
|
// bound automatically when the adapter is started.
|
|
//
|
|
// Update to the above comment: We THOUGHT that was correct, but it
|
|
// turns out it isn't. TDI isn't PNP (guess they must have missed
|
|
// THAT memo) and they are not re-reading the new bind strings
|
|
// from the registry when lower notifications bubble up. So, we
|
|
// have to send these BINDS for added adapters too.
|
|
//
|
|
// We should remove bindpaths that involve components that have
|
|
// been removed. These can end up in added bindpaths because way
|
|
// up in step 0, we added bindpaths that were disabled in the
|
|
// core we started with and that are no longer disabled in the
|
|
// current core. Well, when the component is removed, its disabled
|
|
// bindings are removed, so this case would have caused us to add
|
|
// the bindpath to this binding set.
|
|
//
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// If its been removed, remove any bindpaths that reference it.
|
|
//
|
|
if (!pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
m_AddedBindPaths.RemoveBindPathsWithComponent (pComponent);
|
|
}
|
|
}
|
|
|
|
// To prevent TDI from sending duplicate BINDs to its clients, we
|
|
// have to do a little more work. We need to not send the TDI
|
|
// BINDs to components that are newly installed. This is because
|
|
// TDI sent them the BINDs when we started the driver above.
|
|
// So, for each added bindpath, if it's going to the TDI layer, and
|
|
// the owner (topmost) component of the bindpath is newly installed,
|
|
// remove it from the added binding so we won't send a notification
|
|
// for it below.
|
|
//
|
|
pBindPath = m_AddedBindPaths.begin();
|
|
while (pBindPath != m_AddedBindPaths.end())
|
|
{
|
|
UINT unLayer = GetPnpLayerForBindPath (pBindPath);
|
|
|
|
if ((TDI == unLayer) &&
|
|
!m_CoreStartedWith.Components.FComponentInList (
|
|
pBindPath->POwner()))
|
|
{
|
|
m_AddedBindPaths.erase (pBindPath);
|
|
}
|
|
else
|
|
{
|
|
pBindPath++;
|
|
}
|
|
}
|
|
|
|
m_AddedBindPaths.SortForPnpBind ();
|
|
|
|
m_RegBindCtx.PnpBindOrUnbindBindPaths (BIND,
|
|
&m_AddedBindPaths,
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
// If BINDs fail, we should recommend a reboot, but one is
|
|
// not required for subsequent installs or removes.
|
|
//
|
|
m_fRebootRecommended = TRUE;
|
|
}
|
|
}
|
|
|
|
// Signal the network provider loaded event if needed.
|
|
// Probably best to do this after we've indiciated the PnP bindings
|
|
// (above) to the new clients.
|
|
//
|
|
if (fSignalNetworkProviderLoaded)
|
|
{
|
|
SignalNetworkProviderLoaded ();
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 9: Allow notify objects to apply PnP changes
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 9: Notify: apply PnP changes\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
pComponent->Notify.ApplyPnpChanges (
|
|
pNetConfig->Notify.PINetCfg(),
|
|
&fRebootNeeded);
|
|
|
|
if (fRebootNeeded)
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
" %S notify object wants a reboot\n",
|
|
pComponent->m_pszInfId);
|
|
|
|
// If the component has been removed, treat the reboot
|
|
// as mandatory. (The reason being that we cannot risk a
|
|
// failed re-install.) We put the component into lockdown
|
|
// in this situation.
|
|
//
|
|
if (!pNetConfig->Core.Components.FComponentInList (pComponent))
|
|
{
|
|
m_fRebootRequired = TRUE;
|
|
|
|
LockdownComponentUntilNextReboot (pComponent->m_pszInfId);
|
|
}
|
|
else
|
|
{
|
|
m_fRebootRecommended = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//+-----------------------------------------------------------------------
|
|
// Step 10: Release notify objects for removed components and
|
|
// process any DelFiles in the remove section of their INF.
|
|
//
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
"Step 10: Release notify objects for removed components:\n");
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// Skip enumerated components (they don't have notify objects), and
|
|
// Skip components that were not removed.
|
|
// Skip components that don't have their INF open (like unsupported
|
|
// components that get removed during GUI setup.)
|
|
//
|
|
if (FIsEnumerated (pComponent->Class()) ||
|
|
pNetConfig->Core.Components.FComponentInList (pComponent) ||
|
|
!pComponent->GetCachedInfFile())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pComponent->Notify.ReleaseNotifyObject(NULL, FALSE);
|
|
|
|
fCallCoFreeUnusedLibraries = TRUE;
|
|
}
|
|
|
|
if (fCallCoFreeUnusedLibraries)
|
|
{
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
" calling CoFreeUnusedLibraries before running remove sections\n");
|
|
|
|
// Now ask COM to unload any DLLs hosting COM objects that are no longer
|
|
// in use. (This is a bit heavy-handed as it affects the entire process,
|
|
// but there is currently no other way to safely unload the DLLs hosting
|
|
// the notify objects of the removed components.)
|
|
//
|
|
CoFreeUnusedLibrariesEx(0, 0);
|
|
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// Skip enumerated components (they don't have notify objects), and
|
|
// Skip components that were not removed.
|
|
// Skip components that don't have their INF open (like unsupported
|
|
// components that get removed during GUI setup.)
|
|
//
|
|
if (FIsEnumerated (pComponent->Class()) ||
|
|
pNetConfig->Core.Components.FComponentInList (pComponent) ||
|
|
!pComponent->GetCachedInfFile())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
g_pDiagCtx->Printf (ttidBeDiag,
|
|
" %S [%S]\n", pComponent->PszGetPnpIdOrInfId(),
|
|
pComponent->m_strRemoveSection.c_str());
|
|
|
|
(VOID) HrCiInstallFromInfSection(
|
|
pComponent->GetCachedInfFile(),
|
|
pComponent->m_strRemoveSection.c_str(),
|
|
NULL, NULL, SPINST_FILES);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
//+-----------------------------------------------------------------------
|
|
// Step 11: Reconfigure moved bindings
|
|
//
|
|
// If we changed binding order, Send PnP RECONFIGURE for all dirty
|
|
// components that are neither installed nor removed so we
|
|
// pickup these order changes.
|
|
//
|
|
for (iter = m_DirtyComponents.begin();
|
|
iter != m_DirtyComponents.end();
|
|
iter++)
|
|
{
|
|
pComponent = *iter;
|
|
Assert (pComponent);
|
|
|
|
// Skip components that have been newly installed or removed.
|
|
//
|
|
if (!pNetConfig->Core.Components.FComponentInList (pComponent) ||
|
|
!m_CoreStartedWith.Components.FComponentInList (pComponent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Note: send RECONFIGURE
|
|
}
|
|
*/
|
|
}
|
|
|
|
HRESULT
|
|
CModifyContext::HrEnableOrDisableBindPath (
|
|
IN DWORD dwChangeFlag,
|
|
IN CBindPath* pBindPath,
|
|
IN INetCfgBindingPath* pIPath OPTIONAL)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
CNetConfig* pNetConfig;
|
|
UINT CountBefore;
|
|
|
|
Assert (this);
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert ((dwChangeFlag == NCN_ENABLE) || (dwChangeFlag == NCN_DISABLE));
|
|
Assert (pBindPath);
|
|
|
|
hr = S_OK;
|
|
pNetConfig = PNetConfig();
|
|
|
|
// Get the count of bindpaths currently disabled. If it changes
|
|
// after we enable/disable this one, we'll inform notify objects
|
|
// about it. If the count does not change, it means the state
|
|
// of the bindpath has not changed.
|
|
//
|
|
CountBefore = pNetConfig->Core.DisabledBindings.CountBindPaths();
|
|
|
|
if (NCN_ENABLE == dwChangeFlag)
|
|
{
|
|
pNetConfig->Core.EnableBindPath (pBindPath);
|
|
Assert (S_OK == hr);
|
|
}
|
|
else
|
|
{
|
|
hr = pNetConfig->Core.HrDisableBindPath (pBindPath);
|
|
}
|
|
|
|
if ((S_OK == hr) &&
|
|
(pNetConfig->Core.DisabledBindings.CountBindPaths() != CountBefore))
|
|
{
|
|
// Note: Need to protect against bad notify objects that
|
|
// switch the state of a bindpath we are notifying for.
|
|
// This could cause an infinite loop. Solve by adding a
|
|
// recursion count and bindset to the modify context dedicated
|
|
// to bindpath enabling/disabling. When the count is zero,
|
|
// we clear the bindingset, add the bindpath we are about to
|
|
// notify for, increment the recursion count and call
|
|
// NotifyBindPath. When the call returns, we decrement the
|
|
// recursion count, remove the bindpath from the binding set,
|
|
// and return. Before we call NotifyBindPath when the recursion
|
|
// count is non-zero, if the bindpath is already in the
|
|
// bindingset, we don't call.
|
|
//
|
|
|
|
pNetConfig->Notify.NotifyBindPath (dwChangeFlag, pBindPath, pIPath);
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"CModifyContext::HrEnableOrDisableBindPath");
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CModifyContext::InstallOrRemoveRequiredComponents (
|
|
IN CComponent* pComponent,
|
|
IN IOR_ACTION Action)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
HKEY hkeyInstance;
|
|
PWSTR pszRequiredList;
|
|
const WCHAR szDelims[] = L", ";
|
|
|
|
Assert (this);
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (pComponent);
|
|
Assert ((IOR_INSTALL == Action) || (IOR_REMOVE == Action));
|
|
|
|
pszRequiredList = NULL;
|
|
|
|
// Open the instance key of the component and read the RequireAll value.
|
|
// This value may not exist, which is okay, it means we have nothing
|
|
// to do.
|
|
//
|
|
hr = pComponent->HrOpenInstanceKey (KEY_READ, &hkeyInstance, NULL, NULL);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
HKEY hkeyNdi;
|
|
|
|
hr = HrRegOpenKeyEx (hkeyInstance, L"Ndi", KEY_READ, &hkeyNdi);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrRegQuerySzWithAlloc (hkeyNdi, L"RequiredAll",
|
|
&pszRequiredList);
|
|
|
|
RegCloseKey (hkeyNdi);
|
|
}
|
|
|
|
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
|
|
{
|
|
hr = S_OK;
|
|
Assert (!pszRequiredList);
|
|
}
|
|
|
|
RegCloseKey (hkeyInstance);
|
|
}
|
|
|
|
// If we have a list of required components, install or remove them.
|
|
//
|
|
if ((S_OK == hr) && pszRequiredList)
|
|
{
|
|
CNetConfig* pNetConfig;
|
|
INetCfgComponent* pIComp;
|
|
|
|
pNetConfig = PNetConfig();
|
|
|
|
hr = pComponent->HrGetINetCfgComponentInterface (
|
|
pNetConfig->Notify.PINetCfg(),
|
|
&pIComp);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
PCWSTR pszInfId;
|
|
PWSTR pszNextInfId;
|
|
OBO_TOKEN OboToken;
|
|
CComponent* pComponentToRemove;
|
|
WCHAR szInfFile [_MAX_PATH];
|
|
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_COMPONENT;
|
|
OboToken.pncc = pIComp;
|
|
|
|
// For each INF ID in the comma separate list of required
|
|
// components...
|
|
//
|
|
for (pszInfId = GetNextStringToken (pszRequiredList, szDelims, &pszNextInfId);
|
|
pszInfId && *pszInfId;
|
|
pszInfId = GetNextStringToken (NULL, szDelims, &pszNextInfId))
|
|
{
|
|
if (IOR_INSTALL == Action)
|
|
{
|
|
NETWORK_INSTALL_PARAMS nip;
|
|
COMPONENT_INSTALL_PARAMS Params;
|
|
|
|
ZeroMemory (&Params, sizeof(Params));
|
|
|
|
// Get the Class corresponding to the INF ID.
|
|
//
|
|
m_hr = HrCiGetClassAndInfFileOfInfId (
|
|
pszInfId, &Params.Class, szInfFile);
|
|
if (S_OK != m_hr)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//$REVIEW:Should we stick the filename in the
|
|
// COMPONENT_INSTALL_PARAMS so that we don't grovel
|
|
// the INF directory to find it again?
|
|
// If so, store the filename buffer in the modify
|
|
// context so we don't take up stack space or heap space.
|
|
// Just need to be sure that we use it to install the
|
|
// component before we recurse and overwrite it.
|
|
|
|
// Pack the network install parameters and call the common
|
|
// function.
|
|
//
|
|
//$REVIEW: we probably need dwSetupFlags and dwUpgradeFromBuildNo
|
|
// in the modify context saved when it was called at
|
|
// recursion depth 0. Otherwise, things installed here
|
|
// during GUI setup will have wrong parameters.
|
|
//
|
|
nip.dwSetupFlags = 0;
|
|
nip.dwUpgradeFromBuildNo = 0;
|
|
nip.pszAnswerFile = NULL;
|
|
nip.pszAnswerSection = NULL;
|
|
|
|
// Setup the component install parameters.
|
|
//
|
|
Params.pszInfId = pszInfId;
|
|
Params.pszInfFile = szInfFile;
|
|
Params.pOboToken = FIsEnumerated (Params.Class)
|
|
? NULL : &OboToken;
|
|
Params.pnip = &nip;
|
|
|
|
//
|
|
// THIS MAY CAUSE RECURSION
|
|
//
|
|
// (just using pComponentToRemove as a placeholder
|
|
// for a required parameter.)
|
|
//
|
|
HrInstallNewOrReferenceExistingComponent (
|
|
Params, &pComponentToRemove);
|
|
if (S_OK != m_hr)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert (IOR_REMOVE == Action);
|
|
|
|
// Search for the component to remove using its INF ID.
|
|
//
|
|
pComponentToRemove = pNetConfig->Core.Components.
|
|
PFindComponentByInfId (pszInfId, NULL);
|
|
|
|
if (pComponentToRemove)
|
|
{
|
|
//
|
|
// THIS MAY CAUSE RECURSION
|
|
//
|
|
HrRemoveComponentIfNotReferenced (
|
|
pComponentToRemove,
|
|
FIsEnumerated (pComponentToRemove->Class())
|
|
? NULL
|
|
: &OboToken,
|
|
NULL);
|
|
if (S_OK != m_hr)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ReleaseObj (pIComp);
|
|
}
|
|
|
|
MemFree (pszRequiredList);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Update a component. Do this by generating the bindings which involve
|
|
// the component and noting them as 'OldBindPaths'. The stack entries which
|
|
// involve the component are removed and re-generated and the bindings which
|
|
// involve the component are again noted as 'NewBindPaths'. The old bindings
|
|
// are compared to the new bindings and the differences are notified to
|
|
// notify objects as either being removed or added. For any removed bindings,
|
|
// we also remove them from the core's disabled set if they happen to exist
|
|
// there too.
|
|
//
|
|
// Assumptions:
|
|
// The INF for pComponent has already been re-run so that the potentially
|
|
// new values for UpperRange, LowerRange, etc. are present in the registry.
|
|
//
|
|
// pComponent has had its external data loaded already.
|
|
//
|
|
HRESULT
|
|
CModifyContext::HrUpdateComponent (
|
|
IN CComponent* pComponent,
|
|
IN DWORD dwSetupFlags,
|
|
IN DWORD dwUpgradeFromBuildNo)
|
|
{
|
|
TraceFileFunc(ttidNetcfgBase);
|
|
|
|
HRESULT hr;
|
|
CNetConfig* pNetConfig;
|
|
CBindingSet OldBindPaths;
|
|
CBindingSet NewBindPaths;
|
|
CBindPath* pScan;
|
|
|
|
Assert (this);
|
|
Assert (S_OK == m_hr);
|
|
Assert (m_fPrepared);
|
|
Assert (pComponent);
|
|
|
|
pNetConfig = PNetConfig();
|
|
|
|
// Now that we actually are going to modify something, push a new
|
|
// recursion depth.
|
|
//
|
|
PushRecursionDepth();
|
|
Assert (S_OK == m_hr);
|
|
|
|
// Generate the "old" bindings by noting those which involve the
|
|
// component.
|
|
//
|
|
hr = pNetConfig->Core.HrGetBindingsInvolvingComponent (
|
|
pComponent,
|
|
GBF_ONLY_WHICH_CONTAIN_COMPONENT,
|
|
&OldBindPaths);
|
|
if (S_OK != hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Reload the external data so we pickup what the possibly updated
|
|
// INF has changed.
|
|
//
|
|
hr = pComponent->Ext.HrReloadExternalData ();
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
goto finished;
|
|
}
|
|
|
|
// Update the stack table entries for the component.
|
|
//
|
|
|
|
hr = pNetConfig->Core.StackTable.HrUpdateEntriesForComponent (
|
|
pComponent,
|
|
&pNetConfig->Core.Components,
|
|
INS_SORTED);
|
|
if (S_OK != hr)
|
|
{
|
|
// This is not good. We ripped out the stack entries and failed
|
|
// putting them back in. The stack table now has no entries for
|
|
// this component. Prevent this from being applied by setting the
|
|
// modify context's HRESULT to the error.
|
|
//
|
|
m_hr = hr;
|
|
goto finished;
|
|
}
|
|
|
|
// Generate the "new" bindings by noting those which involve the
|
|
// component.
|
|
//
|
|
hr = pNetConfig->Core.HrGetBindingsInvolvingComponent (
|
|
pComponent,
|
|
GBF_ONLY_WHICH_CONTAIN_COMPONENT,
|
|
&NewBindPaths);
|
|
if (S_OK != hr)
|
|
{
|
|
// Probably out of memory. Prevent apply by setting the modify
|
|
// context's HRESULT to the error.
|
|
//
|
|
m_hr = hr;
|
|
goto finished;
|
|
}
|
|
|
|
// Notify any bindpaths which have been removed.
|
|
//
|
|
for (pScan = OldBindPaths.begin();
|
|
pScan != OldBindPaths.end();
|
|
pScan++)
|
|
{
|
|
if (NewBindPaths.FContainsBindPath (pScan))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
m_DeletedBindPaths.HrAddBindPath (pScan, INS_IGNORE_IF_DUP | INS_APPEND);
|
|
pNetConfig->Core.DisabledBindings.RemoveBindPath (pScan);
|
|
pNetConfig->Notify.NotifyBindPath (NCN_REMOVE, pScan, NULL);
|
|
}
|
|
|
|
// Notify any bindpaths which have been added.
|
|
//
|
|
for (pScan = NewBindPaths.begin();
|
|
pScan != NewBindPaths.end();
|
|
pScan++)
|
|
{
|
|
if (OldBindPaths.FContainsBindPath (pScan))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
m_AddedBindPaths.HrAddBindPath (pScan, INS_IGNORE_IF_DUP | INS_APPEND);
|
|
pNetConfig->Notify.NotifyBindPath (NCN_ADD | NCN_ENABLE, pScan, NULL);
|
|
}
|
|
|
|
// Notify that the component has been updated.
|
|
//
|
|
pNetConfig->Notify.ComponentUpdated (pComponent,
|
|
dwSetupFlags,
|
|
dwUpgradeFromBuildNo);
|
|
|
|
finished:
|
|
|
|
hr = HrPopRecursionDepth();
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"CModifyContext::HrUpdateComponent (%S)",
|
|
pComponent->PszGetPnpIdOrInfId());
|
|
return hr;
|
|
}
|
|
|