windows-xp/Source/XPSP1/NT/admin/hmonitor/hmagent/copypaste.cpp

//***************************************************************************
//
//  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;
}