able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/hmonitor/hmagent/copypaste.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1420 lines
46 KiB
C++
Raw Blame History

//***************************************************************************
//
// COPYPASTE.CPP
//
// Module: HEALTHMON SERVER AGENT
//
// Purpose: Copying and pasting code below.
//
// Copyright (c)2000 Microsoft Corporation, All Rights Reserved
//
//***************************************************************************
#pragma warning (disable: 4786) // exceeds 255 chars in browser info
#define _WIN32_DCOM
#include "global.h"
#include "system.h"
#define ASSERT MY_ASSERT
#define TRACE(x) MY_OUTPUT(x, 4)
#include <comdef.h>
#include <wbemcli.h>
#include "SafeArray.h"
#include "StringMap.h"
// smart pointers for common WMI types
_COM_SMARTPTR_TYPEDEF(IWbemLocator, __uuidof(IWbemLocator));
_COM_SMARTPTR_TYPEDEF(IWbemServices, __uuidof(IWbemServices));
_COM_SMARTPTR_TYPEDEF(IWbemClassObject, __uuidof(IWbemClassObject));
_COM_SMARTPTR_TYPEDEF(IWbemQualifierSet, __uuidof(IWbemQualifierSet));
_COM_SMARTPTR_TYPEDEF(IWbemObjectSink, __uuidof(IWbemObjectSink));
_COM_SMARTPTR_TYPEDEF(IEnumWbemClassObject, __uuidof(IEnumWbemClassObject));
// a bunch of constant strings. Enables us to change class names without a lot of cut
// and paste
static const _bstr_t bstrLocalHealthMonNamespace(L"\\\\.\\ROOT\\CIMV2\\MicrosoftHealthMonitor");
static const _bstr_t bstrHealthMonNamespace(L"ROOT\\CIMV2\\MicrosoftHealthMonitor");
static const _bstr_t bstrBaseConfigurationPath(L"MicrosoftHM_Configuration");
static const _bstr_t bstrFilterToConsumerBindingClassPath(L"__FilterToConsumerBinding");
static const _bstr_t bstrEventConsumerClassPath(L"__EventConsumer");
static const _bstr_t bstrEventFilterClassPath(L"__EventFilter");
static const _bstr_t bstrActionAssocClassPath(L"MicrosoftHM_ConfigurationActionAssociation");
static const _bstr_t bstrActionConfigurationClassPath(L"MicrosoftHM_ActionConfiguration");
static const _bstr_t bstrTopPath(L"MicrosoftHM_SystemConfiguration.GUID=\"{@}\"");
static const _bstr_t bstrTopGUID(L"{@}");
static const _bstr_t bstrConfigurationAssocClassPath(L"MicrosoftHM_ConfigurationAssociation");
static const _bstr_t bstrThresholdConfigurationClassPath(L"MicrosoftHM_ThresholdConfiguration");
static const _bstr_t bstrDataCollectorConfigurationClassPath(L"MicrosoftHM_DataCollectorConfiguration");
static const _bstr_t bstrDataGroupConfigurationClassPath(L"MicrosoftHM_DataGroupConfiguration");
static const _bstr_t bstrSystemConfigurationClassPath(L"MicrosoftHM_SystemConfiguration");
static const _bstr_t strLanguage(L"WQL");
static const _bstr_t MOFFileHeader1(
L"////////////////////////////////////////////////////////\n"
L"// Automatically generated Health Monitor MOF dump\n"
L"// Parent Root = "
);
static const _bstr_t MOFFileHeader2(
L"\n"
L"////////////////////////////////////////////////////////\n"
L"\n"
L"#pragma autorecover\n"
L"#pragma namespace(\"\\\\\\\\.\\\\ROOT\\\\CIMV2\\\\MicrosoftHealthMonitor\")\n"
L"\n"
L"\n");
// get a BSTR-valued property
static HRESULT GetStringProperty (IWbemClassObject* pObj,
LPCWSTR lpszPropName,
_bstr_t& bstr)
{
_variant_t var;
CHECK_ERROR (pObj->Get(lpszPropName, 0, &var, NULL, NULL));
if (V_VT(&var) != VT_BSTR)
{
CHECK_ERROR (E_INVALIDARG); // bad data type. should never happen
}
CHECK_ERROR (SafeAssign (bstr, var));
return S_OK;
}
static HRESULT GetUint32Property (IWbemClassObject* pObj,
LPCWSTR lpszPropName,
DWORD& val)
{
_variant_t var;
CHECK_ERROR (pObj->Get(lpszPropName, 0, &var, NULL, NULL));
if (V_VT(&var) != VT_I4)
{
CHECK_ERROR (E_INVALIDARG); // bad data type. should never happen
}
val = V_I4(&var);
return S_OK;
}
// get a BSTR-valued property
static HRESULT PutStringProperty (IWbemClassObject* pObj,
LPCWSTR lpszPropName,
const _bstr_t& bstr)
{
_variant_t var;
CHECK_ERROR (SafeAssign (var, bstr));
CHECK_ERROR (pObj->Put(lpszPropName, 0, &var, NULL));
return S_OK;
}
static HRESULT CompareInstances (IWbemClassObject* pObj1, IWbemClassObject* pObj2, bool& bMatch)
{
// compare all the properties of these two instances
if (pObj1 == NULL || pObj2 == NULL)
return WBEM_E_INVALID_PARAMETER;
HRESULT hr = S_OK;
CHECK_ERROR (pObj1->BeginEnumeration (WBEM_FLAG_NONSYSTEM_ONLY));
while (TRUE)
{
// get property.
BSTR bstrVal;
hr = pObj1->Next(0, &bstrVal, NULL, NULL, NULL );
if (hr == WBEM_S_NO_MORE_DATA)
break; // BREAK OUT!!!! We're done.
else if (FAILED (hr))
break;
_bstr_t bstrName(bstrVal, false); // false for attach and auto-free
_variant_t var1, var2;
CIMTYPE eType1, eType2;
if (pObj1->Get(bstrName, 0, &var1, &eType1, NULL))
break;
if (pObj2->Get(bstrName, 0, &var2, &eType2, NULL))
break;
if (eType1 != eType2)
{
bMatch = false; // differnet CIM types
break;
}
else if (var1 != var2)
{
bMatch = false; // differnet values
break;
}
}
if (FAILED (hr))
{
pObj1->EndEnumeration (); // clean up just in case
CHECK_ERROR (hr);
}
CHECK_ERROR (pObj1->EndEnumeration ());
bMatch = true;
return WBEM_S_NO_ERROR;
}
// Same as Clone(), but works across machine boundaries. Clone()
// only works on local instances.
static HRESULT CopyInstance (IWbemServicesPtr& WMI,
IWbemClassObjectPtr& pObj1,
IWbemClassObjectPtr& pObj2)
{
// first, get the class so that we can spawn a new instance
_bstr_t bstrClass;
IWbemClassObjectPtr smartpClass;
CHECK_ERROR (GetStringProperty(pObj1, L"__CLASS", bstrClass));
CHECK_ERROR (WMI->GetObject (bstrClass,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpClass,
NULL));
CHECK_ERROR (smartpClass->SpawnInstance (0, &pObj2));
HRESULT hr = S_OK;
CHECK_ERROR (pObj1->BeginEnumeration (WBEM_FLAG_NONSYSTEM_ONLY));
while (TRUE)
{
// get property name
BSTR bstrVal;
hr = pObj1->Next(0, &bstrVal, NULL, NULL, NULL );
if (hr == WBEM_S_NO_MORE_DATA)
break; // BREAK OUT!!!! We're done.
else if (FAILED (hr))
break;
_bstr_t bstrName(bstrVal, false); // false for attach and auto-free
// get the property on one and copy to the other
_variant_t var;
CIMTYPE eType1;
if (FAILED(hr = pObj1->Get(bstrName, 0, &var, &eType1, NULL)))
break;
if (FAILED(hr = pObj2->Put(bstrName, 0, &var, 0)))
break;
}
if (FAILED (hr))
{
pObj1->EndEnumeration (); // clean up just in case
CHECK_ERROR (hr);
}
CHECK_ERROR (pObj1->EndEnumeration ());
return WBEM_S_NO_ERROR;
}
//
// escape a string so that it's OK to put in an object path
//
static HRESULT WmiPathEscape (LPCWSTR pszPath, _bstr_t& ResultPath)
{
// first, allocate a string twice as big. (escaping never exceeds 2x size)
BSTR bstr = ::SysAllocStringLen (NULL, wcslen(pszPath)*2);
if (bstr == NULL)
CHECK_ERROR (E_OUTOFMEMORY);
WCHAR *pDest = bstr;
for (LPCWSTR pSrc = pszPath; *pSrc; pSrc++)
{
if (*pSrc == L'\"' || *pSrc == L'\\')
{
*pDest++ = L'\\';
}
*pDest++ = *pSrc; // unescaped char
}
*pDest++ = 0; // null-terminate
CHECK_ERROR (SafeAssign(ResultPath, bstr));
::SysFreeString(bstr); // free this now that copy is made
return S_OK;
}
static HRESULT GetAssociationPath (_bstr_t& strAssocPath,
LPCWSTR szAssocClass,
LPCWSTR szInstance1Role,
LPCWSTR szInstance1Path,
LPCWSTR szInstance2Role,
LPCWSTR szInstance2Path)
{
try
{
// first, escape the object paths so that they can be encased in
// other object paths
_bstr_t bstrInstance1Path, bstrInstance2Path;
CHECK_ERROR (WmiPathEscape(szInstance1Path, bstrInstance1Path))
CHECK_ERROR (WmiPathEscape(szInstance2Path, bstrInstance2Path))
// now construct the association path
strAssocPath = szAssocClass;
strAssocPath += L".";
strAssocPath += szInstance1Role;
strAssocPath += L"=\"";
strAssocPath += bstrInstance1Path;
strAssocPath += L"\",";
strAssocPath += szInstance2Role;
strAssocPath += L"=\"";
strAssocPath += bstrInstance2Path;
strAssocPath += L"\"";
}
catch (_com_error e)
{
CHECK_ERROR (e.Error());
}
return S_OK;
}
// OK, it's an action. There are four instances:
// This method saves them all.
// a) The ConfigurationActionAssication, between the HM object and the action
// b) the action configuration itself
// c) The event filter
// d) the event consumer
// e) the filter-to-consumer binding
static HRESULT AddActionOtherInstances (
SafeArrayOneDimWbemClassObject& saInstances,
int& nArrayIndex,
IWbemClassObjectPtr& smartpParent,
IWbemServices* WMI
)
{
IWbemClassObjectPtr smartpFilter, smartpConsumer, smartpFilterToConsumerBinding;
HRESULT hr;
ULONG nRet;
// First, build paths for the filter & consumer
_bstr_t bstrActionGUID, bstrConsumerPath, bstrFilterPath;
CHECK_ERROR(GetStringProperty(smartpParent, L"GUID", bstrActionGUID));
CHECK_ERROR(GetStringProperty(smartpParent, L"EventConsumer", bstrConsumerPath));
try
{
// The Filter
bstrFilterPath = L"__EventFilter.Name=\"";
bstrFilterPath += bstrActionGUID;
bstrFilterPath += "\"";
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// ok, now that we've got the paths, let's get the objects themselves
CHECK_ERROR (WMI->GetObject (bstrConsumerPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpConsumer,
NULL));
CHECK_ERROR (WMI->GetObject (bstrFilterPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpFilter,
NULL));
// Now query to get the Filter To Consumer Binding
_bstr_t strQueryFTCB;
try
{
strQueryFTCB = L"REFERENCES OF {";
strQueryFTCB += bstrFilterPath;
strQueryFTCB += "} WHERE ResultClass = ";
strQueryFTCB += bstrFilterToConsumerBindingClassPath;
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// now get the Filter-to-consumer binding from WMI.
// note that this must return a valid instance or it's an error!
IEnumWbemClassObjectPtr pEnumFTCB;
CHECK_ERROR (WMI->ExecQuery (strLanguage, strQueryFTCB, 0, NULL, &pEnumFTCB));
hr = pEnumFTCB->Next(5000, 1, &smartpFilterToConsumerBinding, &nRet);
if (FAILED(hr))
CHECK_ERROR (hr); // either S_FALSE (none found) or error
if (hr == WBEM_S_TIMEDOUT)
CHECK_ERROR (RPC_E_TIMEOUT); // it timed out. bad!
if (hr != WBEM_S_NO_ERROR)
CHECK_ERROR (E_FAIL); // no associations found. bad!
// now add'em to the array
CHECK_ERROR (saInstances.SafePutElement(nArrayIndex++, smartpConsumer));
CHECK_ERROR (saInstances.SafePutElement(nArrayIndex++, smartpFilter));
CHECK_ERROR (saInstances.SafePutElement(nArrayIndex++, smartpFilterToConsumerBinding));
return S_OK;
}
static HRESULT BuildInstancesArray (
SafeArrayOneDimWbemClassObject& saInstances,
int& nArrayIndex,
IWbemClassObjectPtr& smartpParent,
IWbemServices* WMI,
bool bCopyActionsOnly = false, // only copy the actions; nothing more
bool bFirstTime = true // recursion?
)
{
ULONG nRet;
HRESULT hr;
ASSERT (smartpParent != NULL);
_bstr_t bstrParentPath;
CHECK_ERROR (GetStringProperty (smartpParent, L"__RELPATH", bstrParentPath));
// Next, deal with children. Depending on what kind of
// configuration class this is, we respond differently
_bstr_t bstrClass;
bool bCanHaveChildren = false;
if (bCopyActionsOnly)
{
bCanHaveChildren = true; // get all the actions
}
else
{
CHECK_ERROR (GetStringProperty(smartpParent,L"__CLASS", bstrClass));
// first time through, we need to store the parent object before we
// recurse to find kids
if (bFirstTime)
{
// if it's an action, store the filter, binding, etc.
// note that we need to store these first, as the
// agent needs to have the configuration show up last.
if (!_wcsicmp (bstrClass, bstrActionConfigurationClassPath))
{
CHECK_ERROR (AddActionOtherInstances (saInstances,
nArrayIndex,
smartpParent,
WMI ));
}
// store the top instance
CHECK_ERROR (saInstances.SafePutElement (nArrayIndex++, smartpParent));
}
if (!_wcsicmp (bstrClass, bstrActionConfigurationClassPath) ||
!_wcsicmp (bstrClass, bstrThresholdConfigurationClassPath))
{
// it's a threshold or action. There are never children.
return WBEM_S_NO_ERROR;
}
else
{
// it may have children. below we will recurse to handle children
bCanHaveChildren = true;
}
}
if (bCanHaveChildren)
{
// build the apppropriate queries to fetch the associators for
// this parent object. Note that there is a weird syntax for the
// ASSOCIATORS OF and REFERENCES OF queries which combines query
// clauses without using AND. See the WMI SDK descripion of
// REFERENCES OF for more details.
_bstr_t bstrQueryChildren;
try
{
// all the actions
if (bCopyActionsOnly)
{
bstrQueryChildren = "SELECT * FROM ";
bstrQueryChildren += bstrActionConfigurationClassPath;
}
else
{
// all the associations referencing us
bstrQueryChildren = L"REFERENCES OF {";
bstrQueryChildren += bstrParentPath;
bstrQueryChildren += "} WHERE ResultClass = ";
bstrQueryChildren += bstrConfigurationAssocClassPath;
bstrQueryChildren += " Role = ParentPath";
}
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
IEnumWbemClassObjectPtr pEnum;
if (FAILED (hr = WMI->ExecQuery (strLanguage, bstrQueryChildren, 0, NULL, &pEnum)))
{
// TRACE (L"%s\n", (LPCTSTR) bstrQueryChildren);
if (hr != WBEM_E_NOT_FOUND) // notfound is OK-- there may be no children. We're done.
{
CHECK_ERROR (hr);
}
}
else // everything is OK. now enumerate
{
_bstr_t bstrParentPath, bstrChildPath;
IWbemClassObjectPtr smartpAssocInstance, smartpInstance;
for ( hr = pEnum->Next(5000, 1, &smartpAssocInstance, &nRet);
SUCCEEDED(hr) && hr == WBEM_S_NO_ERROR;
hr = pEnum->Next(5000, 1, &smartpAssocInstance, &nRet))
{
// if we are just getting the actions,
if (bCopyActionsOnly)
{
// if it's an action, store the filter, binding, etc.
// note that we need to store these first, as the
// agent needs to have the configuration show up last.
CHECK_ERROR (AddActionOtherInstances (saInstances,
nArrayIndex,
smartpAssocInstance,
WMI ));
// store the instance.
CHECK_ERROR (saInstances.SafePutElement (nArrayIndex++, smartpAssocInstance));
}
else
{ // not only the actions
_variant_t var;
// now get the configuration instance that this association
// instance actually points to
CHECK_ERROR (GetStringProperty(smartpAssocInstance,
L"ChildPath",
bstrChildPath));
CHECK_ERROR (WMI->GetObject (bstrChildPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpInstance,
NULL));
// If it's an action, store the other subinstances as well
// note that we need to store the subinstances first, as the
// agent needs to have the configuration show up last.
CHECK_ERROR (GetStringProperty(smartpInstance,L"__CLASS", bstrClass));
if (!_wcsicmp (bstrClass, bstrActionConfigurationClassPath))
{
CHECK_ERROR (AddActionOtherInstances (saInstances,
nArrayIndex,
smartpInstance,
WMI ));
}
// store the instance.
CHECK_ERROR (saInstances.SafePutElement (nArrayIndex++, smartpInstance));
// now put the association in the array
CHECK_ERROR (saInstances.SafePutElement(nArrayIndex++, smartpAssocInstance));
// now recurse to deal with *this* object's children
// note that actions and thresholds have no kids
if (_wcsicmp (bstrClass, bstrActionConfigurationClassPath) != 0 &&
_wcsicmp (bstrClass, bstrThresholdConfigurationClassPath) != 0)
{
CHECK_ERROR (BuildInstancesArray (saInstances,
nArrayIndex,
smartpInstance,
WMI,
false // recursion!
));
}
}
}
if (hr == WBEM_S_TIMEDOUT)
CHECK_ERROR (RPC_E_TIMEOUT); // it timed out. bad!
CHECK_ERROR (hr);
}
}
return WBEM_S_NO_ERROR;
}
enum EGuidType {GUID_PLAIN, GUID_PATH, GUID_QUERY};
static HRESULT ReGuidOneProperty (IWbemClassObjectPtr& pObj,
LPCWSTR wszPropName,
StringToStringMap& GuidMap,
EGuidType eType)
{
// get the current value of the property from WMI
_variant_t var;
CIMTYPE CimType;
CHECK_ERROR (pObj->Get(wszPropName, 0, &var, &CimType, NULL));
if (var.vt != VT_BSTR)
{
ASSERT (FALSE);
return E_FAIL; // bad type of prop!
}
// OK, now pull out the BSTR and remove it from the variant
_bstr_t bstrCurrentPropValue(var.bstrVal, false);
var.Detach();
// now locate the GUID in the string
LPCWSTR pGuidStr;
WCHAR szGUID[39]; // enough space to fit a GUID in Unicode
switch (eType)
{
case GUID_PLAIN:
pGuidStr = bstrCurrentPropValue;
ASSERT (CimType == CIM_STRING);
break;
case GUID_PATH:
pGuidStr = wcschr ((LPWSTR)bstrCurrentPropValue, L'{');
ASSERT (CimType == CIM_REFERENCE);
break;
case GUID_QUERY:
pGuidStr = wcschr ((LPWSTR)bstrCurrentPropValue, L'{');
ASSERT (CimType == CIM_STRING);
break;
}
if (pGuidStr == NULL)
{
ASSERT (FALSE);
return E_FAIL; // corrupt WMI value!
}
LPCWSTR pEndBracket = wcschr (pGuidStr, '}');
if (pEndBracket == NULL)
{
ASSERT (FALSE);
return E_FAIL; // corrupt WMI value!
}
else if (pEndBracket - pGuidStr == 2 && pGuidStr[1] == '@')
{
return S_OK; // it's the system configuration instance.
// No need to re-guid.
}
else if (pEndBracket - pGuidStr != 37 )
{
ASSERT (FALSE);
return E_FAIL; // corrupt WMI value!
}
ASSERT (pGuidStr[0] == '{');
ASSERT (pGuidStr[37] == '}');
// now move the string into temp storage
wcsncpy (szGUID, pGuidStr, 38);
szGUID[38] = 0;
// have we seen this one?
_bstr_t bstrGuidNew;
bool bFound;
CHECK_ERROR (GuidMap.Find (szGUID, bstrGuidNew, bFound));
if (bFound)
{
// OK, we found this GUID there already. Use the preset
// replacement GUID
wcsncpy ((LPWSTR) pGuidStr, bstrGuidNew, 38);
}
else
{
// we haven't already seen this. Generate a new GUID, add it
// to the map
CGuidString strNewGuid;
GuidMap.Add (szGUID, strNewGuid);
wcsncpy ((LPWSTR) pGuidStr, strNewGuid, 38);
}
// OK, now we have a BSTR with the new GUID.
CHECK_ERROR (PutStringProperty (pObj, wszPropName, bstrCurrentPropValue));
return S_OK;
}
// walk through the array looking for GUID's. When we find a GUID,
// we will check a mapping table to see if it is already mapped to another
// GUID. If it is, we will replace it and move on through the list. If
// it isn't in the table, we will generate a new GUID, replace the
// one already there, and store the new GUID in the table
static HRESULT ReGuid(SafeArrayOneDimWbemClassObject& saInstances,
StringToStringMap& aGuidMap )
{
HRESULT hr;
for ( int i = 0, nLen = saInstances.GetSize(); i < nLen; i++)
{
IWbemClassObjectPtr pObj;
CHECK_ERROR (saInstances.GetElement(i, &pObj));
ASSERT (pObj != NULL);
// now check the class of this object. Depending on the class type,
_bstr_t bstrClass, bstrPath;
CHECK_ERROR (GetStringProperty (pObj, L"__RELPATH", bstrPath))
CHECK_ERROR (GetStringProperty (pObj, L"__CLASS", bstrClass));
// now re-guid the appropriate properties
if (!_wcsicmp(bstrClass, bstrActionConfigurationClassPath))
{
hr = ReGuidOneProperty (pObj, L"GUID", aGuidMap, GUID_PLAIN);
hr = ReGuidOneProperty (pObj, L"EventConsumer", aGuidMap, GUID_PATH);
}
else if (pObj->InheritsFrom(bstrBaseConfigurationPath)==S_OK)
{
// it's a configuration class, but not action config. Use the GUID property
hr = ReGuidOneProperty (pObj, L"GUID", aGuidMap, GUID_PLAIN);
}
else if (pObj->InheritsFrom(bstrEventConsumerClassPath)==S_OK)
{
hr = ReGuidOneProperty (pObj, L"Name", aGuidMap, GUID_PLAIN);
}
else if (pObj->InheritsFrom(L"__EventFilter")==S_OK)
{
hr = ReGuidOneProperty (pObj, L"Name", aGuidMap, GUID_PLAIN);
hr = ReGuidOneProperty (pObj, L"Query", aGuidMap, GUID_QUERY);
}
else if (!_wcsicmp(bstrClass, bstrFilterToConsumerBindingClassPath))
{
hr = ReGuidOneProperty (pObj, L"Consumer", aGuidMap, GUID_PATH);
hr = ReGuidOneProperty (pObj, L"Filter", aGuidMap, GUID_PATH);
}
else if (!_wcsicmp(bstrClass, bstrActionAssocClassPath))
{
hr = ReGuidOneProperty (pObj, L"ParentPath", aGuidMap, GUID_PATH);
hr = ReGuidOneProperty (pObj, L"ChildPath", aGuidMap, GUID_PATH);
hr = ReGuidOneProperty (pObj, L"EventFilter", aGuidMap, GUID_PATH);
hr = ReGuidOneProperty (pObj, L"Query", aGuidMap, GUID_QUERY);
}
else if (!_wcsicmp(bstrClass, bstrConfigurationAssocClassPath))
{
hr = ReGuidOneProperty (pObj, L"ParentPath", aGuidMap, GUID_PATH);
hr = ReGuidOneProperty (pObj, L"ChildPath", aGuidMap, GUID_PATH);
}
else
{
ASSERT (FALSE); // should never happen. it's an invalid class.
}
CHECK_ERROR (hr);
}
return S_OK;
}
//
// Detect all actions with duplicate names between the clipboard and the target
// Fill up a GUID map with the dupes
//
static HRESULT FillActionGuidMap( SafeArrayOneDimWbemClassObject& saInstances,
StringToStringMap& ActionNameToGuidMap,
StringToStringMap& GuidMap)
{
for ( int i = 0, nLen = saInstances.GetSize(); i < nLen; i++)
{
IWbemClassObjectPtr pObj;
CHECK_ERROR (saInstances.GetElement(i, &pObj));
ASSERT (pObj != NULL);
_bstr_t bstrClass, bstrPath;
CHECK_ERROR (GetStringProperty (pObj, L"__CLASS", bstrClass));
// now re-guid the appropriate properties
if (_wcsicmp(bstrClass, bstrActionConfigurationClassPath) != 0)
continue; // we only care about actions!
_bstr_t bstrGuidCurrentAction, bstrName;
bool bFound = false;
CHECK_ERROR (GetStringProperty(pObj, L"Name", bstrName));
CHECK_ERROR (ActionNameToGuidMap.Find(bstrName, bstrGuidCurrentAction, bFound));
if (bFound)
{
// there's a duplicate! We'll store a mapping of the GUID in
// the clipboard's instance to the duplicate action GUID.
_bstr_t bstrGUID;
CHECK_ERROR (GetStringProperty (pObj, L"GUID", bstrGUID));
CHECK_ERROR (GuidMap.Add(bstrGUID, bstrGuidCurrentAction));
}
}
return S_OK;
}
static HRESULT Copy(LPTSTR szSourceComputer,
LPTSTR szGUID,
bstr_t& bstrParentGUID, // [out]
SafeArrayOneDimWbemClassObject& saInstances,
CSystem& System)
{
// impersonate the caller. Important since we're now calling into
// WMI and need to make sure caller is allowed
CHECK_ERROR(CoImpersonateClient());
_bstr_t bstrNamespace = L"\\\\";
bstrNamespace += szSourceComputer;
bstrNamespace += L"\\";
bstrNamespace += bstrHealthMonNamespace;
IWbemServicesPtr WMI = g_pIWbemServices;
// IWbemLocatorPtr WMILocator;
// IWbemServicesPtr WMI;
// CHECK_ERROR (WMILocator.CreateInstance(__uuidof(WbemLocator),NULL));
// CHECK_ERROR (WMILocator->ConnectServer (bstrNamespace,
// NULL, NULL, NULL, 0, NULL, NULL,
// &WMI));
_bstr_t bstrPath;
try
{
bstrPath = bstrBaseConfigurationPath;
bstrPath += L".GUID=\"";
bstrPath += szGUID;
bstrPath += L"\"";
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
IWbemClassObjectPtr smartpObj;
HRESULT hr = WMI->GetObject (bstrPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpObj,
NULL);
if (hr == WBEM_E_NOT_FOUND)
{
return WBEM_E_NOT_FOUND; // it's not there
}
CHECK_ERROR (hr);
// if it's a single action, then we fake the parent to be the system instance
// same if it's the entire system that we're copying
_bstr_t bstrClass;
CHECK_ERROR (GetStringProperty(smartpObj, L"__CLASS", bstrClass));
if (!_wcsicmp (bstrClass, bstrActionConfigurationClassPath)
|| !_wcsicmp (bstrClass, bstrSystemConfigurationClassPath))
{
try
{
bstrParentGUID = bstrTopGUID;
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
}
else
{
// build the query to find our parent
_bstr_t bstrParentQuery;
try
{
bstrParentQuery = L"ASSOCIATORS OF {";
bstrParentQuery += bstrPath;
bstrParentQuery += L"} WHERE";
bstrParentQuery += L" ResultRole = ParentPath";
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// now exec the query to fetch the parent
ULONG nRet;
IEnumWbemClassObjectPtr pEnumParent;
IWbemClassObjectPtr smartpParent;
CHECK_ERROR (WMI->ExecQuery (strLanguage, bstrParentQuery, 0, NULL, &pEnumParent));
hr = pEnumParent->Next(5000, 1, &smartpParent, &nRet);
if (FAILED(hr))
CHECK_ERROR (hr);
if (hr == WBEM_S_TIMEDOUT)
CHECK_ERROR (RPC_E_TIMEOUT); // it timed out. bad!
if (hr != WBEM_S_NO_ERROR)
CHECK_ERROR (E_FAIL); // no parent found. bad!
CHECK_ERROR (GetStringProperty(smartpParent, L"GUID", bstrParentGUID));
}
// now actually go get the array
int nArrayIndex = 0;
CHECK_ERROR (saInstances.Clear());
CHECK_ERROR (saInstances.Create());
// now build an array of all the instances underneath this one
CHECK_ERROR (BuildInstancesArray (saInstances,
nArrayIndex,
smartpObj,
WMI));
// now, if this was the entire system that we were copying, copy the
// unattached actions as well.
if (!_wcsicmp (bstrClass, bstrSystemConfigurationClassPath))
{
// now add all the actions to the array
CHECK_ERROR (BuildInstancesArray (saInstances,
nArrayIndex,
smartpObj,
WMI,
true));
}
CHECK_ERROR (saInstances.Resize(nArrayIndex));
return S_OK;
}
// the input is an array of instances to be added, in order. Add them.
// Note that actions will be compared to actions currently on the box.
static HRESULT Paste(LPCTSTR pszTargetComputer,
LPCTSTR pszTargetParentGUID,
LPCTSTR pszOriginalComputer,
LPCTSTR pszOriginalParentGUID,
SAFEARRAY* psa,
BOOL bForceReplace,
CSystem& System)
{
// impersonate the caller. Important since we're now calling into
// WMI and need to make sure caller is allowed
CHECK_ERROR(CoImpersonateClient());
_bstr_t bstrNamespace = L"\\\\";
bstrNamespace += pszTargetComputer;
bstrNamespace += L"\\";
bstrNamespace += bstrHealthMonNamespace;
TCHAR szComputerName[1024];
DWORD dwSize = 1024;
::GetComputerName(szComputerName, &dwSize);
if (!_wcsicmp(szComputerName, pszTargetComputer))
pszTargetComputer = L".";
if (!_wcsicmp(szComputerName, pszOriginalComputer))
pszOriginalComputer = L".";
IWbemServicesPtr WMI = g_pIWbemServices;
HRESULT hr;
// Commented-out code below was used when we were not part of the agent.
// IWbemLocatorPtr WMILocator;
// IWbemServicesPtr WMI;
// CHECK_ERROR (WMILocator.CreateInstance(__uuidof(WbemLocator),NULL));
// CHECK_ERROR (WMILocator->ConnectServer (bstrNamespace,
// NULL, NULL, NULL, 0, NULL, NULL,
// &WMI));
// if we didn't create the array, then don't
// bother proceeding
VARIANT varSA;
varSA.vt = VT_ARRAY | VT_UNKNOWN;
varSA.parray = psa;
if (!SafeArrayOneDimWbemClassObject::IsValid(varSA))
CHECK_ERROR (E_INVALIDARG);
// since we know that it's one of ours, and because our SafeArray wrapper
// is the same length as a regular safe array, we can cast it.
SafeArrayOneDimWbemClassObject& saInstancesOriginal = (SafeArrayOneDimWbemClassObject&)varSA;
// if we're pasting in the same parent, then the behavior should
// match Windows, where you add a " (2)" to the name and make a copy
bool bPasteOnSameMachine = !_wcsicmp (pszTargetComputer,pszOriginalComputer);
bool bPasteInSameFolder = bPasteOnSameMachine &&
!_wcsicmp (pszTargetParentGUID, pszOriginalParentGUID);
_bstr_t bstrParentRelPath;
try
{
bstrParentRelPath = bstrBaseConfigurationPath;
bstrParentRelPath += L".GUID=\"";
bstrParentRelPath += pszTargetParentGUID;
bstrParentRelPath += L"\"";
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// Pasting Algorithm
// ==========================================================
// 1. If child with same name already exists in parent: If bOverwrite = TRUE,
// delete the other guy. If bOverwrite = FALSE, return an error.
// 2. If actions with same name but *different* contents already exists in parent:
// If bOverwrite = TRUE, delete the other actions. If bOverwrite = FALSE,
// return an error.
// 3. If actions with same name and *same* contents already exists in parent,
// reassign the to-be-pasted GUID's to match the target.
// 4. Now simply Put each member of the array.
//===========================================================
// fetch this parent instance
IWbemClassObjectPtr smartpParentInstance;
CHECK_ERROR (WMI->GetObject (bstrParentRelPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpParentInstance,
NULL));
// get the full, normalized path
CHECK_ERROR (GetStringProperty(smartpParentInstance, L"__RELPATH", bstrParentRelPath));
// First, get the top instance of the array. This is the parent
IWbemClassObjectPtr smartpTopInstance;
CHECK_ERROR (saInstancesOriginal.GetElement (0, &smartpTopInstance));
int nTopIndex = 0;
// now get the name of that top instance
_bstr_t bstrTopInstanceName, bstrTopInstanceClass;
CHECK_ERROR (GetStringProperty(smartpTopInstance, L"__CLASS", bstrTopInstanceClass));
if (bstrTopInstanceClass == bstrSystemConfigurationClassPath)
{
// we cannot (yet) paste the entire system
CHECK_ERROR (E_INVALIDARG);
}
// now see if we're only copying actions-- which will be the case if an
// action (or the filter, binding, etc.) is first on the list of instances
// coming back from the Copy command.
// BUGBUG: need to do something better than simply looking for the string
// "Consumer" below-- not all event consumers will contain that string!
bool bIsActionTopInstance =
bstrTopInstanceClass == bstrActionConfigurationClassPath
|| bstrTopInstanceClass == bstrFilterToConsumerBindingClassPath
|| wcsstr ((LPCTSTR) bstrTopInstanceClass, L"Consumer") != NULL
|| bstrTopInstanceClass == bstrEventFilterClassPath;
if (bIsActionTopInstance)
{
// we need to find the name of the action. But the action is not on top-- it could
// be any of the top 4 instances (action config, filter, consumer or binding). So go look.
// we've already checked the zeroth, so we can start at 1.
for (int i = 1; i < 4; i++)
{
CHECK_ERROR (saInstancesOriginal.GetElement (i, &smartpTopInstance));
CHECK_ERROR (GetStringProperty(smartpTopInstance, L"__CLASS", bstrTopInstanceClass));
if (bstrTopInstanceClass == bstrActionConfigurationClassPath)
{
// found it! we will get the name
nTopIndex = i;
break;
}
}
if (i == 4)
{
CHECK_ERROR (E_INVALIDARG); // uh-oh. the instance array was corrupted.
}
}
// finally, get the name of the instance
CHECK_ERROR (GetStringProperty(smartpTopInstance, L"Name", bstrTopInstanceName));
// Build a query to look for siblings in the new parent
_bstr_t bstrQueryChildren;
try
{
if (bIsActionTopInstance)
{
// for actions, there is no parent. Just list all actions
bstrQueryChildren = L"SELECT * FROM MicrosoftHM_ActionConfiguration";
}
else
{
// first, make a query for get kids of this parent
bstrQueryChildren = L"ASSOCIATORS OF {";
bstrQueryChildren += bstrParentRelPath;
bstrQueryChildren += L"} WHERE";
bstrQueryChildren += L" ResultRole = ChildPath";
}
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// now execute this query. Look for siblings with matching (i.e. conflicting) names
StringToStringMap TopLevelNameConflictMap;
_bstr_t bstrConflictGUID;
IEnumWbemClassObjectPtr pEnum;
// TRACE (L"%s\n", (LPCTSTR) bstrQueryChildren);
if (FAILED (hr = WMI->ExecQuery (strLanguage, bstrQueryChildren, 0, NULL, &pEnum)))
{
// TRACE (L"%s\n", (LPCTSTR) bstrQueryChildren);
if (hr != WBEM_E_NOT_FOUND) // notfound is OK-- there may be no children. We're done.
{
CHECK_ERROR (hr);
}
}
else
{
_bstr_t bstrChildName;
IWbemClassObjectPtr smartpInstance;
ULONG nRet;
for ( hr = pEnum->Next(5000, 1, &smartpInstance, &nRet);
SUCCEEDED(hr) && hr == WBEM_S_NO_ERROR;
hr = pEnum->Next(5000, 1, &smartpInstance, &nRet))
{
_bstr_t bstrChildName, bstrChildClass;
CHECK_ERROR (GetStringProperty(smartpInstance, L"Name", bstrChildName));
CHECK_ERROR (GetStringProperty(smartpInstance, L"__CLASS", bstrChildClass));
// if this child is an action, then the only case where we care about
// conflicts is in the top-level. Otherwise, the actions are not really
// "children" (they're just associated via the ConfigActionAssociation class)
// so we can ignore them. But if this is an action as the
// top instance, you bet we want to check for conflicts!
if (!bIsActionTopInstance && (bstrChildClass == bstrActionConfigurationClassPath))
continue;
// store this for later, in case we have to rename the top item.
if (bPasteInSameFolder)
CHECK_ERROR(TopLevelNameConflictMap.Add(bstrChildName, L"NotUsed"));
// check for conflict
if (!_wcsicmp (bstrChildName, bstrTopInstanceName))
{
CHECK_ERROR (GetStringProperty(smartpInstance, L"GUID", bstrConflictGUID));
if (!bPasteInSameFolder)
{
// uh, oh. We have a name conflict. Depending on whether the
// user wants to perform any overwrites, we will either have to
// delete the conflicting one or return an error.
if (bForceReplace)
{
TRACE(L"Paste: Instance Name Conflict. We will delete the conflicting one");
break;
}
else
{
TRACE(L"Paste: Instance Name Conflict. Returning an error.");
return WBEM_E_ALREADY_EXISTS;
}
}
}
}
if (hr == WBEM_S_TIMEDOUT)
CHECK_ERROR (RPC_E_TIMEOUT); // it timed out. bad!
CHECK_ERROR (hr);
}
// OK, Now build a map of the names of actions already on the target
// and their GUID's
try
{
bstrQueryChildren = L"SELECT * FROM ";
bstrQueryChildren += bstrActionConfigurationClassPath;
}
catch (_com_error e)
{
CHECK_ERROR (e.Error()); // out of memory
}
// we will store a hashtable of mapping action names to their
// GUID's. This will help us in re-GUIDing and in identifying conflicts.
StringToStringMap ActionNameToGuidMap;
// now execute this query
if (FAILED (hr = WMI->ExecQuery (strLanguage, bstrQueryChildren, 0, NULL, &pEnum)))
{
// TRACE (L"%s\n", (LPCTSTR) bstrQueryChildren);
if (hr != WBEM_E_NOT_FOUND) // notfound is OK-- there may be no children. We're done.
{
CHECK_ERROR (hr);
}
}
else
{
_bstr_t bstrChildName;
IWbemClassObjectPtr smartpInstance;
ULONG nRet;
for ( hr = pEnum->Next(5000, 1, &smartpInstance, &nRet);
SUCCEEDED(hr) && hr == WBEM_S_NO_ERROR;
hr = pEnum->Next(5000, 1, &smartpInstance, &nRet))
{
_bstr_t bstrActionName, bstrActionGUID;
CHECK_ERROR (GetStringProperty(smartpInstance, L"Name", bstrActionName));
CHECK_ERROR (GetStringProperty(smartpInstance, L"GUID", bstrActionGUID));
CHECK_ERROR (ActionNameToGuidMap.Add(bstrActionName, bstrActionGUID));
}
}
// OK, now we will make a copy of the array.
bool bAlreadyFound = false;
SafeArrayOneDimWbemClassObject saInstancesNew;
CHECK_ERROR (saInstancesNew.Create());
for (int i = 0, nLen = saInstancesOriginal.GetSize(); i < nLen; i++)
{
IWbemClassObjectPtr smartpInstance;
CHECK_ERROR (saInstancesOriginal.GetElement (i, &smartpInstance));
// make a copy & store it. Note that it's a no-no to take instances
// from one machine and PutInstance them on another machine-- they will
// fail intermittently. So we in turn do a "manual clone" here to
// spawn the instance locally and copy the properties one by one
// On the same machine, it's faster and more efficient to use Clone(),
// so we do.
IWbemClassObjectPtr smartpNewInstance;
if (bPasteOnSameMachine)
{
CHECK_ERROR (smartpInstance->Clone(&smartpNewInstance));
}
else
{
CHECK_ERROR (CopyInstance (WMI, smartpInstance, smartpNewInstance));
}
CHECK_ERROR (saInstancesNew.SafePutElement(i, smartpNewInstance));
// reassign, considering that we're re-GUIDing it
if (i == nTopIndex)
smartpTopInstance = smartpNewInstance;
/*
if (!bAlreadyFound)
{
// get name, GUID, and class
_bstr_t bstrClass;
CHECK_ERROR (GetStringProperty(smartpNewInstance, "__CLASS", &bstrClass);
// if it's action-related, see if it's already there
if (!_wcsicmp(bstrFilterToConsumerBindingClassPath, bstrClass)
|| !_wcsicmp(bstrEventConsumerClassPath, bstrClass)
|| !_wcsicmp(bstrActionAssocClassPath, bstrClass)
|| !_wcsicmp(bstrActionConfigurationClassPath, bstrClass) )
{
CHECK_ERROR (GetStringProperty(smartpNewInstance, "Name", &bstrActionName);
_bstr_t bstrGuidNew, bstrName;
bool bFound;
CHECK_ERROR (GetStringProperty(pObj, L"Name", bstrName));
CHECK_ERROR (GuidMap.Find(bstrName, bstrGuidNew, bFound));
if (bFound)
{
}
}
*/
}
// trim the new array
CHECK_ERROR (saInstancesNew.Resize(nLen));
// now find all the actions we're associated to, compare their names
// to actions on the target machine, and fill up a hashtable map
// with the list of conflicts. Note that if this is just one action that
// we're copying locally, there's no need to look for conflicts because
// we're renaming the action anyway.
StringToStringMap GuidMap;
if (! (bIsActionTopInstance && bPasteInSameFolder) )
{
CHECK_ERROR (FillActionGuidMap(saInstancesNew, ActionNameToGuidMap, GuidMap));
int nDuplicateCount = GuidMap.GetSize();
if (nDuplicateCount > 0 && !bPasteOnSameMachine)
{
// uh, oh. We have a name conflict. Depending on whether the
// user wants to perform any overwrites, we will either have to
// delete the conflicting one or return an error.
if (bForceReplace)
{
TRACE(L"Paste: Action Name Conflict. We will delete the conflicting one");
}
else
{
TRACE(L"Paste: Action Name Conflict. Returning an error.");
return WBEM_E_ALREADY_EXISTS;
}
}
}
// Now, let's change all the GUID's (except for the actions
// that we'll be replacing, as above).
CHECK_ERROR (ReGuid (saInstancesNew, GuidMap));
// Now, let's see if I need to rename the top-level item to
// resolve name conflicts
if ((LPCWSTR)bstrConflictGUID != NULL)
{
if (bPasteInSameFolder)
{
// if we get here, we're renaming our top item to avoid
// a name conflict, just like Explorer does
i = 2;
bool bFound = true;
_bstr_t bstrName;
do
{
// compose a name, like Foo (2), Foo (3), etc. like explorer does
WCHAR szNumber[20];
bstrName = bstrTopInstanceName;
bstrName += L" (";
bstrName += _itow (i++, szNumber, 10);
bstrName += L")";
_bstr_t NotUsed;
CHECK_ERROR (TopLevelNameConflictMap.Find(bstrName, NotUsed, bFound));
} while (bFound);
// when we get to here, we've found a free name
CHECK_ERROR (PutStringProperty(smartpTopInstance, L"Name", bstrName));
}
else if (! bIsActionTopInstance)
{
// we're almost there. Now we need to delete the top-level item on the
// target, if present, to make room for us. Use the delete method.
// note that we *do not* go through this codepath for actions, because
// for actions we will just lay down a new action, with the same GUID,
// right over the old one. If we actually did call delete (via the agent)
// the agent would clobber all the action assocations, whereas we want to
// keep them there and have the new action just fall right into place
IWbemClassObjectPtr smartpSystemClass, smartpInParamsClass,
smartpInParamsInstance, smartpResults;
// impersonate the caller. Important since we're now calling into
// WMI and need to make sure caller is allowed
CHECK_ERROR(CoImpersonateClient());
// BUGBUG: For next release, we need to think about how to provide
// safer functionality here, so that we don't actually delete the
// target until we've successfully added the new stuff
// until then, just delete the conflict
CHECK_ERROR(System.FindAndDeleteByGUID(bstrConflictGUID));
/*
// now that this code lives inside the agent, there's no need to call
// an external method on the agent. It's much easier-- just call
// the FindAndDeleteByGUID function on the system class!
// get the system class
CHECK_ERROR (WMI->GetObject (bstrSystemConfigurationClassPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpSystemClass,
NULL));
// get the delete method in-params "class"
CHECK_ERROR (smartpSystemClass->GetMethod (L"Delete", 0, &smartpInParamsClass, NULL));
CHECK_ERROR (smartpInParamsClass->SpawnInstance (0, &smartpInParamsInstance));
CHECK_ERROR (PutStringProperty(smartpInParamsInstance, L"TargetGUID", bstrTopInstanceGUID));
CHECK_ERROR (WMI->ExecMethod(bstrSystemConfigurationClassPath,
L"Delete",
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
smartpInParamsInstance,
&smartpResults,
NULL));
DWORD dwReturnValue;
CHECK_ERROR (GetUint32Property (smartpResults, L"ReturnValue", dwReturnValue));
CHECK_ERROR (dwReturnValue);
*/
}
}
// Now we need to compute the association to link the new instances up to the
// parent instance. This should get the agent to pick up the change and set
// all the balls in motion. Note that actions don't require parent associations--
// actions are just global instances available everywhere.
IWbemClassObjectPtr smartpAssocInstance;
if (! bIsActionTopInstance)
{
IWbemClassObjectPtr smartpAssocClass;
_bstr_t bstrParentPath, bstrTopInstancePath, bstrTopInstanceRelPath;
CHECK_ERROR (GetStringProperty(smartpTopInstance, L"__RELPATH", bstrTopInstanceRelPath));
try
{
bstrParentPath = bstrLocalHealthMonNamespace
+ L":"
+ bstrParentRelPath;
bstrTopInstancePath = bstrLocalHealthMonNamespace
+ L":"
+ bstrTopInstanceRelPath;
}
catch (_com_error e)
{
CHECK_ERROR (e.Error());
}
// now create the association
CHECK_ERROR (WMI->GetObject (bstrConfigurationAssocClassPath,
WBEM_FLAG_RETURN_WBEM_COMPLETE,
NULL,
&smartpAssocClass,
NULL));
CHECK_ERROR(smartpAssocClass->SpawnInstance(0, &smartpAssocInstance));
CHECK_ERROR(PutStringProperty(smartpAssocInstance, L"ParentPath", bstrParentPath));
CHECK_ERROR(PutStringProperty(smartpAssocInstance, L"ChildPath", bstrTopInstancePath));
}
// Whew! Finally, we're ready to paste the new items. Let 'er rip!
for (i = 0, nLen = saInstancesNew.GetSize(); i < nLen; i++)
{
IWbemClassObjectPtr smartpInstance;
CHECK_ERROR (saInstancesNew.GetElement (i, &smartpInstance));
_bstr_t bstrClass, bstrPath;
CHECK_ERROR (GetStringProperty(smartpInstance, L"__RELPATH", bstrPath));
CHECK_ERROR (GetStringProperty(smartpInstance, L"__CLASS", bstrClass));
// If the user is pasting on the same machine, there's no need to write
// actions, since we will simply use associations to the same actions.
// The one exception is if we're pasting a single action (which will
// result in a new action being laid down).
if (bPasteOnSameMachine && ! bIsActionTopInstance)
{
if (!_wcsicmp(bstrFilterToConsumerBindingClassPath, bstrClass)
|| !_wcsicmp(bstrEventConsumerClassPath, bstrClass)
|| !_wcsicmp(bstrEventFilterClassPath, bstrClass)
|| !_wcsicmp(bstrActionConfigurationClassPath, bstrClass) )
{
continue; // skip if it's an action
}
}
// TODO: as an optmization, we should consider not laying down
// multiple copies of the same action. WMI should handle our saves as
// simple instance modification events, but it would speed things up
// to filter out multiple copies of actions.
// impersonate the caller. Important since we're now calling into
// WMI and need to make sure caller is allowed
CHECK_ERROR(CoImpersonateClient());
// finally, lay down the new instance!
HRESULT hr = WMI->PutInstance(smartpInstance,
WBEM_FLAG_RETURN_WBEM_COMPLETE | WBEM_FLAG_CREATE_OR_UPDATE,
NULL,
NULL);
if (hr == WBEM_E_ACCESS_DENIED)
{
// we may have trouble overwriting action instances when those
// were created by another user. But since admin users should
// be able to override this restriction, and only admins can
// use HM in this release, I think that we're OK.
// BUGBUG: in future HM releases, we should consider deleting
// old action instances if the SID's are different from ours.
}
if (FAILED(hr))
{
CHECK_ERROR (hr);
}
if (i == 0 && (bool) smartpAssocInstance)
{
// now that we've stored the top-level parent, let's add the association
// to the parent. There's a bug in the rest of the agent that it won't
// pick up action associations unless the parent instance is already
// associated. Hopefully this will be fixed, but until then we'll link up
// the new top instance right at first.
CHECK_ERROR(WMI->PutInstance(smartpAssocInstance,
WBEM_FLAG_RETURN_WBEM_COMPLETE | WBEM_FLAG_CREATE_OR_UPDATE,
NULL,
NULL));
}
//BUGBUG: shouldn't lay down anything that's already there and the same as us!
//BUGBUG: before calling it a conflict, must compare properties!
}
return S_OK;
}
// Below are the actual entry points for the old agent code
// to call the new copy & paste functionality
HRESULT CSystem::AgentPaste(LPTSTR pszTargetGUID,
SAFEARRAY* psa,
LPTSTR pszOriginalSystem,
LPTSTR pszOriginalParentGUID,
BOOL bForceReplace)
{
HRESULT hr = Paste(L".", pszTargetGUID, pszOriginalSystem,
pszOriginalParentGUID, psa, bForceReplace, *this);
// BUGBUG: the agent returns the HRESULT of the Paste back
// through the __ReturnValue of the method, not through WMI
// errors. This is bad-- needs to be changed.
if (hr == WBEM_E_ALREADY_EXISTS)
return 2; // 2 is what console recognizes here.
else if (FAILED(hr))
return hr;
else
return 0;
}
HRESULT CSystem::AgentCopy(LPTSTR pszGUID,
SAFEARRAY** ppsa,
LPTSTR *pszOriginalParentGUID)
{
SafeArrayOneDimWbemClassObject sa;
CHECK_ERROR (sa.Create());
_bstr_t bstrParentGUID;
// now call the underlying copy routine
HRESULT hr = Copy(L".", pszGUID, bstrParentGUID, sa, *this);
CHECK_ERROR (hr);
VARIANT var = sa.Detach();
*ppsa = var.parray;
// copy the BSTR into a new[] string, as the caller expects.
// should really use a smart pointer or _bstr_t instead....
TCHAR* p = new TCHAR[bstrParentGUID.length()+1];
if (p == NULL)
CHECK_ERROR (E_OUTOFMEMORY);
wcscpy (p, bstrParentGUID);
*pszOriginalParentGUID = p;
return hr;
}
Reference in a new issue View git blame Copy permalink