1898 lines
60 KiB
C++
1898 lines
60 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: N C N E T C F G . C P P
|
|
//
|
|
// Contents: Common routines for dealing with INetCfg interfaces.
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: shaunco 24 Mar 1997
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include <pch.h>
|
|
#pragma hdrstop
|
|
#include "netcfgx.h"
|
|
#include "netcfgn.h"
|
|
#include "netcfgp.h"
|
|
#include "ncdebug.h"
|
|
#include "ncbase.h"
|
|
#include "ncmisc.h"
|
|
#include "ncnetcfg.h"
|
|
#include "ncreg.h"
|
|
#include "ncvalid.h"
|
|
|
|
extern const WCHAR c_szRegKeyAnswerFileMap[];
|
|
extern const WCHAR c_szInfId_MS_AppleTalk[];
|
|
extern const WCHAR c_szInfId_MS_AtmArps[];
|
|
extern const WCHAR c_szInfId_MS_AtmElan[];
|
|
extern const WCHAR c_szInfId_MS_AtmLane[];
|
|
extern const WCHAR c_szInfId_MS_AtmUni[];
|
|
extern const WCHAR c_szInfId_MS_DHCPServer[];
|
|
extern const WCHAR c_szInfId_MS_FPNW[];
|
|
extern const WCHAR c_szInfId_MS_GPC[];
|
|
extern const WCHAR c_szInfId_MS_IrDA[];
|
|
extern const WCHAR c_szInfId_MS_IrdaMiniport[];
|
|
extern const WCHAR c_szInfId_MS_IrModemMiniport[];
|
|
extern const WCHAR c_szInfId_MS_Isotpsys[];
|
|
extern const WCHAR c_szInfId_MS_L2TP[];
|
|
extern const WCHAR c_szInfId_MS_L2tpMiniport[];
|
|
extern const WCHAR c_szInfId_MS_MSClient[];
|
|
extern const WCHAR c_szInfId_MS_NdisWan[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanAtalk[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanBh[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanIp[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanIpx[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanNbfIn[];
|
|
extern const WCHAR c_szInfId_MS_NdisWanNbfOut[];
|
|
extern const WCHAR c_szInfId_MS_NetBIOS[];
|
|
extern const WCHAR c_szInfId_MS_NetBT[];
|
|
extern const WCHAR c_szInfId_MS_NetBT_SMB[];
|
|
extern const WCHAR c_szInfId_MS_NetMon[];
|
|
extern const WCHAR c_szInfId_MS_NWClient[];
|
|
extern const WCHAR c_szInfId_MS_NWIPX[];
|
|
extern const WCHAR c_szInfId_MS_NWNB[];
|
|
extern const WCHAR c_szInfId_MS_NwSapAgent[];
|
|
extern const WCHAR c_szInfId_MS_NWSPX[];
|
|
extern const WCHAR c_szInfId_MS_PPPOE[];
|
|
extern const WCHAR c_szInfId_MS_PppoeMiniport[];
|
|
extern const WCHAR c_szInfId_MS_PPTP[];
|
|
extern const WCHAR c_szInfId_MS_PptpMiniport[];
|
|
extern const WCHAR c_szInfId_MS_PSched[];
|
|
extern const WCHAR c_szInfId_MS_PSchedMP[];
|
|
extern const WCHAR c_szInfId_MS_PSchedPC[];
|
|
extern const WCHAR c_szInfId_MS_PtiMiniport[];
|
|
extern const WCHAR c_szInfId_MS_RasCli[];
|
|
extern const WCHAR c_szInfId_MS_RasMan[];
|
|
extern const WCHAR c_szInfId_MS_RasSrv[];
|
|
extern const WCHAR c_szInfId_MS_RawWan[];
|
|
extern const WCHAR c_szInfId_MS_RSVP[];
|
|
extern const WCHAR c_szInfId_MS_Server[];
|
|
extern const WCHAR c_szInfId_MS_Steelhead[];
|
|
extern const WCHAR c_szInfId_MS_Streams[];
|
|
extern const WCHAR c_szInfId_MS_TCPIP[];
|
|
|
|
|
|
#pragma BEGIN_CONST_SECTION
|
|
|
|
// Warning: This must stay sorted on component id!
|
|
// Hint: With VSlick, use 'sort_on_selection AI' to resort this.
|
|
//
|
|
extern const __declspec(selectany) COMPONENT_INFO c_mapComponents [] =
|
|
{
|
|
{ c_szInfId_MS_AppleTalk, &GUID_DEVCLASS_NETTRANS, L"netatlk.inf" },
|
|
{ c_szInfId_MS_AtmArps, &GUID_DEVCLASS_NETTRANS, L"netaarps.inf"},
|
|
{ c_szInfId_MS_AtmElan, &GUID_DEVCLASS_NET, L"netlanem.inf"},
|
|
{ c_szInfId_MS_AtmLane, &GUID_DEVCLASS_NETTRANS, L"netlanep.inf"},
|
|
{ c_szInfId_MS_AtmUni, &GUID_DEVCLASS_NETTRANS, L"netauni.inf"},
|
|
{ c_szInfId_MS_DHCPServer, &GUID_DEVCLASS_NETSERVICE, L"netdhcps.inf" },
|
|
{ c_szInfId_MS_FPNW, &GUID_DEVCLASS_NETSERVICE, L"netsfn.inf" },
|
|
{ c_szInfId_MS_GPC, &GUID_DEVCLASS_NET, L"netgpc.inf" },
|
|
{ c_szInfId_MS_IrDA, &GUID_DEVCLASS_NETTRANS, L"netirda.inf" },
|
|
{ c_szInfId_MS_IrdaMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_IrModemMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_Isotpsys, &GUID_DEVCLASS_NETTRANS, L"nettp4.inf" },
|
|
{ c_szInfId_MS_L2TP, &GUID_DEVCLASS_NETTRANS, L"netrast.inf" },
|
|
{ c_szInfId_MS_L2tpMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_MSClient, &GUID_DEVCLASS_NETCLIENT, L"netmscli.inf" },
|
|
{ c_szInfId_MS_NdisWan, &GUID_DEVCLASS_NETTRANS, L"netrast.inf" },
|
|
{ c_szInfId_MS_NdisWanAtalk, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NdisWanBh, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NdisWanIp, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NdisWanIpx, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NdisWanNbfIn, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NdisWanNbfOut, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_NetBIOS, &GUID_DEVCLASS_NETSERVICE, L"netnb.inf" },
|
|
{ c_szInfId_MS_NetBT, &GUID_DEVCLASS_NETTRANS, L"nettcpip.inf" },
|
|
{ c_szInfId_MS_NetBT_SMB, &GUID_DEVCLASS_NETTRANS, L"nettcpip.inf" },
|
|
{ c_szInfId_MS_NetMon, &GUID_DEVCLASS_NETTRANS, L"netnm.inf" },
|
|
{ c_szInfId_MS_NWClient, &GUID_DEVCLASS_NETCLIENT, L"netnwcli.inf" },
|
|
{ c_szInfId_MS_NWIPX, &GUID_DEVCLASS_NETTRANS, L"netnwlnk.inf" },
|
|
{ c_szInfId_MS_NWNB, &GUID_DEVCLASS_NETTRANS, L"netnwlnk.inf" },
|
|
{ c_szInfId_MS_NwSapAgent, &GUID_DEVCLASS_NETSERVICE, L"netsap.inf" },
|
|
{ c_szInfId_MS_NWSPX, &GUID_DEVCLASS_NETTRANS, L"netnwlnk.inf" },
|
|
{ c_szInfId_MS_PPPOE, &GUID_DEVCLASS_NETTRANS, L"netrast.inf" },
|
|
{ c_szInfId_MS_PppoeMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_PPTP, &GUID_DEVCLASS_NETTRANS, L"netrast.inf" },
|
|
{ c_szInfId_MS_PptpMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_PSched, &GUID_DEVCLASS_NETSERVICE, L"netpschd.inf" },
|
|
{ c_szInfId_MS_PSchedMP, &GUID_DEVCLASS_NET, L"netpsa.inf" },
|
|
{ c_szInfId_MS_PSchedPC, &GUID_DEVCLASS_NETSERVICE, L"netpschd.inf" },
|
|
{ c_szInfId_MS_PtiMiniport, &GUID_DEVCLASS_NET, L"netrasa.inf" },
|
|
{ c_szInfId_MS_RasCli, &GUID_DEVCLASS_NETSERVICE, L"netrass.inf" },
|
|
{ c_szInfId_MS_RasMan, &GUID_DEVCLASS_NETSERVICE, L"netrass.inf" },
|
|
{ c_szInfId_MS_RasSrv, &GUID_DEVCLASS_NETSERVICE, L"netrass.inf" },
|
|
{ c_szInfId_MS_RawWan, &GUID_DEVCLASS_NETTRANS, L"netrwan.inf" },
|
|
{ c_szInfId_MS_RSVP, &GUID_DEVCLASS_NETSERVICE, L"netrsvp.inf"},
|
|
{ c_szInfId_MS_Server, &GUID_DEVCLASS_NETSERVICE, L"netserv.inf" },
|
|
{ c_szInfId_MS_Steelhead, &GUID_DEVCLASS_NETSERVICE, L"netrass.inf" },
|
|
{ c_szInfId_MS_Streams, &GUID_DEVCLASS_NETTRANS, L"netstrm.inf" },
|
|
{ c_szInfId_MS_TCPIP, &GUID_DEVCLASS_NETTRANS, L"nettcpip.inf" },
|
|
{ L"ms_wanarp", &GUID_DEVCLASS_NET, L"netrast.inf" },
|
|
};
|
|
|
|
#pragma END_CONST_SECTION
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: NCompareComponentIds
|
|
//
|
|
// Purpose: Compare function for bsearch.
|
|
//
|
|
// Arguments:
|
|
// ppszComp1 [in] pointer to pointer to a component id
|
|
// ppszComp2 [in] pointer to pointer to a component id
|
|
//
|
|
// Returns: < 0 if pvComp1 is less than pvComp2
|
|
// 0 if they are equal
|
|
// > 0 if pvComp1 is greater than pvComp2
|
|
//
|
|
// Author: shaunco 27 Jul 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
int __cdecl
|
|
NCompareComponentIds (
|
|
IN const PCWSTR* ppszComp1,
|
|
IN const PCWSTR* ppszComp2)
|
|
{
|
|
return lstrcmpiW (*ppszComp1, *ppszComp2);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PComponentInfoFromComponentId
|
|
//
|
|
// Purpose: Return the COMPONENT_INFO record within c_mapComponents
|
|
// having the specified component id.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] The requested component id.
|
|
//
|
|
// Returns: NULL if not found.
|
|
//
|
|
// Author: shaunco 27 Jul 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
inline
|
|
const COMPONENT_INFO*
|
|
PComponentInfoFromComponentId (
|
|
PCWSTR pszComponentId)
|
|
{
|
|
// For debug builds, check that c_mapComponents is sorted properley.
|
|
// If it isn't, bsearch (called below) won't work. Only perform this
|
|
// check once because the map doesn't change.
|
|
//
|
|
#ifdef DBG
|
|
static BOOL fCheckedSorted = FALSE;
|
|
|
|
if (!fCheckedSorted)
|
|
{
|
|
fCheckedSorted = TRUE;
|
|
|
|
for (UINT i = 1; i < celems (c_mapComponents); i++)
|
|
{
|
|
PCWSTR pszComp1 = c_mapComponents [i-1].pszComponentId;
|
|
PCWSTR pszComp2 = c_mapComponents [i] .pszComponentId;
|
|
if (NCompareComponentIds (&pszComp1, &pszComp2) >= 0)
|
|
{
|
|
AssertFmt (FALSE, FAL,
|
|
"'%S' in c_mapComponents is out of order! "
|
|
"Component installation may fail in bizarre ways!",
|
|
pszComp2);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
typedef int (__cdecl *PFNCOMPARE)(const void *, const void *);
|
|
|
|
PFNCOMPARE pfn = reinterpret_cast<PFNCOMPARE>(NCompareComponentIds);
|
|
|
|
return static_cast<const COMPONENT_INFO*>
|
|
(bsearch (&pszComponentId,
|
|
&c_mapComponents->pszComponentId,
|
|
celems (c_mapComponents),
|
|
sizeof (c_mapComponents[0]),
|
|
pfn));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FClassGuidFromComponentId
|
|
//
|
|
// Purpose: Given a component id, returns the class guid associated with
|
|
// it.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] Component id to look up.
|
|
// pguidClass [out] Class guid to be returned.
|
|
//
|
|
// Returns: TRUE if component was found, FALSE if not.
|
|
//
|
|
// Author: danielwe 17 Jun 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL
|
|
FClassGuidFromComponentId (
|
|
PCWSTR pszComponentId,
|
|
const GUID** ppguidClass)
|
|
{
|
|
Assert(ppguidClass);
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
*ppguidClass = NULL;
|
|
|
|
const COMPONENT_INFO* pComponentInfo =
|
|
PComponentInfoFromComponentId (pszComponentId);
|
|
if (pComponentInfo)
|
|
{
|
|
*ppguidClass = pComponentInfo->pguidClass;
|
|
return TRUE;
|
|
}
|
|
TraceTag (ttidNetcfgBase,
|
|
"Found no match for %S in FClassGuidFromComponentId.",
|
|
pszComponentId);
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FInfFileFromComponentId
|
|
//
|
|
// Purpose: Given a component ID, returns the INF file name it lives in.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] Component id to look up.
|
|
// pszInfFile [out] INF file name to be returned.
|
|
// (must be _MAX_PATH long).
|
|
//
|
|
// Returns: TRUE if component was found, FALSE if not.
|
|
//
|
|
// Author: shaunco 27 Jul 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL
|
|
FInfFileFromComponentId (
|
|
PCWSTR pszComponentId,
|
|
PWSTR pszInfFile)
|
|
{
|
|
Assert(pszComponentId);
|
|
Assert(pszInfFile);
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
*pszInfFile = 0;
|
|
|
|
const COMPONENT_INFO* pComponentInfo =
|
|
PComponentInfoFromComponentId (pszComponentId);
|
|
if (pComponentInfo)
|
|
{
|
|
wcsncpy (pszInfFile, pComponentInfo->pszInfFile, _MAX_PATH);
|
|
pszInfFile [_MAX_PATH - 1] = 0;
|
|
return TRUE;
|
|
}
|
|
TraceTag (ttidNetcfgBase,
|
|
"Found no match for %S in FInfFileFromComponentId.",
|
|
pszComponentId);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FGetInstanceGuidOfComponentFromAnswerFileMap
|
|
//
|
|
// Purpose: Maps a component instance in the answer file to
|
|
// its instance guid.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] Name of component to get guid of.
|
|
// pguid [out] Returns instance GUID of that component.
|
|
//
|
|
// Returns: TRUE if successful, FALSE if the component was not located.
|
|
//
|
|
BOOL
|
|
FGetInstanceGuidOfComponentFromAnswerFileMap (
|
|
IN PCWSTR pszComponentId,
|
|
OUT GUID* pguid)
|
|
{
|
|
|
|
HRESULT hr;
|
|
BOOL fFound = FALSE;
|
|
|
|
// Component not found as already installed. Need to examine the
|
|
// AnswerFileMap in the registry.
|
|
//
|
|
HKEY hkey;
|
|
hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyAnswerFileMap,
|
|
KEY_QUERY_VALUE, &hkey);
|
|
if (S_OK == hr)
|
|
{
|
|
WCHAR szGuid [c_cchGuidWithTerm];
|
|
DWORD cbData = sizeof (szGuid);
|
|
hr = HrRegQuerySzBuffer(hkey, pszComponentId, szGuid, &cbData);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = IIDFromString(szGuid, pguid);
|
|
fFound = (S_OK == hr);
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
#ifdef ENABLETRACE
|
|
if (FAILED(hr))
|
|
{
|
|
TraceTag(ttidNetcfgBase, "FGetInstanceGuidOfComponentInAnswerFile: "
|
|
"could not locate instance GUID of %S", pszComponentId);
|
|
}
|
|
#endif
|
|
|
|
return fFound;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FGetInstanceGuidOfComponentInAnswerFile
|
|
//
|
|
// Purpose: Maps a component instance in the answer file to
|
|
// its instance guid.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] Name of component to get guid of.
|
|
// pnc [in] INetCfg interface
|
|
// pguid [out] Returns instance GUID of that component.
|
|
//
|
|
// Returns: TRUE if successful, FALSE if the component was not located.
|
|
//
|
|
BOOL
|
|
FGetInstanceGuidOfComponentInAnswerFile(
|
|
IN PCWSTR pszComponentId,
|
|
IN INetCfg* pnc,
|
|
OUT LPGUID pguid)
|
|
{
|
|
static char __FUNCNAME__[] = "FGetInstanceGuidOfComponentInAnswerFile";
|
|
|
|
Assert (pszComponentId);
|
|
AssertValidReadPtr(pnc);
|
|
AssertValidWritePtr(pguid);
|
|
|
|
// Search for the component.
|
|
//
|
|
INetCfgComponent* pncc;
|
|
HRESULT hr = pnc->FindComponent (pszComponentId, &pncc);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pncc->GetInstanceGuid (pguid);
|
|
ReleaseObj(pncc);
|
|
}
|
|
else
|
|
{
|
|
// Component not found as already installed. Need to examine the
|
|
// AnswerFileMap in the registry.
|
|
//
|
|
HKEY hkey;
|
|
hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyAnswerFileMap,
|
|
KEY_QUERY_VALUE, &hkey);
|
|
if (S_OK == hr)
|
|
{
|
|
WCHAR szGuid [c_cchGuidWithTerm];
|
|
DWORD cbData = sizeof (szGuid);
|
|
hr = HrRegQuerySzBuffer(hkey, pszComponentId, szGuid, &cbData);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = IIDFromString(szGuid, pguid);
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
#ifdef ENABLETRACE
|
|
if (FAILED(hr))
|
|
{
|
|
TraceTag(ttidNetcfgBase, "%s: could not locate instance GUID of %S",
|
|
__FUNCNAME__, pszComponentId);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TraceHr(ttidError, FAL, hr, (S_FALSE == hr), __FUNCNAME__);
|
|
return (SUCCEEDED(hr)) ? TRUE : FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FIsBindingName
|
|
//
|
|
// Purpose: Returns TRUE if a binding interface is of the specified name.
|
|
//
|
|
// Arguments:
|
|
// pszName [in] Name of the binding interface to check for.
|
|
// dwFlags [in] FIBN_ flags
|
|
// pncbi [in] Binding interface pointer.
|
|
//
|
|
// Returns: TRUE if the binding interface is of the specified name.
|
|
//
|
|
// Author: shaunco 24 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL
|
|
FIsBindingName (
|
|
PCWSTR pszName,
|
|
DWORD dwFlags,
|
|
INetCfgBindingInterface* pncbi)
|
|
{
|
|
Assert (pszName);
|
|
Assert (pncbi);
|
|
|
|
BOOL fRet = FALSE;
|
|
PWSTR pszInterfaceName;
|
|
if (SUCCEEDED(pncbi->GetName (&pszInterfaceName)))
|
|
{
|
|
INT c_cchPrefix = (FIBN_PREFIX & dwFlags) ? lstrlenW (pszName) : -1;
|
|
|
|
fRet = (2 == CompareStringW (LOCALE_SYSTEM_DEFAULT, 0,
|
|
pszName, c_cchPrefix,
|
|
pszInterfaceName, c_cchPrefix));
|
|
|
|
CoTaskMemFree (pszInterfaceName);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FIsComponentId
|
|
//
|
|
// Purpose: Returns TRUE if a component is of the specified id.
|
|
//
|
|
// Arguments:
|
|
// pszComponentId [in] Component Id to check for.
|
|
// pncc [in] Component interface pointer.
|
|
//
|
|
// Returns: TRUE if component is of the specified id.
|
|
//
|
|
// Author: shaunco 24 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL
|
|
FIsComponentId (
|
|
PCWSTR pszComponentId,
|
|
INetCfgComponent* pncc)
|
|
{
|
|
Assert (pszComponentId);
|
|
Assert (pncc);
|
|
|
|
BOOL fRet = FALSE;
|
|
PWSTR pszId;
|
|
if (SUCCEEDED(pncc->GetId (&pszId)))
|
|
{
|
|
if (FEqualComponentId (pszComponentId, pszId))
|
|
fRet = TRUE;
|
|
|
|
CoTaskMemFree (pszId);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrAddOrRemoveAdapter
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// pszComponentId [in] component INF id.
|
|
// dwFlags [in]
|
|
//
|
|
// ARA_ADD : Add the component
|
|
// ARA_REMOVE : Remove the component. Cannot be specified
|
|
// with ARA_ADD.
|
|
// pOboToken [in] If specified, refcount the adapter. This is the
|
|
// on behalf of token adding or removing the specified
|
|
// component. This allows per-component reference
|
|
// counts of another.
|
|
// cInstances [in] this specifies how many instances (or references)
|
|
// to add or remove.
|
|
// ppncc [out] (optional). The newly added component. Can only
|
|
// be specified when adding one component.
|
|
//
|
|
// Returns: S_OK or an error
|
|
//
|
|
// Author: shaunco 28 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrAddOrRemoveAdapter (
|
|
INetCfg* pnc,
|
|
PCWSTR pszComponentId,
|
|
DWORD dwFlags,
|
|
OBO_TOKEN* pOboToken,
|
|
UINT cInstances,
|
|
INetCfgComponent** ppncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pszComponentId);
|
|
Assert (dwFlags);
|
|
Assert (cInstances);
|
|
|
|
#ifdef DBG
|
|
AssertSz ((dwFlags & ARA_ADD) || (dwFlags & ARA_REMOVE),
|
|
"Need to add or remove. Can't do neither.");
|
|
|
|
if (dwFlags & ARA_ADD)
|
|
{
|
|
AssertSz (!(dwFlags & ARA_REMOVE), "Can't remove AND add.");
|
|
}
|
|
if (dwFlags & ARA_REMOVE)
|
|
{
|
|
AssertSz (!(dwFlags & ARA_ADD), "Can't add AND remove.");
|
|
}
|
|
AssertSz (FImplies(1 != cInstances, NULL == ppncc),
|
|
"Can't return ppncc when cInstances is greater than one.");
|
|
AssertSz (FImplies(ppncc, 1 == cInstances),
|
|
"Can only add one instance when returning ppncc.");
|
|
AssertSz (FImplies(ppncc, dwFlags & ARA_ADD),
|
|
"Can't return ppncc when removing.");
|
|
#endif
|
|
|
|
// Get the component class object for adapters.
|
|
INetCfgClass* pncclass;
|
|
HRESULT hr = pnc->QueryNetCfgClass (&GUID_DEVCLASS_NET, IID_INetCfgClass,
|
|
reinterpret_cast<void**>(&pncclass));
|
|
if (S_OK == hr)
|
|
{
|
|
INetCfgClassSetup* pncclasssetup;
|
|
hr = pncclass->QueryInterface (IID_INetCfgClassSetup,
|
|
reinterpret_cast<void**>(&pncclasssetup));
|
|
if (S_OK == hr)
|
|
{
|
|
if (dwFlags & ARA_ADD)
|
|
{
|
|
// Install the component the specified number of times.
|
|
//
|
|
while (SUCCEEDED(hr) && cInstances--)
|
|
{
|
|
hr = pncclasssetup->Install(pszComponentId, pOboToken,
|
|
0, 0, NULL, NULL, ppncc );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Remove the component the specified number of times.
|
|
//
|
|
AssertSz(S_OK == hr, "hr should be S_OK here to make sure the "
|
|
"loop is given a chance.");
|
|
while (SUCCEEDED(hr) && cInstances)
|
|
{
|
|
// Find and remove the component.
|
|
//
|
|
INetCfgComponent* pncc;
|
|
hr = pncclass->FindComponent (pszComponentId, &pncc);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pncclasssetup->DeInstall (pncc,
|
|
pOboToken, NULL);
|
|
|
|
cInstances--;
|
|
|
|
ReleaseObj (pncc);
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
// If it wasn't found, get out.
|
|
break;
|
|
}
|
|
}
|
|
AssertSz (FImplies(SUCCEEDED(hr), (0 == cInstances)),
|
|
"cInstances should be zero. This assert means "
|
|
"that we were asked to remove more instances than "
|
|
"were installed.");
|
|
}
|
|
|
|
// Normalize the HRESULT.
|
|
// Possible values of hr at this point are S_FALSE,
|
|
// NETCFG_S_REBOOT, and NETCFG_S_STILL_REFERENCED.
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
ReleaseObj( pncclasssetup );
|
|
}
|
|
ReleaseObj (pncclass);
|
|
}
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrAddOrRemoveAdapter");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveAllInstancesOfAdapter
|
|
//
|
|
// Purpose: Remove all instances of the adapter with the specified
|
|
// component id.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pszComponentId [in] Component id to search for and remove.
|
|
//
|
|
// Returns: S_OK or an error code
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveAllInstancesOfAdapter (
|
|
INetCfg* pnc,
|
|
PCWSTR pszComponentId)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pszComponentId);
|
|
|
|
PCWSTR apszComponentId [1];
|
|
apszComponentId[0] = pszComponentId;
|
|
|
|
HRESULT hr = HrFindAndRemoveAllInstancesOfAdapters (pnc,
|
|
1, apszComponentId);
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"HrFindAndRemoveAllInstancesOfAdapter");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveAllInstancesOfAdapters
|
|
//
|
|
// Purpose: Remove all instances of the adapters with the specified
|
|
// component ids.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// cComponents [in] Count of component ids in the array.
|
|
// apszComponentId [in] Array of compoennt ids to search for and
|
|
// remove.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveAllInstancesOfAdapters (
|
|
INetCfg* pnc,
|
|
ULONG cComponents,
|
|
const PCWSTR* apszComponentId)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apszComponentId);
|
|
|
|
// Get the class object for adapters.
|
|
INetCfgClass* pncclass;
|
|
INetCfgClassSetup* pncclasssetup;
|
|
|
|
HRESULT hr = pnc->QueryNetCfgClass (&GUID_DEVCLASS_NET,
|
|
IID_INetCfgClass,
|
|
reinterpret_cast<void**>(&pncclass));
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pncclass->QueryInterface (IID_INetCfgClassSetup,
|
|
reinterpret_cast<void**>(&pncclasssetup));
|
|
if (S_OK == hr)
|
|
{
|
|
for (ULONG i = 0; (i < cComponents) && SUCCEEDED(hr); i++)
|
|
{
|
|
// Find and remove all instances of the component.
|
|
INetCfgComponent* pncc;
|
|
|
|
while ((SUCCEEDED(hr)) &&
|
|
(S_OK == (hr = pncclass->FindComponent (
|
|
apszComponentId[i], &pncc))))
|
|
{
|
|
hr = pncclasssetup->DeInstall (pncc, NULL, NULL);
|
|
ReleaseObj (pncc);
|
|
}
|
|
|
|
// Normalize the HRESULT.
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
ReleaseObj (pncclasssetup);
|
|
}
|
|
ReleaseObj (pncclass);
|
|
}
|
|
TraceHr (ttidError, FAL, hr, FALSE,
|
|
"HrFindAndRemoveAllInstancesOfAdapters");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveComponent
|
|
//
|
|
// Purpose: Find and remove the component with the specified id.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pguidClass [in] Class GUID of the component.
|
|
// pszComponentId [in] Component id to search for and remove.
|
|
// pOboToken [in] (Optional) If specified, remove on behalf of.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED, or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveComponent (
|
|
INetCfg* pnc,
|
|
const GUID* pguidClass,
|
|
PCWSTR pszComponentId,
|
|
OBO_TOKEN* pOboToken)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pguidClass);
|
|
Assert (pszComponentId);
|
|
AssertSz (GUID_DEVCLASS_NET != *pguidClass,
|
|
"Don't use this to remove adapters.");
|
|
|
|
// Get the component class object.
|
|
//
|
|
INetCfgClass* pncclass;
|
|
HRESULT hr = pnc->QueryNetCfgClass (pguidClass, IID_INetCfgClass,
|
|
reinterpret_cast<void**>(&pncclass));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Find the component to remove.
|
|
//
|
|
INetCfgComponent* pnccRemove;
|
|
hr = pncclass->FindComponent (pszComponentId, &pnccRemove);
|
|
if (S_OK == hr)
|
|
{
|
|
INetCfgClassSetup* pncclasssetup;
|
|
hr = pncclass->QueryInterface (IID_INetCfgClassSetup,
|
|
reinterpret_cast<void**>(&pncclasssetup));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pncclasssetup->DeInstall (pnccRemove, pOboToken, NULL);
|
|
|
|
ReleaseObj (pncclasssetup);
|
|
}
|
|
|
|
ReleaseObj (pnccRemove);
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
ReleaseObj (pncclass);
|
|
}
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrFindAndRemoveComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveComponents
|
|
//
|
|
// Purpose: Find and remove the components with the specified ids.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// cComponents [in] Count of components in the array.
|
|
// apguidClass [in] Array of class GUIDs corresponding to the
|
|
// array of component ids.
|
|
// apszComponentId [in] Array of component ids to search for and
|
|
// remove.
|
|
// pOboToken [in] (Optional) If specified, remove on behalf of.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED, or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveComponents (
|
|
INetCfg* pnc,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId,
|
|
OBO_TOKEN* pOboToken)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apguidClass);
|
|
Assert (apszComponentId);
|
|
|
|
HRESULT hr = S_OK;
|
|
for (ULONG i = 0; (i < cComponents) && SUCCEEDED(hr); i++)
|
|
{
|
|
hr = HrFindAndRemoveComponent (pnc, apguidClass[i],
|
|
apszComponentId[i], pOboToken);
|
|
}
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrFindAndRemoveComponents");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveComponentsOboComponent
|
|
//
|
|
// Purpose: Remove multiple components on behalf of one component.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// cComponents [in] count of class guid pointers and component id
|
|
// pointers.
|
|
// apguidClass [in] array of class guid pointers.
|
|
// apszId [in] array of component id pointers.
|
|
// pnccObo [in] the component requesting the remove. (i.e. the
|
|
// "on behalf of" component.)
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED, or an error code.
|
|
//
|
|
// Author: shaunco 13 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveComponentsOboComponent (
|
|
INetCfg* pnc,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId,
|
|
INetCfgComponent* pnccObo)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apguidClass);
|
|
Assert (apszComponentId);
|
|
Assert (pnccObo);
|
|
|
|
// Make an "on behalf of" token for the requesting component.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_COMPONENT;
|
|
OboToken.pncc = pnccObo;
|
|
|
|
HRESULT hr = HrFindAndRemoveComponents (pnc, cComponents,
|
|
apguidClass, apszComponentId, &OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrFindAndRemoveComponentsOboComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindAndRemoveComponentsOboUser
|
|
//
|
|
// Purpose: Remove multiple components on behalf of one component.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// cComponents [in] count of class guid pointers and component id
|
|
// pointers.
|
|
// apguidClass [in] array of class guid pointers.
|
|
// apszId [in] array of component id pointers.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED, or an error code.
|
|
//
|
|
// Author: shaunco 13 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindAndRemoveComponentsOboUser (
|
|
INetCfg* pnc,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apguidClass);
|
|
Assert (apszComponentId);
|
|
|
|
// Make an "on behalf of" token for the user.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_USER;
|
|
|
|
HRESULT hr = HrFindAndRemoveComponents (pnc, cComponents,
|
|
apguidClass, apszComponentId, &OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrFindAndRemoveComponentsOboUser");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindComponents
|
|
//
|
|
// Purpose: Find multiple INetCfgComponents with one call. This makes
|
|
// the error handling associated with multiple calls to
|
|
// QueryNetCfgClass and Find much easier.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to INetCfg object
|
|
// cComponents [in] count of class guid pointers, component id
|
|
// pointers, and INetCfgComponent output pointers.
|
|
// apguidClass [in] array of class guid pointers.
|
|
// apszComponentId [in] array of component id pointers.
|
|
// apncc [out] array of returned INetCfgComponet pointers.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 22 Mar 1997
|
|
//
|
|
// Notes: cComponents is the count of pointers in all three arrays.
|
|
// S_OK will still be returned even if no components were
|
|
// found! This is by design.
|
|
//
|
|
HRESULT
|
|
HrFindComponents (
|
|
INetCfg* pnc,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId,
|
|
INetCfgComponent** apncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apguidClass);
|
|
Assert (apszComponentId);
|
|
Assert (apncc);
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
ZeroMemory (apncc, cComponents * sizeof(*apncc));
|
|
|
|
// Find all of the components requested.
|
|
// Variable initialization is important here.
|
|
HRESULT hr = S_OK;
|
|
ULONG i;
|
|
for (i = 0; (i < cComponents) && SUCCEEDED(hr); i++)
|
|
{
|
|
// Get the class object for this component.
|
|
INetCfgClass* pncclass;
|
|
hr = pnc->QueryNetCfgClass (apguidClass[i], IID_INetCfgClass,
|
|
reinterpret_cast<void**>(&pncclass));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Find the component.
|
|
hr = pncclass->FindComponent (apszComponentId[i], &apncc[i]);
|
|
|
|
AssertSz (SUCCEEDED(hr), "pncclass->Find failed.");
|
|
|
|
ReleaseObj (pncclass);
|
|
}
|
|
}
|
|
|
|
// On any error, release what we found and set the output to NULL.
|
|
if (FAILED(hr))
|
|
{
|
|
for (i = 0; i < cComponents; i++)
|
|
{
|
|
ReleaseObj (apncc[i]);
|
|
apncc[i] = NULL;
|
|
}
|
|
}
|
|
// Otherwise, normalize the HRESULT. (i.e. don't return S_FALSE)
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrFindComponents");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrGetBindingInterfaceComponents
|
|
//
|
|
// Purpose: Get both upper and lower components involved in a
|
|
// binding interface.
|
|
//
|
|
// Arguments:
|
|
// pncbi [in] binding interface.
|
|
// ppnccUpper [out] output upper component.
|
|
// ppnccLower [out] output lower compoenet.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 18 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrGetBindingInterfaceComponents (
|
|
INetCfgBindingInterface* pncbi,
|
|
INetCfgComponent** ppnccUpper,
|
|
INetCfgComponent** ppnccLower)
|
|
{
|
|
Assert (pncbi);
|
|
Assert (ppnccUpper);
|
|
Assert (ppnccLower);
|
|
|
|
// Initialize the output parameters.
|
|
*ppnccUpper = NULL;
|
|
*ppnccLower = NULL;
|
|
|
|
INetCfgComponent* pnccUpper;
|
|
HRESULT hr = pncbi->GetUpperComponent (&pnccUpper);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
INetCfgComponent* pnccLower;
|
|
hr = pncbi->GetLowerComponent (&pnccLower);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppnccUpper = pnccUpper;
|
|
*ppnccLower = pnccLower;
|
|
}
|
|
else
|
|
{
|
|
// Rather than AddRef this in the above SUCCEEDED block followed
|
|
// by the normal unconditional Release, just Release here in
|
|
// the case of failure to get the lower component.
|
|
ReleaseObj (pnccUpper);
|
|
}
|
|
}
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrGetBindingInterfaceComponents");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponent
|
|
//
|
|
// Purpose: Install the component with a specified id.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pnip [in] (Optional) If specified, perform the installation
|
|
// using the answer file.
|
|
// pguidClass [in] Class guid of the component to install.
|
|
// pszComponentId [in] Component id to install.
|
|
// pOboToken [in] (Optional) If specified, perform the installation
|
|
// on behalf of this token.
|
|
// ppncc [out] (Optional) Returned component that was
|
|
// installed.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponent (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
const GUID* pguidClass,
|
|
PCWSTR pszComponentId,
|
|
OBO_TOKEN* pOboToken,
|
|
INetCfgComponent** ppncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pszComponentId);
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
if (ppncc)
|
|
{
|
|
*ppncc = NULL;
|
|
}
|
|
|
|
// Get the class setup object.
|
|
//
|
|
INetCfgClassSetup* pncclasssetup;
|
|
HRESULT hr = pnc->QueryNetCfgClass (pguidClass, IID_INetCfgClassSetup,
|
|
reinterpret_cast<void**>(&pncclasssetup));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pnip)
|
|
{
|
|
hr = pncclasssetup->Install (
|
|
pszComponentId,
|
|
pOboToken,
|
|
pnip->dwSetupFlags,
|
|
pnip->dwUpgradeFromBuildNo,
|
|
pnip->pszAnswerFile,
|
|
pnip->pszAnswerSection,
|
|
ppncc);
|
|
}
|
|
else
|
|
{
|
|
hr = pncclasssetup->Install (pszComponentId,
|
|
pOboToken, 0, 0, NULL, NULL, ppncc);
|
|
}
|
|
|
|
ReleaseObj (pncclasssetup);
|
|
}
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponent (%S)", pszComponentId);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponents
|
|
//
|
|
// Purpose: Install the components with the specified ids.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pnip [in] (Optional) If specified, perform the installation
|
|
// using the answer file.
|
|
// cComponents [in] Count of components in the arrays.
|
|
// apguidClass [in] Array of class guids for the specified components.
|
|
// apszComponentId [in] Array of component ids to install.
|
|
// pOboToken [in] (Optional) If specified, perform the installation
|
|
// on behalf of this token.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponents (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId,
|
|
OBO_TOKEN* pOboToken)
|
|
{
|
|
Assert (pnc);
|
|
Assert (cComponents);
|
|
Assert (apguidClass);
|
|
Assert (apszComponentId);
|
|
|
|
HRESULT hr = S_OK;
|
|
for (ULONG i = 0; (i < cComponents) && SUCCEEDED(hr); i++)
|
|
{
|
|
hr = HrInstallComponent (pnc, pnip,
|
|
apguidClass[i], apszComponentId[i], pOboToken, NULL);
|
|
}
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponents");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponentsOboComponent
|
|
//
|
|
// Purpose: Install multiple components on behalf of one component.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// pnip [in] (Optional) pointer to network install parameters.
|
|
// If non-NULL, a network install is performed,
|
|
// otherwise a normal install is performed.
|
|
// cComponents [in] count of class guid pointers and component id
|
|
// pointers.
|
|
// apguidClass [in] array of class guid pointers.
|
|
// apszComponentId [in] array of component id pointers.
|
|
// pnccObo [in] the component requesting the install. (i.e. the
|
|
// "on behalf of" component.)
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 13 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponentsOboComponent (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId,
|
|
INetCfgComponent* pnccObo)
|
|
{
|
|
Assert (pnccObo);
|
|
|
|
// Make an "on behalf of" token for the requesting component.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_COMPONENT;
|
|
OboToken.pncc = pnccObo;
|
|
|
|
HRESULT hr = HrInstallComponents (pnc, pnip, cComponents, apguidClass,
|
|
apszComponentId, &OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponentsOboComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponentsOboUser
|
|
//
|
|
// Purpose: Install multiple components on behalf of the user.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pnip [in] (Optional) If specified, perform the installation
|
|
// using the answer file.
|
|
// cComponents [in] Count of components in the arrays.
|
|
// apguidClass [in] Array of class guids for the specified components.
|
|
// apszComponentId [in] Array of component ids to install.
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponentsOboUser (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
ULONG cComponents,
|
|
const GUID** apguidClass,
|
|
const PCWSTR* apszComponentId)
|
|
{
|
|
// Make an "on behalf of" token for the user.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_USER;
|
|
|
|
HRESULT hr = HrInstallComponents (pnc, pnip, cComponents, apguidClass,
|
|
apszComponentId, &OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponentsOboUser");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponentOboComponent
|
|
//
|
|
// Purpose: Installs a component on behalf of another. If the component
|
|
// is already installed, it reference count is incremented on
|
|
// behalf of the component doing the install. When one
|
|
// component calls this function to install another, it is
|
|
// saying that it has a depencency on the component being
|
|
// installed. This dependency will prevent even the user from
|
|
// removing the component.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// pnip [in] (Optional) pointer to network install parameters.
|
|
// If non-NULL, a network install is performed,
|
|
// otherwise a normal install is performed.
|
|
// rguid [in] class GUID of the component being installed.
|
|
// pszComponentId [in] component INF id of the component being installed.
|
|
// pnccObo [in] the component requesting the install. (i.e. the
|
|
// "on behalf of" component.)
|
|
// ppncc [out] (Optional) set on return to the previously
|
|
// installed component or the one that was installed.
|
|
//
|
|
// Returns: S_OK or an error.
|
|
//
|
|
// Author: shaunco 7 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponentOboComponent (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
const GUID& rguid,
|
|
PCWSTR pszComponentId,
|
|
INetCfgComponent* pnccObo,
|
|
INetCfgComponent** ppncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pszComponentId);
|
|
Assert (pnccObo);
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
if (ppncc)
|
|
{
|
|
*ppncc = NULL;
|
|
}
|
|
|
|
// Make an "on behalf of" token for the requesting component.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_COMPONENT;
|
|
OboToken.pncc = pnccObo;
|
|
|
|
HRESULT hr = HrInstallComponent (pnc, pnip, &rguid, pszComponentId,
|
|
&OboToken, ppncc);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponentOboComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponentOboSoftware
|
|
//
|
|
// Purpose: Installs a component on behalf of a piece of software.
|
|
// If the component is already installed, it's reference count
|
|
// is incremented on behalf of the indicated software piece.
|
|
// This is useful for a component to call
|
|
// when it is installing another component as a convienience for
|
|
// the user. The user can then remove the component with no
|
|
// ill-effects for the component that called this function.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// pnip [in] (Optional) pointer to network install parameters.
|
|
// If non-NULL, a network install is performed,
|
|
// otherwise a normal install is performed.
|
|
// rguid [in] class GUID of the component being installed.
|
|
// pszComponentId [in] component INF id of the component being installed.
|
|
// pszManufacturer [in] Manufacturer name of software.
|
|
// pszProduct [in] Product name of software.
|
|
// pszDisplayName [in] Full display name of software.
|
|
// ppncc [out] (Optional) set on return to the previously
|
|
// installed component or the one that was installed.
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: danielwe 5 May 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponentOboSoftware (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
const GUID& rguid,
|
|
PCWSTR pszComponentId,
|
|
PCWSTR pszManufacturer,
|
|
PCWSTR pszProduct,
|
|
PCWSTR pszDisplayName,
|
|
INetCfgComponent** ppncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pszComponentId);
|
|
Assert (pszManufacturer);
|
|
Assert (pszDisplayName);
|
|
Assert (pszProduct);
|
|
AssertSz (GUID_DEVCLASS_NET != rguid, "Don't use this to install adapters.");
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
if (ppncc)
|
|
{
|
|
*ppncc = NULL;
|
|
}
|
|
|
|
// Make an "on behalf of" token for the software.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_SOFTWARE;
|
|
OboToken.pszwManufacturer = pszManufacturer;
|
|
OboToken.pszwProduct = pszProduct;
|
|
OboToken.pszwDisplayName = pszDisplayName;
|
|
|
|
HRESULT hr = HrInstallComponent (pnc, pnip, &rguid, pszComponentId,
|
|
&OboToken, ppncc);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponentOboSoftware");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallComponentOboUser
|
|
//
|
|
// Purpose: Installs a component on behalf of the user. If the component
|
|
// is already installed, it reference count is incremented on
|
|
// behalf of the user. This is useful for a component to call
|
|
// when it is installing another component as a convienience for
|
|
// the user. The user can then remove the component with no
|
|
// ill-effects for the component that called this function.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// pnip [in] (Optional) pointer to network install parameters.
|
|
// If non-NULL, a network install is performed,
|
|
// otherwise a normal install is performed.
|
|
// rguid [in] class GUID of the component being installed.
|
|
// pszComponentId [in] component INF id of the component being installed.
|
|
// ppncc [out] (Optional) set on return to the previously
|
|
// installed component or the one that was installed.
|
|
//
|
|
// Returns: S_OK or an error.
|
|
//
|
|
// Author: shaunco 7 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrInstallComponentOboUser (
|
|
INetCfg* pnc,
|
|
const NETWORK_INSTALL_PARAMS* pnip,
|
|
const GUID& rguid,
|
|
PCWSTR pszComponentId,
|
|
INetCfgComponent** ppncc)
|
|
{
|
|
Assert (pnc);
|
|
Assert (&rguid);
|
|
Assert (pszComponentId);
|
|
AssertSz (GUID_DEVCLASS_NET != rguid, "Don't use this to install adapters.");
|
|
|
|
// Initialize output parameter.
|
|
//
|
|
if (ppncc)
|
|
{
|
|
*ppncc = NULL;
|
|
}
|
|
|
|
// Make an "on behalf of" token for the user.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_USER;
|
|
|
|
HRESULT hr = HrInstallComponent (pnc, pnip, &rguid, pszComponentId,
|
|
&OboToken, ppncc);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallComponentOboUser");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrInstallRasIfNeeded
|
|
//
|
|
// Purpose: Install RAS services on behalf of the user. No need to
|
|
// check first as we install on behalf of the user which is
|
|
// implicilty checked.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer to use
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 30 Aug 1997
|
|
//
|
|
// Notes:
|
|
// (shaunco) 10 Sep 1997: Don't install RAS Server for Beta1.
|
|
// DHCP addresses get eaten up too quickly. For Beta2, it will be
|
|
// installed but disabled.
|
|
//
|
|
// (shaunco) 20 Dec 1997: We used to install RAS Server only on NTS.
|
|
// We now install it always but its set to not start automatically.
|
|
//
|
|
HRESULT
|
|
HrInstallRasIfNeeded (
|
|
INetCfg* pnc)
|
|
{
|
|
Assert (pnc);
|
|
|
|
static const GUID* c_apguidInstalledComponentClasses [] =
|
|
{
|
|
&GUID_DEVCLASS_NETSERVICE, // RasCli
|
|
&GUID_DEVCLASS_NETSERVICE, // RasSrv
|
|
};
|
|
|
|
static const PCWSTR c_apszInstalledComponentIds [] =
|
|
{
|
|
c_szInfId_MS_RasCli,
|
|
c_szInfId_MS_RasSrv,
|
|
};
|
|
|
|
HRESULT hr = HrInstallComponentsOboUser (pnc, NULL,
|
|
celems (c_apguidInstalledComponentClasses),
|
|
c_apguidInstalledComponentClasses,
|
|
c_apszInstalledComponentIds);
|
|
|
|
TraceHr (ttidError, FAL, hr, (NETCFG_S_REBOOT == hr),
|
|
"HrInstallRasIfNeeded");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrQueryNotifyObject
|
|
//
|
|
// Purpose: Helper function to call QueryNotifyObject given an
|
|
// INetCfgComponent. (Saves the intermediate QI.)
|
|
//
|
|
// Arguments:
|
|
// pncc [in] INetCfgComponent to call QueryNotifyObject on.
|
|
// riid [in] Requested interface identifier.
|
|
// ppvObject [out] Address of pointer to return the requested interface.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 2 Sep 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrQueryNotifyObject (
|
|
INetCfgComponent* pncc,
|
|
REFIID riid,
|
|
VOID** ppvObject)
|
|
{
|
|
Assert (pncc);
|
|
Assert (ppvObject);
|
|
|
|
// Initialize the output parameter.
|
|
//
|
|
*ppvObject = NULL;
|
|
|
|
// First, QI for the component private interface.
|
|
//
|
|
INetCfgComponentPrivate* pPrivate;
|
|
HRESULT hr = pncc->QueryInterface(
|
|
IID_INetCfgComponentPrivate,
|
|
reinterpret_cast<VOID**>(&pPrivate));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Now query the notify object for the requested interface.
|
|
//
|
|
hr = pPrivate->QueryNotifyObject (riid, ppvObject);
|
|
|
|
ReleaseObj (pPrivate);
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrQueryNotifyObject");
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRemoveComponent
|
|
//
|
|
// Purpose: Remove the specified component.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] INetCfg pointer.
|
|
// pnccToRemove [in] Component to remove.
|
|
// pOboToken [in] (Optional) If specified, remove the component
|
|
// on behalf of this token.
|
|
// pmszRefs [out] (Optional) Returns Multi-Sz of components that
|
|
// still reference this one. NOTE: This will be NULL
|
|
// if the return value is not
|
|
// NETCFG_S_STILL_REFERENCED
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED, or an error code.
|
|
//
|
|
// Author: shaunco 4 Jan 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRemoveComponent (
|
|
INetCfg* pnc,
|
|
INetCfgComponent* pnccToRemove,
|
|
OBO_TOKEN* pOboToken,
|
|
PWSTR * pmszRefs)
|
|
{
|
|
Assert (pnc);
|
|
Assert (pnccToRemove);
|
|
|
|
// Get the class setup interface for this component.
|
|
//
|
|
GUID guidClass;
|
|
HRESULT hr = pnccToRemove->GetClassGuid (&guidClass);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Use the class setup interface to remove the component.
|
|
//
|
|
INetCfgClassSetup* pSetup;
|
|
hr = pnc->QueryNetCfgClass (&guidClass,
|
|
IID_INetCfgClassSetup,
|
|
reinterpret_cast<void**>(&pSetup));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pSetup->DeInstall (pnccToRemove, pOboToken, pmszRefs);
|
|
ReleaseObj (pSetup);
|
|
}
|
|
}
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrRemoveComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRemoveComponentOboComponent
|
|
//
|
|
// Purpose: Removes a component previously installed by another.
|
|
// Effectively balances a call to HrInstallComponentOboComponent().
|
|
// The reference count of the component is decremented and,
|
|
// if it is zero, the component is removed from the system.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// rguidClass [in] class GUID of the component being removed.
|
|
// pszComponentId [in] component INF id of the component being removed.
|
|
// pnccObo [in] the component requesting the removal.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED or an error.
|
|
//
|
|
// Author: shaunco 7 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRemoveComponentOboComponent (
|
|
INetCfg* pnc,
|
|
const GUID& rguidClass,
|
|
PCWSTR pszComponentId,
|
|
INetCfgComponent* pnccObo)
|
|
{
|
|
// Make an "on behalf of" token for the requesting component.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_COMPONENT;
|
|
OboToken.pncc = pnccObo;
|
|
|
|
HRESULT hr = HrFindAndRemoveComponent (pnc, &rguidClass, pszComponentId,
|
|
&OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrRemoveComponentOboComponent");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRemoveComponentOboSoftware
|
|
//
|
|
// Purpose: Removes a component previously installed by some software
|
|
// entity. Effectively balances a call to
|
|
// HrAddComponentOboSoftware(). The reference count of the
|
|
// component is decremented and, if it is zero, the component
|
|
// is removed from the system.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// rguidClass [in] class GUID of the component being removed.
|
|
// pszComponentId [in] component INF id of the component being removed.
|
|
// pszManufacturer [in] Manufacturer name of software.
|
|
// pszProduct [in] Product name of software.
|
|
// pszDisplayName [in] Full display name of software.
|
|
// pnccObo [in] the component requesting the removal.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED or an error.
|
|
//
|
|
// Author: jeffspr 13 Jun 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRemoveComponentOboSoftware (
|
|
INetCfg* pnc,
|
|
const GUID& rguidClass,
|
|
PCWSTR pszComponentId,
|
|
PCWSTR pszManufacturer,
|
|
PCWSTR pszProduct,
|
|
PCWSTR pszDisplayName)
|
|
{
|
|
// Make an "on behalf of" token for the software.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_SOFTWARE;
|
|
OboToken.pszwManufacturer = pszManufacturer;
|
|
OboToken.pszwProduct = pszProduct;
|
|
OboToken.pszwDisplayName = pszDisplayName;
|
|
|
|
HRESULT hr = HrFindAndRemoveComponent (pnc, &rguidClass, pszComponentId,
|
|
&OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrRemoveComponentOboSoftware");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRemoveComponentOboUser
|
|
//
|
|
// Purpose: Removes a component previously installed by the user.
|
|
// Effectively balances a call to HrAddComponentOboUser().
|
|
// The reference count of the component is decremented and,
|
|
// if it is zero, the component is removed from the system.
|
|
//
|
|
// Arguments:
|
|
// pnc [in] pointer to an INetCfg object.
|
|
// rguidClass [in] class GUID of the component being removed.
|
|
// pszComponentId [in] component INF id of the component being removed.
|
|
//
|
|
// Returns: S_OK, NETCFG_S_STILL_REFERENCED or an error.
|
|
//
|
|
// Author: shaunco 7 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRemoveComponentOboUser (
|
|
INetCfg* pnc,
|
|
const GUID& rguidClass,
|
|
PCWSTR pszComponentId)
|
|
{
|
|
// Make an "on behalf of" token for the user.
|
|
//
|
|
OBO_TOKEN OboToken;
|
|
ZeroMemory (&OboToken, sizeof(OboToken));
|
|
OboToken.Type = OBO_USER;
|
|
|
|
HRESULT hr = HrFindAndRemoveComponent (pnc, &rguidClass, pszComponentId,
|
|
&OboToken);
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(NETCFG_S_REBOOT == hr) || (NETCFG_S_STILL_REFERENCED == hr),
|
|
"HrRemoveComponentOboUser");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrGetLastComponentAndInterface
|
|
//
|
|
// Purpose: This function enumerates a binding path, returns the last
|
|
// component on the path and optionally return the last binding
|
|
// interface name in this path.
|
|
//
|
|
// Arguments:
|
|
// pncbp [in] The INetCfgBindingPath *
|
|
// ppncc [out] The INetCfgComponent * of the last component on the path
|
|
// ppszInterfaceName [out] The interface name of the last binding interface of the path
|
|
//
|
|
// Returns: S_OK, or an error.
|
|
//
|
|
// Author: tongl 5 Dec 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrGetLastComponentAndInterface (
|
|
INetCfgBindingPath* pncbp,
|
|
INetCfgComponent** ppncc,
|
|
PWSTR* ppszInterfaceName)
|
|
{
|
|
Assert(pncbp);
|
|
|
|
// Initialize output parameters.
|
|
//
|
|
*ppncc = NULL;
|
|
if (ppszInterfaceName)
|
|
{
|
|
*ppszInterfaceName = NULL;
|
|
}
|
|
|
|
// Enumerate binding interfaces and keep track of
|
|
// the last interface.
|
|
//
|
|
HRESULT hr = S_OK;
|
|
CIterNetCfgBindingInterface ncbiIter(pncbp);
|
|
INetCfgBindingInterface* pncbi;
|
|
INetCfgBindingInterface* pncbiLast = NULL;
|
|
|
|
while(SUCCEEDED(hr) && (hr = ncbiIter.HrNext(&pncbi)) == S_OK)
|
|
{
|
|
ReleaseObj (pncbiLast);
|
|
pncbiLast = pncbi;
|
|
}
|
|
|
|
if (S_FALSE == hr) // we got to the end of the loop
|
|
{
|
|
hr = S_OK;
|
|
|
|
Assert (pncbiLast);
|
|
|
|
INetCfgComponent* pnccLowerComponent;
|
|
hr = pncbiLast->GetLowerComponent(&pnccLowerComponent);
|
|
if (S_OK == hr)
|
|
{
|
|
// Get the name of the interface if requested.
|
|
//
|
|
if (ppszInterfaceName)
|
|
{
|
|
hr = pncbiLast->GetName(ppszInterfaceName);
|
|
}
|
|
|
|
// If we've succeded everything, (including the optional
|
|
// return of the interface name above) then assign and addref
|
|
// the output interface.
|
|
//
|
|
if (S_OK == hr)
|
|
{
|
|
AddRefObj (pnccLowerComponent);
|
|
*ppncc = pnccLowerComponent;
|
|
}
|
|
|
|
// Important to release our use of this interface in case
|
|
// we failed and didn't assign it as an output parameter.
|
|
//
|
|
ReleaseObj (pnccLowerComponent);
|
|
}
|
|
}
|
|
|
|
// Don't forget to release the binding interface itself.
|
|
//
|
|
ReleaseObj (pncbiLast);
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrGetLastComponentAndInterface");
|
|
return hr;
|
|
}
|