#include <wbemidl.h>
#include <wbemprov.h>
#include <wbemtime.h>
#include <atlbase.h>
#include <stdio.h>      // fprintf
#include <stdlib.h>
#include <locale.h>

#include <buffer.h>

#include <genlex.h>
#include <qllex.h>
#include <ql.h>

#include "objpath.h"
#include "iads.h"
#include "adshlp.h"

#include "Utility.h"


#define MAX_ATTR 25

//***************************************************************************
// Function:   Init
//
// Purpose:   1 - Create an instance of the WbemLocator interface
//            2 - Use the pointer returned in step two to connect to
//                the server using the specified namespace.
//***************************************************************************

HRESULT ConnectToNameSpace(IWbemServices **ppIWbemServices, WCHAR *pNamespace)
{
  HRESULT dwRes;
  IWbemLocator *pIWbemLocator = NULL;

  CReleaseMe
    RelpIWbemLocator(pIWbemLocator);

  // **** Create an instance of the WbemLocator interface

  dwRes = CoCreateInstance(CLSID_WbemLocator,
                           NULL,
                           CLSCTX_INPROC_SERVER,
                           IID_IWbemLocator,
                           (LPVOID *) &pIWbemLocator);

  // **** connect to the server using the passed in namespace.

  if(SUCCEEDED(dwRes))
  {
    dwRes = pIWbemLocator->ConnectServer(QString(pNamespace),  // Namespace
                                       NULL,                 // Userid
                                       NULL,                 // PW
                                       NULL,                 // Locale
                                       NULL,                 // flags
                                       NULL,                 // Authority
                                       NULL,                 // Context
                                       ppIWbemServices);
  }

  return dwRes;
}

/*********************************************************************
************** Active Directory Methods ******************************
*********************************************************************/

HRESULT Policy_CIMToAD(long lFlags, IWbemClassObject *pSrcPolicyObj, IDirectoryObject *pDestContainer)
{
    HRESULT 
      hres = WBEM_S_NO_ERROR;

    CComVariant
      vPolicyType,
      v[MAX_ATTR];

    long 
      lIsSimple = 0,
      c1,
      nOptArgs = 0,
      nArgs = 0;
    
  DWORD
    dwReturn;

  CComQIPtr<IDirectoryObject, &IID_IDirectoryObject>
    pDestPolicyObj,
    pDirObj;

  BYTE defaultBuffer[2048];
  ULONG bWritten = 0;
  LARGE_INTEGER offset;

  CBuffer
    ClassDefBuffer(defaultBuffer, 2048, FALSE);

  CIMTYPE vtType1;
    
  CComPtr<IDispatch>
      pDisp;
    
  CComPtr<IWbemClassObject>
      pParamObj;
    
  CComQIPtr<IADsContainer, &IID_IADsContainer>
    pADsContainer = pDestContainer;

  CComQIPtr<IADs, &IID_IADs>
    pADsLegacyObj;

  ADSVALUE
    AdsValue[MAX_ATTR];

  ADS_ATTR_INFO 
    attrInfo[MAX_ATTR];

  WBEMTime
    wtCurrentTime;

  SYSTEMTIME
    SystemTime;

  GetSystemTime(&SystemTime);

  wtCurrentTime = SystemTime;

    // **** determine which class we are putting (Simple or Mergeable)

    hres = pSrcPolicyObj->Get(L"__CLASS", 0, &vPolicyType, NULL, NULL);
    if(FAILED(hres) || (NULL == V_BSTR(&vPolicyType))) return hres;
    if(0 == _wcsicmp(g_bstrClassSimplePolicy, V_BSTR(&vPolicyType)))
      lIsSimple = 1;

    // **** set policy object type

    Init_AdsAttrInfo(&attrInfo[nArgs], 
                     g_bstrADObjectClass, 
                     ADS_ATTR_UPDATE, 
                     ADSTYPE_CASE_IGNORE_STRING, 
                     &AdsValue[nArgs], 
                     1);

    AdsValue[nArgs].CaseIgnoreString = g_bstrADClassSimplePolicy;
    int lTypeIndex = nArgs++;
    
    // **** security descriptor

    PSECURITY_DESCRIPTOR
      pSD = GetADSecurityDescriptor(pDestContainer);

    if(NULL == pSD)
    {
      ERRORTRACE((LOG_ESS, "POLICMAN: could not create security descriptor for policy object\n"));
      return WBEM_E_OUT_OF_MEMORY;
    }

    CNtSecurityDescriptor
      cSD(pSD, TRUE);

    if(CNtSecurityDescriptor::NoError != cSD.GetStatus()) return WBEM_E_FAILED;

    hres = RestrictSecurityDescriptor(cSD);

    AdsValue[nArgs].SecurityDescriptor.dwLength = cSD.GetSize();
    AdsValue[nArgs].SecurityDescriptor.lpValue = (LPBYTE) cSD.GetPtr();

    Init_AdsAttrInfo(&attrInfo[nArgs], 
                     L"ntSecurityDescriptor", 
                     ADS_ATTR_UPDATE, 
                     ADSTYPE_NT_SECURITY_DESCRIPTOR, 
                     &AdsValue[nArgs], 
                     1);

    nArgs++;

    // **** ID
    
    hres = pSrcPolicyObj->Get(g_bstrID, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;
    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADID, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);
    }
    else
        return WBEM_E_ILLEGAL_NULL;
    int lIDIndex = nArgs++;

  // **** if object already exists, get a pointer to it

  CComBSTR
    PolicyName(L"CN=");

  PolicyName.Append(AdsValue[lIDIndex].CaseIgnoreString);

  // **** LEGACY code to delete existing mergeable policy AD objects

  if(SUCCEEDED(hres = pADsContainer->GetObject(NULL, PolicyName, &pDisp)))
  {
    pADsLegacyObj = pDisp;

    CComBSTR
      bstrClassName;

    hres = pADsLegacyObj->get_Class(&bstrClassName);
    if(FAILED(hres)) return hres;

    if(0 != _wcsicmp(g_bstrADClassMergeablePolicy, bstrClassName))
      pADsLegacyObj.Release();
  }

    // **** Description
    
    hres = pSrcPolicyObj->Get(g_bstrDescription, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;
    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
        Init_AdsAttrInfo(&attrInfo[nArgs], 
                         g_bstrADDescription, 
                         ADS_ATTR_UPDATE, 
                         ADSTYPE_CASE_IGNORE_STRING, 
                         &AdsValue[nArgs], 
                         1);

        AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

        nArgs++;
    }
    
    // **** TargetType
    
    hres = pSrcPolicyObj->Get(g_bstrTargetType, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADTargetType, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    
    // **** Name
    
    hres = pSrcPolicyObj->Get(g_bstrName, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADName, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    
    // **** TargetNameSpace
    
    hres = pSrcPolicyObj->Get(g_bstrTargetNameSpace, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADTargetNameSpace, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    else
      return WBEM_E_ILLEGAL_NULL;
    
    // **** TargetClass
    
    hres = pSrcPolicyObj->Get(g_bstrTargetClass, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADTargetClass, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    
    // **** TargetPath
    
    if(lIsSimple)
    {
      CComPtr<IWbemClassObject>
        pTargetObj;

      CComVariant
       vTargetObj;

      hres = pSrcPolicyObj->Get(g_bstrTargetObject, 0, &vTargetObj, NULL, NULL);
      if(FAILED(hres)) return hres;
      if((vTargetObj.vt != VT_UNKNOWN) || (vTargetObj.punkVal == NULL)) 
        return WBEM_E_ILLEGAL_NULL;

      hres = vTargetObj.punkVal->QueryInterface(IID_IWbemClassObject, (void**)&pTargetObj);
      if(FAILED(hres)) return hres;

      hres = pTargetObj->Get(L"__RELPATH", 0, &v[nArgs], NULL, NULL);
      if(FAILED(hres)) return hres;
      if ((v[nArgs].vt != VT_BSTR) || (v[nArgs].bstrVal == NULL))
        return WBEM_E_ILLEGAL_NULL;
    }
    else
    {
      hres = pSrcPolicyObj->Get(g_bstrTargetPath, 0, &v[nArgs], NULL, NULL);
      if(FAILED(hres)) return hres;
    }

    {
      CObjectPathParser
        ObjPath(e_ParserAcceptRelativeNamespace);

      ParsedObjectPath
        *pParsedObjectPath = NULL;

      if(ObjPath.NoError != ObjPath.Parse(v[nArgs].bstrVal, &pParsedObjectPath))
      {
        ERRORTRACE((LOG_ESS, "POLICMAN: Parse error target path: %S\n", v[nArgs].bstrVal));
        return WBEM_E_INVALID_PARAMETER;
      }

      if(NULL != pParsedObjectPath) 
        ObjPath.Free(pParsedObjectPath);
    }

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADTargetPath, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }

    // **** NormalizedClass
    
    Init_AdsAttrInfo(&attrInfo[nArgs], 
                     g_bstrADNormalizedClass, 
                     ADS_ATTR_UPDATE, 
                     ADSTYPE_CASE_IGNORE_STRING, 
                     &AdsValue[nArgs], 
                     1);

    if(lIsSimple)
      AdsValue[nArgs].CaseIgnoreString = g_bstrADClassSimplePolicy;
    else
      AdsValue[nArgs].CaseIgnoreString = g_bstrADClassMergeablePolicy;
    nArgs++;
    
    // **** SourceOrganization
    
    hres = pSrcPolicyObj->Get(g_bstrSourceOrganization, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADSourceOrganization, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    
    // **** Author
    
    hres = pSrcPolicyObj->Get(g_bstrAuthor, 0, &v[nArgs], NULL, NULL);
    if(FAILED(hres)) return hres;

    if ((v[nArgs].vt == VT_BSTR) && (v[nArgs].bstrVal != NULL))
    {
      Init_AdsAttrInfo(&attrInfo[nArgs], 
                       g_bstrADAuthor, 
                       ADS_ATTR_UPDATE, 
                       ADSTYPE_CASE_IGNORE_STRING, 
                       &AdsValue[nArgs], 
                       1);

      AdsValue[nArgs].CaseIgnoreString = V_BSTR(&v[nArgs]);

      nArgs++;
    }
    
    // **** ChangeDate
    
    Init_AdsAttrInfo(&attrInfo[nArgs], 
                     g_bstrADChangeDate, 
                     ADS_ATTR_UPDATE, 
                     ADSTYPE_CASE_IGNORE_STRING, 
                     &AdsValue[nArgs], 
                     1);

    AdsValue[nArgs].CaseIgnoreString = wtCurrentTime.GetDMTF(FALSE);

    nArgs++;
    
    // **** CreationDate
    
  if(NULL == pDisp.p)
  {
    AdsValue[nArgs].CaseIgnoreString = wtCurrentTime.GetDMTF(FALSE);

    Init_AdsAttrInfo(&attrInfo[nArgs],
                   g_bstrADCreationDate,
                   ADS_ATTR_UPDATE,
                   ADSTYPE_CASE_IGNORE_STRING,
                   &AdsValue[nArgs],
                   1);

    nArgs++;
  }

  // **** LEGACY code to delete existing mergeable policy AD objects

  else if(NULL != pADsLegacyObj.p)
  {
    VARIANT
      vCreationDate;

    hres = pADsLegacyObj->Get(g_bstrADCreationDate, &vCreationDate);
    if(FAILED(hres)) return hres;

    AdsValue[nArgs].CaseIgnoreString = vCreationDate.bstrVal;

    Init_AdsAttrInfo(&attrInfo[nArgs],
                  g_bstrADCreationDate,
                  ADS_ATTR_UPDATE,
                  ADSTYPE_CASE_IGNORE_STRING,
                  &AdsValue[nArgs],
                  1);

    nArgs++;
  }

   // **** Target Object/Range Settings

   offset.LowPart = 0;
   offset.HighPart = 0;

   hres = ClassDefBuffer.Seek(offset, STREAM_SEEK_SET, NULL);
   if(FAILED(hres)) return hres;

   if(lIsSimple)
   {
     hres = pSrcPolicyObj->Get(g_bstrTargetObject, 0, &v[nArgs], NULL, NULL);
     if(FAILED(hres)) return hres;

     hres = CoMarshalInterface(&ClassDefBuffer, 
                               IID_IWbemClassObject, 
                               v[nArgs].punkVal, 
                               MSHCTX_NOSHAREDMEM, 
                               NULL, 
                               MSHLFLAGS_TABLESTRONG);

     if(FAILED(hres)) return hres;
   }
   else
   {
     CComVariant
       vRangeParams;

     SafeArray<IUnknown*, VT_UNKNOWN>
       Array1;

     wchar_t
       swArraySize[20];

     hres = pSrcPolicyObj->Get(g_bstrRangeSettings, 0, &vRangeParams, NULL, NULL);
     if(FAILED(hres)) return hres;
     if(vRangeParams.vt != (VT_ARRAY | VT_UNKNOWN)) return WBEM_E_INVALID_PARAMETER;

     Array1 = &vRangeParams;
        
     _itow(Array1.Size(), swArraySize, 10);
     ClassDefBuffer.Write(swArraySize, sizeof(wchar_t) * 20, NULL);

     for(c1 = 0; c1 < Array1.Size(); c1++)
     {
       CComVariant
         vParamType;

       CComQIPtr<IWbemClassObject, &IID_IWbemClassObject>
         pParamObj = Array1[c1];

       // **** verify valid range parameter

       hres = pParamObj->Get(L"__CLASS", 0, &vParamType, NULL, NULL);
 
       if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassRangeSint32))
         hres = Range_Sint32_Verify(pParamObj);
       else if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassRangeUint32))
         hres = Range_Uint32_Verify(pParamObj);
       else if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassRangeReal))
         hres = Range_Real_Verify(pParamObj);
       else if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassSetSint32))
         hres = Set_Sint32_Verify(pParamObj);
       else if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassSetUint32))
         hres = Set_Uint32_Verify(pParamObj);
       else if(0 == _wcsicmp(V_BSTR(&vParamType), g_bstrClassSetString))
         hres = Set_String_Verify(pParamObj);
       else
         hres = Param_Unknown_Verify(pParamObj);

       if(FAILED(hres)) return hres;

       // **** pack range parameter into TargetObject

       hres = CoMarshalInterface(&ClassDefBuffer, IID_IUnknown, Array1[c1], 
                                 MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG);
       if(FAILED(hres)) return hres;
     }
   }

   Init_AdsAttrInfo(&attrInfo[nArgs], 
                    g_bstrADTargetObject, 
                    ADS_ATTR_UPDATE, 
                    ADSTYPE_OCTET_STRING, 
                    &AdsValue[nArgs], 
                    1);

   AdsValue[nArgs].OctetString.dwLength = ClassDefBuffer.GetIndex();
   AdsValue[nArgs].OctetString.lpValue = ClassDefBuffer.GetRawData();
   nArgs++;

  // **** create AD policy object
    
  if(NULL != pDisp.p)
  {
    if(WBEM_FLAG_CREATE_ONLY & lFlags) return WBEM_E_ALREADY_EXISTS;

    if(NULL != pADsLegacyObj.p)
    {
      CComQIPtr<IADsDeleteOps, &IID_IADsDeleteOps>
        pDelObj = pADsLegacyObj;

      pDisp = NULL;
      pADsLegacyObj.Release();
      pDelObj->DeleteObject(0);

      hres = pDestContainer->CreateDSObject(PolicyName, attrInfo, nArgs, &pDisp);
      if(FAILED(hres)) return hres;
    }
    else
    {
      pDirObj = pDisp;
  
      hres = pDirObj->SetObjectAttributes(&attrInfo[2], nArgs - 2, &dwReturn);
      if(FAILED(hres)) return hres;
    }
  }
  else
  {
    if(WBEM_FLAG_UPDATE_ONLY & lFlags)
      return WBEM_E_NOT_FOUND;

    hres = pDestContainer->CreateDSObject(PolicyName, attrInfo, nArgs, &pDisp);
    if(FAILED(hres)) return hres;
  }

  return WBEM_S_NO_ERROR;
}

HRESULT Policy_ADToCIM(IWbemClassObject * *ppDestPolicyObj,
                       IDirectoryObject *pSrcPolicyObj, 
                       IWbemServices *pDestCIM)
{
    HRESULT 
      hres = WBEM_S_NO_ERROR;

    CComVariant
      v1;
 
    wchar_t* AttrNames[] = 
    { 
        g_bstrADID, 
        g_bstrADDescription,
        g_bstrADName,
        g_bstrADTargetNameSpace, 
        g_bstrADTargetClass, 
        g_bstrADTargetPath, 
        g_bstrADTargetType, 
        g_bstrADNormalizedClass,
        g_bstrADSourceOrganization, 
        g_bstrADAuthor,
        g_bstrADChangeDate,
        g_bstrADCreationDate,
        g_bstrADTargetObject
    };
    
    wchar_t* AttrType[] =
    {
      g_bstrADNormalizedClass
    };

    wchar_t* AttrTypeLegacy[] =
    {
      g_bstrADObjectClass
    };

  BYTE defaultBuffer[2048];
  ULONG bWritten = 0;
  LARGE_INTEGER offset;

  CBuffer
    ClassDefBuffer(defaultBuffer, 2048, FALSE);

    ADsStruct<ADS_ATTR_INFO>
        pAttrTypeInfo,
        pAttrTypeInfoLegacy,
        pAttrInfo;
    
    unsigned long
        ulIsLegacy = 0,
        ulIsSimple = 0,
        c1, 
        dwReturn;
    
    CComPtr<IUnknown>
        pUnknown;
    
    CComPtr<IWbemClassObject>
        pClassDef,
        pDestPolicyObj,
        pDestParamObj;
    
    CComPtr<IWbemContext>
        pCtx;
    
    ADsStruct<ADS_OBJECT_INFO>
        pInfo;
 
    // **** determine policy object type

    hres = pSrcPolicyObj->GetObjectAttributes(AttrTypeLegacy, 1, &pAttrTypeInfoLegacy, &dwReturn);
    if(FAILED(hres)) return hres;
    if(pAttrTypeInfoLegacy == NULL) return WBEM_E_NOT_FOUND;
    if(0 == _wcsicmp(g_bstrADClassMergeablePolicy, (pAttrTypeInfoLegacy->pADsValues + pAttrTypeInfoLegacy->dwNumValues - 1)->CaseIgnoreString))
      ulIsLegacy = 1;
    else
    {
      hres = pSrcPolicyObj->GetObjectAttributes(AttrType, 1, &pAttrTypeInfo, &dwReturn);
      if(FAILED(hres)) return hres;
      if(pAttrTypeInfo == NULL) return WBEM_E_NOT_FOUND;
      if(0 == _wcsicmp(g_bstrADClassSimplePolicy, (pAttrTypeInfo->pADsValues + pAttrTypeInfo->dwNumValues - 1)->CaseIgnoreString))
        ulIsSimple = 1;

      else if(0 == _wcsicmp(g_bstrClassMergeablePolicy, (pAttrTypeInfo->pADsValues + pAttrTypeInfo->dwNumValues - 1)->CaseIgnoreString))
        ulIsSimple = 1;
    }

    // **** create empty class policy
    
    if(ulIsSimple)
      hres = pDestCIM->GetObject(g_bstrClassSimplePolicy, 0, pCtx, &pClassDef, NULL);
    else
      hres = pDestCIM->GetObject(g_bstrClassMergeablePolicy, 0, pCtx, &pClassDef, NULL);

    if(FAILED(hres)) return hres;
    if(pClassDef == NULL) return WBEM_E_FAILED;
    
    hres = pClassDef->SpawnInstance(0, ppDestPolicyObj);
    if(FAILED(hres)) return hres;
    pDestPolicyObj = *ppDestPolicyObj;
    if(pDestPolicyObj == NULL) return WBEM_E_INVALID_CLASS;
    
    // **** get object attributes

    hres = pSrcPolicyObj->GetObjectAttributes(AttrNames, (ulIsLegacy ? 12 : 13), &pAttrInfo, &dwReturn);
    if(FAILED(hres)) return hres;
    if(pAttrInfo == NULL) return WBEM_E_NOT_FOUND;
    
    // **** Domain
    
    hres = pSrcPolicyObj->GetObjectInformation(&pInfo);
    if(SUCCEEDED(hres) && (pInfo != NULL))
    {
      QString
        DomainName;

      hres = DomainNameFromDistName(DomainName, QString(pInfo->pszObjectDN));

      v1 = (wchar_t*)DomainName;
      hres = pDestPolicyObj->Put(g_bstrDomain, 0, &v1, 0);
    }

    if(pInfo == NULL) return WBEM_E_FAILED;
    if(FAILED(hres)) return hres;
    
    for(c1 = 0; c1 < dwReturn; c1++)
    {
        // **** ID
        
        if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADID))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrID, 0, &v1, 0);
        }
        
        // **** Description
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADDescription))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrDescription, 0, &v1, 0);
        }
        
        // **** TargetType
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADTargetType))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrTargetType, 0, &v1, 0);
        }
        
        // **** Name
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADName))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrName, 0, &v1, 0);
        }
        
        // **** TargetNameSpace
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADTargetNameSpace))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrTargetNameSpace, 0, &v1, 0);
        }
        
        // **** TargetClass
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADTargetClass))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrTargetClass, 0, &v1, 0);
        }
        
        // **** TargetPath
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADTargetPath))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrTargetPath, 0, &v1, 0);
        }
        
        // **** SourceOrganization
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADSourceOrganization))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrSourceOrganization, 0, &v1, 0);
        }
        
        // **** Author
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADAuthor))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrAuthor, 0, &v1, 0);
        }
        
        // **** ChangeDate
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADChangeDate))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrChangeDate, 0, &v1, 0);
            // dates are easy to mess up, we won't bail out for it
            if (hres == WBEM_E_TYPE_MISMATCH)
            {
                ERRORTRACE((LOG_ESS, "POLICMAN: Type mismatch on date property\n"));
                hres = WBEM_S_NO_ERROR;
            }
        }
        
        // **** CreationDate
        
        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADCreationDate))
        {
            v1 = (pAttrInfo + c1)->pADsValues->CaseIgnoreString;
            hres = pDestPolicyObj->Put(g_bstrCreationDate, 0, &v1, 0);

            // dates are easy to mess up, we won't bail out for it
            if (hres == WBEM_E_TYPE_MISMATCH)
            {
                ERRORTRACE((LOG_ESS, "POLICMAN: Type mismatch on date property\n"));
                hres = WBEM_S_NO_ERROR;
            }
        }

        // **** TargetObject

        else if(0 == _wcsicmp((pAttrInfo + c1)->pszAttrName, g_bstrADTargetObject))
        {
          ADSVALUE
            *pADsObj = (pAttrInfo + c1)->pADsValues;

          offset.LowPart = 0;
          offset.HighPart = 0;

          if(NULL == pADsObj) continue;

          hres = ClassDefBuffer.Seek(offset, STREAM_SEEK_SET, NULL);
          if(SUCCEEDED(hres))
          { 
            hres = ClassDefBuffer.Write(pADsObj->OctetString.lpValue, pADsObj->OctetString.dwLength, &bWritten);
            if(SUCCEEDED(hres))
            {
              hres = ClassDefBuffer.Seek(offset, STREAM_SEEK_SET, NULL);
              if(SUCCEEDED(hres))
              {
                if(ulIsSimple)
                {
                  hres = CoUnmarshalInterface(&ClassDefBuffer, IID_IWbemClassObject, (void**)&pDestParamObj);
                  if(SUCCEEDED(hres))
                  {
                    v1 = pDestParamObj;
                    hres = pDestPolicyObj->Put(g_bstrTargetObject, 0, &v1, 0);
                  }
                }
                else if(! ulIsLegacy)
                {
                  SafeArray<IUnknown*, VT_UNKNOWN>
                    Array1;

                  IUnknown
                    *pUnknown = NULL;

                  wchar_t
                    swArraySize[20];

                  ClassDefBuffer.Read(swArraySize, sizeof(wchar_t) * 20, NULL);
                  int nElts = _wtoi(swArraySize);

                  while(nElts-- && SUCCEEDED(hres = CoUnmarshalInterface(&ClassDefBuffer, IID_IUnknown, (void**)&pUnknown)))
                  {
                    Array1.ReDim(0, Array1.Size() + 1);
                    Array1[Array1.IndexMax()] = pUnknown;
                    pUnknown = NULL;
                  }

                  if(0 < Array1.Size())
                  {
                    V_VT(&v1) = (VT_UNKNOWN | VT_ARRAY);
                    V_ARRAY(&v1) = Array1.Data();
                    hres = pDestPolicyObj->Put(g_bstrRangeSettings, 0, &v1, 0);
                  }
                }
              }
            }
          }
        }

        if(FAILED(hres)) return hres;

        VariantClear(&v1);
    }

  if(ulIsLegacy)
  {
    CComQIPtr<IDirectorySearch, &IID_IDirectorySearch>
      pDirSrch;

    ADS_SEARCH_HANDLE
        SearchHandle;
    
    ADS_SEARCH_COLUMN
        SearchColumn;
    
    // **** now, get RangeSettings that are the children of this policy object in AD

    pDirSrch = pSrcPolicyObj;

    hres = pDirSrch->ExecuteSearch(L"(cn=*)", NULL, -1, &SearchHandle);
    if(FAILED(hres)) return hres;

    while(S_OK == (hres = pDirSrch->GetNextRow(SearchHandle)))
    {
      hres = pDirSrch->GetColumn(SearchHandle, g_bstrADObjectClass, &SearchColumn);
      if(FAILED(hres)) return hres;

      int x = SearchColumn.dwNumValues - 1;

      if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassRangeSint32))
          hres = Range_Sint32_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassRangeUint32))
          hres = Range_Uint32_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassRangeReal))
          hres = Range_Real_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassSetSint32))
          hres = Set_Sint32_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassSetUint32))
          hres = Set_Uint32_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassSetString))
          hres = Set_String_ADToCIM(&pDestParamObj, pDirSrch, SearchHandle, pDestCIM);
      else if(0 == _wcsicmp((SearchColumn.pADsValues + x)->CaseIgnoreString, g_bstrADClassParamUnknown))
          hres = Param_Unknown_ADToCIM(&pDestParamObj, pDirSrch, &SearchHandle, pDestCIM);

      // **** place pDestParamObj in pDestPolicyObj

      if(SUCCEEDED(hres) && (pDestParamObj != NULL))
      {
          hres = pDestPolicyObj->Get(g_bstrRangeSettings, 0, &v1, NULL, NULL);
          if(FAILED(hres)) return hres;

          SafeArray<IUnknown*, VT_UNKNOWN>
              ValidValues(&v1);

          hres = pDestParamObj.QueryInterface(&pUnknown);
          if(FAILED(hres)) return hres;
          pDestParamObj = NULL;

          ValidValues.ReDim(0, ValidValues.Size() + 1);
          ValidValues[ValidValues.IndexMax()] = pUnknown.Detach();

          VariantClear(&v1);
          V_VT(&v1) = (VT_ARRAY | ValidValues.Type());
          V_ARRAY(&v1) = ValidValues.Data();
          hres = pDestPolicyObj->Put(g_bstrRangeSettings, 0, &v1, 0);
          if(FAILED(hres)) return hres;

          VariantClear(&v1);
      }

      pDirSrch->FreeColumn(&SearchColumn);
    }

    pDirSrch->CloseSearchHandle(SearchHandle);
  }

  return WBEM_S_NO_ERROR;
}

inline int _NextIndex(long &cIndex, SafeArray<long, VT_I4> &ValidObjs)
{
  if((cIndex < -1) || (cIndex >= ValidObjs.Size()))
    return 0;

  while((++cIndex < ValidObjs.Size()) && (ValidObjs[cIndex] == FALSE));

  if(cIndex >= ValidObjs.Size())
    return 0;

  return 1;
}

HRESULT Policy_Merge(SafeArray<IUnknown*, VT_UNKNOWN> &PolicyArray, 
                     CComPtr<IWbemClassObject> &pMergedPolicy,
                     IWbemServices *pDestCIM)
{
  HRESULT 
    hres = WBEM_E_FAILED;

  ULONG 
    nValidObjects = 0;

  CComVariant
    vFirstPolicyType,
    vPolicyAttr;

  long 
    boolFinished = FALSE, boolNotMergeable = FALSE, c1, c2, c3;

  CComPtr<IWbemClassObject>
    pFirstPolicy,
    pClassRangeParam,
    pClassInParams,
    pInParams;

  SafeArray<BSTR, VT_BSTR>
    RangeNames;

  if(PolicyArray.Size() < 1)
    return NULL;

  DEBUGTRACE((LOG_ESS, "POLICMAN(merge): # of objects to merge: %d\n", PolicyArray.Size()));

  // **** get input parameter for MSFT_RangeParam.Merge()

  hres = pDestCIM->GetObject(g_bstrClassRangeParam, 0, NULL, &pClassRangeParam, NULL);
  if(FAILED(hres)) return hres;

  hres = pClassRangeParam->GetMethod(L"Merge", 0, &pClassInParams, NULL);
  if(FAILED(hres)) return hres;

  hres = pClassInParams->SpawnInstance(0, &pInParams);
  if(FAILED(hres)) return hres;

  // **** check to see if 1st obj is Simple Policy Template

  if((0 == PolicyArray.Size()) || (NULL == PolicyArray[0])) return WBEM_E_INVALID_PARAMETER;
  hres = PolicyArray[0]->QueryInterface(IID_IWbemClassObject, (void **)&pFirstPolicy);
  if(FAILED(hres)) return WBEM_E_FAILED;

  if(pFirstPolicy->InheritsFrom(L"MSFT_PolicyTemplate") != WBEM_S_NO_ERROR)
    return WBEM_E_INVALID_PARAMETER;

  // **** create array of Policy objects to be merged

  SafeArray<long, VT_I4>
    ValidPolicyObjects(0, PolicyArray.Size());

  hres = pFirstPolicy->Get(L"__CLASS", 0, &vFirstPolicyType, NULL, NULL);
  if(FAILED(hres)) return WBEM_E_FAILED;

  if((_wcsicmp(g_bstrClassMergeablePolicy, vFirstPolicyType.bstrVal) == 0) ||
     (pFirstPolicy->InheritsFrom(g_bstrClassMergeablePolicy) == WBEM_S_NO_ERROR))
  {
    for(c1 = 0; c1 < PolicyArray.Size(); c1++)
    {
      if(NULL != PolicyArray[c1])
      {
        CComVariant
          vPolicyType,
          vPolicyGenus;

        CComPtr<IWbemClassObject>
          pCurrentPolicy;

        hres = PolicyArray[c1]->QueryInterface(IID_IWbemClassObject, (void**)&pCurrentPolicy);
        if(FAILED(hres)) return WBEM_E_FAILED;

        hres = pCurrentPolicy->Get(L"__CLASS", 0, &vPolicyType, NULL, NULL);
        if(FAILED(hres)) return WBEM_E_FAILED;

        hres = pCurrentPolicy->Get(L"__GENUS", 0, &vPolicyGenus, NULL, NULL);
        if(FAILED(hres)) return WBEM_E_FAILED;
        if(0x2 != vPolicyGenus.lVal) 
        {
          ERRORTRACE((LOG_ESS, "POLICMAN: Policy Object %d is not an instance\n", c1));
          return WBEM_E_INVALID_PARAMETER;
        }

        if((_wcsicmp(g_bstrClassMergeablePolicy, vPolicyType.bstrVal) == 0) ||
           (pCurrentPolicy->InheritsFrom(g_bstrClassMergeablePolicy) == WBEM_S_NO_ERROR))
        {
          ValidPolicyObjects[c1] = TRUE;
          nValidObjects++;
        }
        else
          ValidPolicyObjects[c1] = FALSE;
      }
      else
        ValidPolicyObjects[c1] = FALSE;
    }

    DEBUGTRACE((LOG_ESS, "POLICMAN(merge): %d out of %d template objects are of type MSFT_MergeablePolicyTemplate\n", nValidObjects, PolicyArray.Size()));
  }
  else
  {
    boolFinished = TRUE;
    boolNotMergeable = TRUE;

    DEBUGTRACE((LOG_ESS, "POLICMAN(merge): 1st object is not mergeable policy template object\n"));
  }

  // **** create empty array for merged range parameters, one element per parameter name

  SafeArray<IUnknown*, VT_UNKNOWN>
    MergedParameters;

  // ****  build list of merged range params and place them in MergedParameters

  while((FALSE == boolFinished) && (0 < nValidObjects))
  {
    DEBUGTRACE((LOG_ESS, "POLICMAN(merge): ---- Start Merge Cycle ----\n"));

    // **** get list of attribute names from all policy objects

    c1 = -1;
    while(_NextIndex(c1, ValidPolicyObjects))
    {
      CComQIPtr<IWbemClassObject, &IID_IWbemClassObject>
        pCurrentPolicy;

      CComVariant
        vRangeSettings;

      pCurrentPolicy = PolicyArray[c1];

      hres = pCurrentPolicy->Get(g_bstrRangeSettings, 0, &vRangeSettings, NULL, NULL);
      if(FAILED(hres)) return hres;

      SafeArray<IUnknown*, VT_UNKNOWN>
        RangeSettings(&vRangeSettings);

      for(c2 = 0; c2 < RangeSettings.Size(); c2++)
      {
        CComQIPtr<IWbemClassObject, &IID_IWbemClassObject>
          pCurrentRange;

        CComVariant
          vRangeName;

        pCurrentRange = RangeSettings[c2];

        hres = pCurrentRange->Get(g_bstrPropertyName, 0, &vRangeName, NULL, NULL);
        if(FAILED(hres)) return hres;

        c3 = -1; 
        while((++c3 < RangeNames.Size()) && (0 != _wcsicmp(V_BSTR(&vRangeName), RangeNames[c3])));

        if(c3 > RangeNames.IndexMax())
        {
          RangeNames.ReDim(0, RangeNames.Size() + 1);
          RangeNames[RangeNames.IndexMax()] = SysAllocString(V_BSTR(&vRangeName));
        }
      }
    }

    DEBUGTRACE((LOG_ESS, "POLICMAN(merge): Merging %d parameters accross %d template objects\n", RangeNames.Size(), nValidObjects));

    // **** create and init array for matching parameters from each policy

    SafeArray<IUnknown*, VT_UNKNOWN>
      ParameterObjects(0, PolicyArray.Size());

    // **** resize MergedParameters to contain a slot for each parameter name

    MergedParameters.ReDim(0, RangeNames.Size());

    // **** assemble a list and merge for each parameter in RangeNames

    for(c1 = 0; c1 < RangeNames.Size(); c1++)
    {
      CComPtr<IWbemClassObject>
        pOutParams;

      CComVariant
        vRangeParamType,
        vRangeParamType2,
        vConflict = -1,
        vRanges,
        vReturnValue,
        vMergedParameter;

      // **** build list of parameters from policy objects with name RangeNames[c1]

      c2 = -1;
      while((_NextIndex(c2, ValidPolicyObjects)) && (-1 == vConflict.lVal))
      {
        CComQIPtr<IWbemClassObject, &IID_IWbemClassObject>
          pCurrentPolicyObject = PolicyArray[c2];

        CComVariant
          vCurrentParams;

        // **** walk through parameter settings for c2th policy object looking for a match

        hres = pCurrentPolicyObject->Get(g_bstrRangeSettings, 0, &vCurrentParams, NULL, NULL);
        if(FAILED(hres)) return hres;

        SafeArray<IUnknown*, VT_UNKNOWN>
          CurrentParams(&vCurrentParams);

        c3 = 0;
        ParameterObjects[c2] = NULL;
        while((c3 < CurrentParams.Size()) && (NULL == ParameterObjects[c2]))
        {
          CComQIPtr<IWbemClassObject, &IID_IWbemClassObject>
            pCurrentParameterObject = CurrentParams[c3];

          CComVariant
            vName;

          hres = pCurrentParameterObject->Get(g_bstrPropertyName, 0, &vName, NULL, NULL);
          if(FAILED(hres)) return hres;

          if(0 == _wcsicmp(V_BSTR(&vName), RangeNames[c1]))
          {
            ParameterObjects[c2] = CurrentParams[c3];
            ParameterObjects[c2]->AddRef();

            // **** check that all subsequent parameter objects are of the same type

            if(VT_BSTR != vRangeParamType.vt)
            {
              hres = pCurrentParameterObject->Get(L"__CLASS", 0, &vRangeParamType, NULL, NULL);
              if(FAILED(hres)) return hres;
            }
            else
            {
              hres = pCurrentParameterObject->Get(L"__CLASS", 0, &vRangeParamType2, NULL, NULL);
              if(FAILED(hres)) return hres;

              if((0 != _wcsicmp(V_BSTR(&vRangeParamType), V_BSTR(&vRangeParamType2))) ||
                 (WBEM_S_NO_ERROR != pCurrentParameterObject->InheritsFrom(vRangeParamType.bstrVal)))
              {
                ERRORTRACE((LOG_ESS, "POLICMAN: Type Mismatch on element %d of type %S and type %S\n", c3, V_BSTR(&vRangeParamType), V_BSTR(&vRangeParamType2)));
                vConflict = c2;
                vReturnValue = WBEM_E_TYPE_MISMATCH;
                break;
              }
            }

            DEBUGTRACE((LOG_ESS, "POLICMAN(merge): Got Parameter %S in template object %d\n", V_BSTR(&vName), c2));
          }
  
          c3 += 1;
        }
      }

      // **** now build merged parameter from list

      if(-1 == vConflict.lVal)
      {
        V_VT(&vRanges) = (VT_UNKNOWN | VT_ARRAY);
        V_ARRAY(&vRanges) = ParameterObjects.Data();
        hres = pInParams->Put(L"ranges", 0, &vRanges, 0);
        if(FAILED(hres)) return hres;

        hres = pDestCIM->ExecMethod(V_BSTR(&vRangeParamType), L"Merge", 0, NULL, pInParams, &pOutParams, NULL);
        if(FAILED(hres)) return hres;

        hres = pOutParams->Get(L"mergedRange", 0, &vMergedParameter, NULL, NULL);
        if(FAILED(hres)) return hres;

        hres = pOutParams->Get(L"conflict", 0, &vConflict, NULL, NULL);
        if(FAILED(hres)) return hres;

        hres = pOutParams->Get(L"ReturnValue", 0, &vReturnValue, NULL, NULL);
        if(FAILED(hres)) return hres;
      }

      DEBUGTRACE((LOG_ESS, "POLICMAN(merge): Merge Complete : HRESULT = 0x%d\n", vReturnValue.lVal));

      // **** clean out parameter object array

      for(c2 = 0; c2 < ParameterObjects.Size(); c2++)
        if(NULL != ParameterObjects[c2])
        {
          ParameterObjects[c2]->Release();
          ParameterObjects[c2] = NULL;
        }

      // **** check for conflict

      if((vConflict.lVal >= 0) && (vConflict.lVal < ValidPolicyObjects.Size()))
      {
        DEBUGTRACE((LOG_ESS, " CONFLICT on obj %d\n", vConflict.lVal));

        // **** remove policy object containing offending parameter and start over

        RangeNames.ReDim(0,0);
        MergedParameters.ReDim(0,0);

        ValidPolicyObjects[vConflict.lVal] = FALSE;
        nValidObjects--;

        boolFinished = FALSE;

        // **** log merge conflict

        ERRORTRACE((LOG_ESS, "POLICMAN: Policy Object %d create merge conflict\n", vConflict.lVal));

        break;
      }
      else
      {
        DEBUGTRACE((LOG_ESS, " no conflict\n"));

        hres = (V_UNKNOWN(&vMergedParameter))->QueryInterface(IID_IWbemClassObject, (void **)&(MergedParameters[c1]));
        if(FAILED(hres)) return hres;

        boolFinished = TRUE;
      }
    }
  }

  if(FALSE == boolNotMergeable)
  {
    CComPtr<IWbemClassObject>
      pClassPolicy;

    // **** create new merged policy object

    hres = pDestCIM->GetObject(g_bstrClassMergeablePolicy, 0, NULL, &pClassPolicy, NULL);
    if(FAILED(hres)) return hres;

    hres = pClassPolicy->SpawnInstance(0, &pMergedPolicy);
    if(FAILED(hres)) return hres;

    // **** Pack TargetType

    hres = pFirstPolicy->Get(g_bstrTargetType, 0, &vPolicyAttr, NULL, NULL);
    if(FAILED(hres)) return hres;
    hres = pMergedPolicy->Put(g_bstrTargetType, 0, &vPolicyAttr, 0);
    if(FAILED(hres)) return hres;
    VariantClear(&vPolicyAttr);

    // **** Pack TargetClass

    hres = pFirstPolicy->Get(g_bstrTargetClass, 0, &vPolicyAttr, NULL, NULL);
    if(FAILED(hres)) return hres;
    hres = pMergedPolicy->Put(g_bstrTargetClass, 0, &vPolicyAttr, 0);
    if(FAILED(hres)) return hres;
    VariantClear(&vPolicyAttr);

    // **** Pack TargetPath

    hres = pFirstPolicy->Get(g_bstrTargetPath, 0, &vPolicyAttr, NULL, NULL);
    if(FAILED(hres)) return hres;
    hres = pMergedPolicy->Put(g_bstrTargetPath, 0, &vPolicyAttr, 0);
    if(FAILED(hres)) return hres;
    VariantClear(&vPolicyAttr);

    // **** Pack TargetNamespace

    hres = pFirstPolicy->Get(g_bstrTargetNameSpace, 0, &vPolicyAttr, NULL, NULL);
    if(FAILED(hres)) return hres;
    hres = pMergedPolicy->Put(g_bstrTargetNameSpace, 0, &vPolicyAttr, 0);
    if(FAILED(hres)) return hres;
    VariantClear(&vPolicyAttr);

    // **** pack RangeSettings

    V_VT(&vPolicyAttr) = (VT_ARRAY | VT_UNKNOWN);
    V_ARRAY(&vPolicyAttr) = MergedParameters.Data();

    hres = pMergedPolicy->Put(g_bstrRangeSettings, 0, &vPolicyAttr, 0);
    if(FAILED(hres)) return hres;
    VariantClear(&vPolicyAttr);

    // **** clean out merged parameter object array

    for(c1 = 0; c1 < MergedParameters.Size(); c1++)
      if(NULL != MergedParameters[c1])
      {
        MergedParameters[c1]->Release();
        MergedParameters[c1] = NULL;
      }
  }
  else
    pMergedPolicy = pFirstPolicy;

  {
    CComBSTR
      pBstr;

    hres = pMergedPolicy->GetObjectText(0, &pBstr);

    DEBUGTRACE((LOG_ESS, "POLICMAN(merge): Merged Policy: %S\n", (BSTR)pBstr));
  }

  return WBEM_S_NO_ERROR;
}