windows-xp/Source/XPSP1/NT/inetsrv/iis/admin/wmiprov_dynamic/pusher.cpp

/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    pusher.cpp

Abstract:

    This file contains the implementation of the CPusher class.
    This class contains the logic for pushing schema to the repository.

Author:

    Mohit Srivastava            28-Nov-00

Revision History:

--*/

#include "iisprov.h"
#include "pusher.h"
#include "MultiSzData.h"

extern CDynSchema* g_pDynSch; // Initialized to NULL in schemadynamic.cpp

HRESULT CPusher::RepositoryInSync(
    const CSchemaExtensions* i_pCatalog,
    bool*                    io_pbInSync)
{
    DBG_ASSERT(m_bInitSuccessful == true);
    DBG_ASSERT(io_pbInSync       != NULL);
    DBG_ASSERT(i_pCatalog        != NULL);

    HRESULT hr = WBEM_S_NO_ERROR;

    CComBSTR                  sbstrTemp;
    CComVariant               svtTimeStamp;
    CComPtr<IWbemClassObject> spObjIIsComputer;

    sbstrTemp = WMI_CLASS_DATA::s_Computer.pszClassName;
    if(sbstrTemp.m_str == NULL)
    {
        return WBEM_E_OUT_OF_MEMORY;
    }
    
    hr = m_pNamespace->GetObject(sbstrTemp, 0, m_pCtx, &spObjIIsComputer, NULL);
    if(FAILED(hr))
    {
        return hr;
    }

    //
    // Try to get timestamp from repository
    //
    hr = CUtils::GetQualifiers(spObjIIsComputer, &g_wszCq_SchemaTS, &svtTimeStamp, 1);
    if(FAILED(hr) || svtTimeStamp.vt != VT_BSTR)
    {
        *io_pbInSync = false;
        return WBEM_S_NO_ERROR;
    }

    //
    // Get timestamp of mbschema.xml
    //
    FILETIME FileTime;
    hr = i_pCatalog->GetMbSchemaTimeStamp(&FileTime);
    if(FAILED(hr))
    {
        return hr;
    }

    //
    // Finally, compare the timestamps
    //
    WCHAR wszFileTime[30];
    CUtils::FileTimeToWchar(&FileTime, wszFileTime);
    if(_wcsicmp(wszFileTime, svtTimeStamp.bstrVal) == 0)
    {
        *io_pbInSync = true;
    }
    else
    {
        *io_pbInSync = false;
    }
    return hr;
}

HRESULT CPusher::SetTimeStamp(
    const CSchemaExtensions* i_pCatalog)
{
    DBG_ASSERT(m_bInitSuccessful == true);
    DBG_ASSERT(i_pCatalog        != NULL);

    HRESULT hr = WBEM_S_NO_ERROR;

    CComBSTR                  sbstrTemp;
    CComVariant               svtTimeStamp;
    CComPtr<IWbemClassObject> spObjIIsComputer;

    sbstrTemp = WMI_CLASS_DATA::s_Computer.pszClassName;
    if(sbstrTemp.m_str == NULL)
    {
        return WBEM_E_OUT_OF_MEMORY;
    }
    
    hr = m_pNamespace->GetObject(sbstrTemp, 0, m_pCtx, &spObjIIsComputer, NULL);
    if(FAILED(hr))
    {
        return hr;
    }

    //
    // Get timestamp of mbschema.xml
    //
    FILETIME FileTime;
    hr = i_pCatalog->GetMbSchemaTimeStamp(&FileTime);
    if(FAILED(hr))
    {
        return hr;
    }
    WCHAR wszFileTime[30];
    CUtils::FileTimeToWchar(&FileTime, wszFileTime);

    //
    // Finally, Set the timestamp in the repository
    //
    svtTimeStamp = wszFileTime;
    if(svtTimeStamp.vt != VT_BSTR || svtTimeStamp.bstrVal == NULL)
    {
        return WBEM_E_OUT_OF_MEMORY;
    }
    hr = CUtils::SetQualifiers(
        spObjIIsComputer,
        &g_wszCq_SchemaTS,
        &svtTimeStamp,
        1,
        0);
    if(FAILED(hr))
    {
        return hr;
    }

    //
    // Finally, put the class
    //
    hr = m_pNamespace->PutClass(spObjIIsComputer, WBEM_FLAG_OWNER_UPDATE, m_pCtx, NULL);
    if(FAILED(hr))
    {
        return hr;
    }

    return hr;
}

HRESULT CPusher::Initialize(CWbemServices* i_pNamespace,
                            IWbemContext*  i_pCtx)
/*++

Synopsis: 
    Only call once.

Arguments: [i_pNamespace] - 
           [i_pCtx] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(i_pNamespace      != NULL);
    DBG_ASSERT(i_pCtx            != NULL);
    DBG_ASSERT(m_bInitCalled     == false);
    DBG_ASSERT(m_bInitSuccessful == false);

    HRESULT  hr = WBEM_S_NO_ERROR;
    CComBSTR bstrTemp;

    m_bInitCalled           = true;
    m_pCtx                  = i_pCtx;
    m_pNamespace            = i_pNamespace;
    m_awszClassQualNames[1] = g_wszCq_Dynamic;
    m_avtClassQualValues[1] = (bool)true;
    m_awszClassQualNames[0] = g_wszCq_Provider;
    m_avtClassQualValues[0] = g_wszCqv_Provider;;
    if(m_avtClassQualValues[0].bstrVal == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }

    //
    // Get pointers to most commonly used base classes
    //
    bstrTemp = g_wszExtElementParent;
    if(bstrTemp.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }
    hr = m_pNamespace->GetObject(bstrTemp, 0, m_pCtx, &m_spBaseElementObject, NULL);
    if(FAILED(hr))
    {
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }

    bstrTemp = g_wszExtSettingParent;
    if(bstrTemp.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }
    hr = m_pNamespace->GetObject(bstrTemp, 0, m_pCtx, &m_spBaseSettingObject, NULL);
    if(FAILED(hr))
    {
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }

    bstrTemp = g_wszExtElementSettingAssocParent;
    if(bstrTemp.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }
    hr = m_pNamespace->GetObject(bstrTemp, 0, m_pCtx, &m_spBaseElementSettingObject, NULL);
    if(FAILED(hr))
    {
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }

    bstrTemp = g_wszExtGroupPartAssocParent;
    if(bstrTemp.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }
    hr = m_pNamespace->GetObject(bstrTemp, 0, m_pCtx, &m_spBaseGroupPartObject, NULL);
    if(FAILED(hr))
    {
        DBGPRINTF((DBG_CONTEXT, "CPusher::Initialize failed, hr=0x%x\n", hr));
        goto exit;
    }

exit:
    if(SUCCEEDED(hr))
    {
        m_bInitSuccessful = true;
    }
    return hr;
}

CPusher::~CPusher()
{
}

HRESULT CPusher::Push(
    const CSchemaExtensions*      i_pCatalog,
    CHashTable<WMI_CLASS *>*      i_phashClasses,
    CHashTable<WMI_ASSOCIATION*>* i_phashAssocs)
{
    DBG_ASSERT(i_pCatalog        != NULL);
    DBG_ASSERT(i_phashClasses    != NULL);
    DBG_ASSERT(i_phashAssocs     != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT hr = WBEM_S_NO_ERROR;

    bool bInSync= false;

    hr = RepositoryInSync(i_pCatalog, &bInSync);
    if(FAILED(hr))
    {
        return hr;
    }

    if(!bInSync)
    {
        hr = PushClasses(i_phashClasses);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::Push failed, hr=0x%x\n", hr));
            return hr;
        }
        hr = PushAssocs(i_phashAssocs);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::Push failed, hr=0x%x\n", hr));
            return hr;
        }
        hr = SetTimeStamp(i_pCatalog);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::Push failed, hr=0x%x\n", hr));
            return hr;
        }
    }

    return hr;
}

HRESULT CPusher::PushClasses(
    CHashTable<WMI_CLASS *>* i_phashTable)
/*++

Synopsis: 
    Public function to push classes to repository.
    1) Precondition: All USER_DEFINED_TO_REPOSITORY classes are not in repository.
    2) Pushes all USER_DEFINED_TO_REPOSITORY classes to repository.
    3) Deletes and recreates SHIPPED_TO_MOF, SHIPPED_NOT_TO_MOF, and
       EXTENDED classes if necessary.

Arguments: [i_phashTable] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(i_phashTable      != NULL);
    DBG_ASSERT(m_pNamespace      != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT hr = WBEM_S_NO_ERROR;
    CComPtr<IWbemClassObject>  spObject = NULL;
    CComPtr<IWbemClassObject>  spChildObject = NULL;

    //
    // Vars needed for iteration
    //
    CHashTable<WMI_CLASS*>::Record*  pRec = NULL;
    CHashTable<WMI_CLASS*>::iterator iter;
    CHashTable<WMI_CLASS*>::iterator iterEnd;

    CComVariant v;    

    //
    // DeleteChildren of extended base classes
    //
    LPWSTR awszBaseClasses[] = { 
        g_wszExtElementParent, 
        g_wszExtSettingParent,
        NULL };

    for(ULONG idx = 0; awszBaseClasses[idx] != NULL; idx++)
    {
        hr = DeleteChildren(awszBaseClasses[idx]);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
            goto exit;
        }
    }

    //
    // Walk thru the hashtable of classes
    //
    bool  bPutNeeded;
    iterEnd = i_phashTable->end();
    for(iter = i_phashTable->begin(); iter != iterEnd; ++iter)
    {
        pRec = iter.Record();
        DBG_ASSERT(pRec != NULL);

        //
        // Deletes SHIPPED_TO_MOF, SHIPPED_NOT_TO_MOF, EXTENDED classes if necessary.
        //
        hr = PrepareForPutClass(pRec->m_data, &bPutNeeded);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
            goto exit;
        }

        if(bPutNeeded)
        {
            hr = GetObject(pRec->m_data->pszParentClass, &spObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }

            hr = spObject->SpawnDerivedClass(0, &spChildObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }
            spObject = NULL;

            //
            // Push class qualifiers and special __CLASS property.
            //
            hr = SetClassInfo(
                spChildObject, 
                pRec->m_wszKey,
                pRec->m_data->dwExtended);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }

            //
            // Name property and corresponding qualifier
            // Base class may contain Name.  Handle this case
            //
            bool bPutNameProperty = true;
            for(ULONG j = 0; g_awszParentClassWithNamePK[j] != NULL; j++)
            {
                //
                // Deliberate ==
                //
                if(g_awszParentClassWithNamePK[j] == pRec->m_data->pszParentClass)
                {
                    bPutNameProperty = false;
                }
            }
            if( bPutNameProperty )
            {
                hr = spChildObject->Put(g_wszProp_Name, 0, NULL, CIM_STRING);
                if(FAILED(hr))
                {
                    DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                    goto exit;
                }
                v = (bool)true;
                hr = CUtils::SetPropertyQualifiers(
                    spChildObject, 
                    g_wszProp_Name, // Property name
                    &g_wszPq_Key,   // Array of qual names
                    &v,             // Array of qual values
                    1               // Nr of quals
                    );
                if(FAILED(hr))
                {
                    DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                    goto exit;
                }
            }

            //
            // All other properties
            //
            hr = SetProperties(pRec->m_data, spChildObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }

            //
            // Any methods
            //
            hr = SetMethods(pRec->m_data, spChildObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }

            //
            // Finally, put the class
            //
            hr = m_pNamespace->PutClass(spChildObject, WBEM_FLAG_OWNER_UPDATE, m_pCtx, NULL);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushClasses failed, hr=0x%x\n", hr));
                goto exit;
            }

            spChildObject = NULL;
        }
    }

exit:
    return hr;
}

HRESULT CPusher::PushAssocs(
    CHashTable<WMI_ASSOCIATION*>* i_phashTable)
/*++

Synopsis: 
    Public function to push assocs to repository.
    - Precondition: All USER_DEFINED_TO_REPOSITORY assocs are not in repository.
    - Pushes all USER_DEFINED_TO_REPOSITORY assocs to repository.

Arguments: [i_phashTable] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(i_phashTable      != NULL);
    DBG_ASSERT(m_pNamespace      != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT hr = WBEM_S_NO_ERROR;
    CComPtr<IWbemClassObject>  spObject = NULL;
    CComPtr<IWbemClassObject>  spChildObject = NULL;

    //
    // Vars needed for iteration
    //
    CHashTable<WMI_ASSOCIATION*>::Record*  pRec = NULL;
    CHashTable<WMI_ASSOCIATION*>::iterator iter;
    CHashTable<WMI_ASSOCIATION*>::iterator iterEnd;

    //
    // DeleteChildren of extended base classes
    //
    LPWSTR awszBaseClasses[] = { 
        g_wszExtElementSettingAssocParent, 
        g_wszExtGroupPartAssocParent,
        NULL };

    for(ULONG idx = 0; awszBaseClasses[idx] != NULL; idx++)
    {
        hr = DeleteChildren(awszBaseClasses[idx]);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
            goto exit;
        }
    }

    //
    // Walk thru the hashtable of assocs
    //
    for(iter = i_phashTable->begin(), iterEnd = i_phashTable->end();
        iter != iterEnd; 
        ++iter)
    {
        pRec = iter.Record();
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
            goto exit;
        }

        if(pRec->m_data->dwExtended == USER_DEFINED_TO_REPOSITORY)
        {
            hr = GetObject(pRec->m_data->pszParentClass, &spObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                goto exit;
            }

            hr = spObject->SpawnDerivedClass(0, &spChildObject);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                goto exit;
            }
            spObject = NULL;

            //
            // Push class qualifiers and special __CLASS property.
            //
            hr = SetClassInfo(
                spChildObject, 
                pRec->m_wszKey,
                pRec->m_data->dwExtended);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                goto exit;
            }

            //
            // Push the two ref properties of the association.
            //
            hr = SetAssociationComponent(
                spChildObject,
                pRec->m_data->pType->pszLeft,
                pRec->m_data->pcLeft->pszClassName);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                goto exit;
            }
            hr = SetAssociationComponent(
                spChildObject,
                pRec->m_data->pType->pszRight,
                pRec->m_data->pcRight->pszClassName);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                goto exit;
            }

            hr = m_pNamespace->PutClass(
                spChildObject, 
                WBEM_FLAG_OWNER_UPDATE | WBEM_FLAG_CREATE_ONLY, 
                m_pCtx, 
                NULL);
            if(FAILED(hr))
            {
                if(hr == WBEM_E_ALREADY_EXISTS)
                {
                    hr = WBEM_S_NO_ERROR;
                }
                else
                {
                    DBGPRINTF((DBG_CONTEXT, "CPusher::PushAssocs failed, hr=0x%x\n", hr));
                    goto exit;
                }
            }

            spChildObject = NULL;
        }
    }

exit:
    return hr;
}

HRESULT CPusher::PrepareForPutClass(
    const WMI_CLASS* i_pClass,
    bool*            io_pbPutNeeded)
/*++

Synopsis: 
    Deletes and recreates SHIPPED_TO_MOF, SHIPPED_NOT_TO_MOF, and
    EXTENDED classes if necessary.  Sets io_pbPutNeeded accordingly.

Arguments: [i_pClass] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(m_bInitSuccessful == true);
    DBG_ASSERT(i_pClass          != NULL);
    DBG_ASSERT(io_pbPutNeeded    != NULL);

    HRESULT  hr               = WBEM_S_NO_ERROR;
    CComPtr<IWbemClassObject> spObj;
    CComBSTR bstrClass        = i_pClass->pszClassName;
    if(bstrClass.m_str == NULL)
    {
        return WBEM_E_OUT_OF_MEMORY;
    }
    bool bExtendedQual        = false;
    bool bPutNeeded           = false;

    HRESULT hrGetObject = m_pNamespace->GetObject(
        bstrClass, 
        WBEM_FLAG_RETURN_WBEM_COMPLETE, 
        m_pCtx, 
        &spObj, 
        NULL);
    if( hrGetObject != WBEM_E_INVALID_CLASS && 
        hrGetObject != WBEM_E_NOT_FOUND)
    {
        hr = hrGetObject;
    }
    if(FAILED(hr))
    {
        return hr;
    }

    //
    // Determine if the [extended] qualifier is set.
    //
    if(SUCCEEDED(hrGetObject))
    {
        VARIANT  vtExtended;
        VariantInit(&vtExtended);

        HRESULT hrGetQuals = 
            CUtils::GetQualifiers(spObj, &g_wszCq_Extended, &vtExtended, 1);
        if(FAILED(hrGetQuals))
        {
            bExtendedQual = false;
        }
        else if(vtExtended.vt == VT_BOOL)
        {
            bExtendedQual = vtExtended.boolVal ? true : false;
        }
    }

    //
    // Pretty much, don't do a Put class if both the catalog and repository
    // versions are shipped.  This is an optimization for the normal case.
    //
    switch(i_pClass->dwExtended)
    {
    case EXTENDED:
        if( hrGetObject != WBEM_E_INVALID_CLASS && 
            hrGetObject != WBEM_E_NOT_FOUND)
        {
            hr = m_pNamespace->DeleteClass(
                bstrClass,
                WBEM_FLAG_OWNER_UPDATE,
                m_pCtx,
                NULL);
            if(FAILED(hr))
            {
                return hr;
            }
        }
        bPutNeeded = true;
        break;
    case USER_DEFINED_NOT_TO_REPOSITORY:
        bPutNeeded = false;
        break;
    case USER_DEFINED_TO_REPOSITORY:
        if( hrGetObject != WBEM_E_INVALID_CLASS && 
            hrGetObject != WBEM_E_NOT_FOUND)
        {
            //
            // There is already a class in the repository with the same name
            // as this user-defined class.
            // TODO: Log an error.
            //
            bPutNeeded = false;
        }
        else
        {
            bPutNeeded = true;
        }
        break;
    case SHIPPED_TO_MOF:
    case SHIPPED_NOT_TO_MOF:
        if(bExtendedQual)
        {
            if( hrGetObject != WBEM_E_INVALID_CLASS && 
                hrGetObject != WBEM_E_NOT_FOUND)
            {
                hr = m_pNamespace->DeleteClass(
                    bstrClass,
                    WBEM_FLAG_OWNER_UPDATE,
                    m_pCtx,
                    NULL);
                if(FAILED(hr))
                {
                    return hr;
                }
            }
            bPutNeeded = true;
        }
        else
        {
            bPutNeeded = (hrGetObject == WBEM_E_INVALID_CLASS || 
                          hrGetObject == WBEM_E_NOT_FOUND) ? true : false;
        }
        break;
    default:
        DBG_ASSERT(false && "Unknown i_pClass->dwExtended");
        break;
    }

    *io_pbPutNeeded = bPutNeeded;

    return hr;
}

HRESULT CPusher::SetClassInfo(
    IWbemClassObject* i_pObj,
    LPCWSTR           i_wszClassName,
    ULONG             i_iShipped)
/*++

Synopsis: 
    Sets class qualifiers and special __CLASS property on i_pObj

Arguments: [i_pObj]         - The class or association
           [i_wszClassName] - Will be value of __CLASS property
           [i_iShipped]     - Determines if we set g_wszCq_Extended qualifier
           
Return Value: 

--*/
{
    DBG_ASSERT(i_pObj            != NULL);
    DBG_ASSERT(i_wszClassName    != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);
    HRESULT     hr;
    CComVariant v;

    //
    // Class qualifiers (propagated to instance)
    //
    hr = CUtils::SetQualifiers(
        i_pObj, 
        m_awszClassQualNames, 
        m_avtClassQualValues, 
        2,
        WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE);
    if(FAILED(hr))
    {
        goto exit;
    }

    //
    // Another class qualifier (not propagated to instance)
    //
    if(i_iShipped == EXTENDED)
    {
        v = (bool)true;
        hr = CUtils::SetQualifiers(
            i_pObj, 
            &g_wszCq_Extended, 
            &v, 
            1, 
            0);
        if(FAILED(hr))
        {
            goto exit;
        }
    }

    //
    // Special __CLASS property
    //
    v = i_wszClassName;
    if(v.bstrVal == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        goto exit;
    }
    hr = i_pObj->Put(g_wszProp_Class, 0, &v, 0);
    if(FAILED(hr))
    {
        goto exit;
    }

exit:
    return hr;
}

HRESULT CPusher::SetMethods(
    const WMI_CLASS*  i_pElement,
    IWbemClassObject* i_pObject) const
/*++

Synopsis: 
    Called by PushClasses.
    Sets the methods in i_pObject using i_pElement

Arguments: [i_pElement] -
           [i_pObject] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(i_pElement        != NULL);
    DBG_ASSERT(i_pObject         != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT hr = WBEM_S_NO_ERROR;

    if(i_pElement->ppMethod == NULL)
    {
        return WBEM_S_NO_ERROR;
    }

    CComPtr<IWbemClassObject> spParamsIn;
    CComPtr<IWbemClassObject> spParamsOut;

    //
    // Run thru all the methods
    //
    WMI_METHOD* pMethCurrent = NULL;
    for(ULONG i = 0; i_pElement->ppMethod[i] != NULL; i++)
    {
        pMethCurrent = i_pElement->ppMethod[i];
        spParamsIn   = NULL;
        spParamsOut  = NULL;

        if(pMethCurrent->ppParams != NULL)
        {
            WMI_METHOD_PARAM* pParamCur = NULL;

            //
            // The index to indicate to WMI the order of the parameters
            // wszId is the qualifier name.  svtId is a variant so we can give to WMI.
            //
            static LPCWSTR    wszId     = L"ID";
            CComVariant       svtId     = (int)0;

            //
            // Run thru all the parameters
            //
            for(ULONG j = 0; pMethCurrent->ppParams[j] != NULL; j++)
            {
                //
                // This will just hold spParamsIn and spParamsOut so we
                // don't need to duplicate the code.
                //
                IWbemClassObject* apParamInOut[] = { NULL, NULL };

                //
                // Create the WMI instance for the in and/or out params as needed.
                //
                pParamCur = pMethCurrent->ppParams[j];
                if( pParamCur->iInOut == PARAM_IN ||
                    pParamCur->iInOut == PARAM_INOUT )
                {
                    if(spParamsIn == NULL)
                    {
                        hr = m_pNamespace->GetObject(L"__Parameters", 0, m_pCtx, &spParamsIn, NULL);
                        if(FAILED(hr))
                        {
                            DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
                            goto exit;
                        }
                    }
                    apParamInOut[0] = spParamsIn;
                }
                if( pParamCur->iInOut == PARAM_OUT ||
                    pParamCur->iInOut == PARAM_INOUT )
                {
                    if(spParamsOut == NULL)
                    {
                        hr = m_pNamespace->GetObject(L"__Parameters", 0, m_pCtx, &spParamsOut, NULL);
                        if(FAILED(hr))
                        {
                            DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
                            goto exit;
                        }
                    }
                    apParamInOut[1] = spParamsOut;
                }

                //
                // Finally set them.  First ins then outs.
                //
                for(ULONG k = 0; k < 2; k++)
                {
                    if(apParamInOut[k] == NULL)
                    {
                        continue;
                    }
                    hr = apParamInOut[k]->Put(
                        pParamCur->pszParamName, 0, NULL, pParamCur->type);
                    if(FAILED(hr))
                    {
                        DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
                        goto exit;
                    }

                    hr = CUtils::SetPropertyQualifiers(
                        apParamInOut[k], pParamCur->pszParamName, &wszId, &svtId, 1);
                    if(FAILED(hr))
                    {
                        DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
                        goto exit;
                    }
                }
                if(apParamInOut[0] || apParamInOut[1])
                {
                    svtId.lVal++;
                }
            }
        }

        //
        // Put the method.
        //
        hr = i_pObject->PutMethod(
            pMethCurrent->pszMethodName, 0, spParamsIn, spParamsOut);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
            goto exit;
        }

        VARIANT vImplemented;
        vImplemented.boolVal = VARIANT_TRUE;
        vImplemented.vt      = VT_BOOL;
        hr = CUtils::SetMethodQualifiers(
            i_pObject,
            pMethCurrent->pszMethodName,
            &g_wszMq_Implemented,
            &vImplemented,
            1);
        if(FAILED(hr))
        {
            DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
            goto exit;
        }

        /*if(pMethCurrent->pszDescription)
        {
            VARIANT vDesc;
            vDesc.bstrVal = pMethCurrent->pszDescription;
            vDesc.vt      = VT_BSTR;
            hr = CUtils::SetMethodQualifiers(
                i_pObject, 
                pMethCurrent->pszMethodName, 
                &g_wszMq_Description,
                &vDesc, 
                1);
            if(FAILED(hr))
            {
                DBGPRINTF((DBG_CONTEXT, "CPusher::SetMethods failed, hr=0x%x\n", hr));
                goto exit;
            }
        }*/
    }

exit:
    return hr;
}

HRESULT CPusher::SetProperties(
    const WMI_CLASS*  i_pElement, 
    IWbemClassObject* i_pObject) const
/*++

Synopsis: 
    Called by PushClasses.
    Sets the properties in i_pObject using i_pElement

Arguments: [i_pElement] -
           [i_pObject] - 
           
Return Value: 

--*/
{
    DBG_ASSERT(i_pElement        != NULL);
    DBG_ASSERT(i_pObject         != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT            hr                = WBEM_S_NO_ERROR;
    METABASE_PROPERTY* pPropCurrent      = NULL;
    TFormattedMultiSz* pFormattedMultiSz = NULL;
    CIMTYPE typeProp;

    CComPtr<IWbemQualifierSet> spQualSet;
    VARIANT v;
    VariantInit(&v);

    if(i_pElement->ppmbp == NULL)
    {
        return hr;
    }

    for(ULONG i = 0; i_pElement->ppmbp[i] != NULL; i++)
    {
        pPropCurrent      = i_pElement->ppmbp[i];
        pFormattedMultiSz = NULL;
        switch(pPropCurrent->dwMDDataType)
        {
        case DWORD_METADATA:
            if(pPropCurrent->dwMDMask != 0)
            {
                typeProp = CIM_BOOLEAN;
            }
            else
            {
                typeProp = CIM_SINT32;
            }
            break;
        case STRING_METADATA:
        case EXPANDSZ_METADATA:
            typeProp = CIM_STRING;
            break;
        case MULTISZ_METADATA:
            typeProp = VT_ARRAY | CIM_STRING;
            
            pFormattedMultiSz = 
                TFormattedMultiSzData::Find(pPropCurrent->dwMDIdentifier);
            if(pFormattedMultiSz)
            {
                typeProp = VT_ARRAY | CIM_OBJECT;
            }
            break;
        case BINARY_METADATA:
            typeProp = VT_ARRAY | CIM_UINT8;
            break;
        default:
            //
            // Non fatal if we cannot recognize type
            //
            continue;
        }

        hr = i_pObject->Put(pPropCurrent->pszPropName, 0, NULL, typeProp);
        if(FAILED(hr))
        {
            goto exit;
        }

        //
        // qualifiers
        //
        hr = i_pObject->GetPropertyQualifierSet(pPropCurrent->pszPropName, &spQualSet);
        if(FAILED(hr))
        {
            goto exit;
        }

        //
        // qualifier for read-only
        //
        V_VT(&v)   = VT_BOOL;
        V_BOOL(&v) = (pPropCurrent->fReadOnly) ? VARIANT_FALSE : VARIANT_TRUE;
        hr = spQualSet->Put(g_wszPq_Write, &v, 0);
        if(FAILED(hr))
        {
            goto exit;
        }
        V_BOOL(&v) = VARIANT_TRUE;
        hr = spQualSet->Put(g_wszPq_Read, &v, 0);
        if(FAILED(hr))
        {
            goto exit;
        }
        VariantClear(&v);

        //
        // CIMType qualifier
        //
        if(pFormattedMultiSz)
        {
            DBG_ASSERT(typeProp == (VT_ARRAY | CIM_OBJECT));

            CComBSTR sbstrValue = L"object:";
            if(sbstrValue.m_str == NULL)
            {
                hr = WBEM_E_OUT_OF_MEMORY;
                goto exit;
            }
            sbstrValue += pFormattedMultiSz->wszWmiClassName;
            if(sbstrValue.m_str == NULL)
            {
                hr = WBEM_E_OUT_OF_MEMORY;
                goto exit;
            }

            //
            // Deliberately not smart variant.  We will let sbstrValue do deconstruction.
            //
            VARIANT vValue;
            vValue.vt      = VT_BSTR;
            vValue.bstrVal = sbstrValue;
            hr = spQualSet->Put(g_wszPq_CimType, &vValue, 0);
            if(FAILED(hr))
            {
                goto exit;
            }
        }

        spQualSet = NULL;
    }

exit:
    VariantClear(&v);
    return hr;
}

HRESULT CPusher::SetAssociationComponent(
    IWbemClassObject* i_pObject, 
    LPCWSTR           i_wszComp, 
    LPCWSTR           i_wszClass) const
/*++

Synopsis: 
    Called by PushAssocs
    Sets a ref property of an association, i_pObj, using i_wszComp and i_wszClass

Arguments: [i_pObject] - the association
           [i_wszComp] - property name (Eg. Group, Part)
           [i_wszClass] - the class we are "ref"fing to.
           
Return Value: 

--*/
{
    DBG_ASSERT(i_pObject         != NULL);
    DBG_ASSERT(i_wszComp         != NULL);
    DBG_ASSERT(i_wszClass        != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT                    hr = WBEM_S_NO_ERROR;
    CComPtr<IWbemQualifierSet> spQualSet;
    VARIANT                    v;
    VariantInit(&v);

    //
    // Store "Ref:[class name]" in a bstr.
    //
    ULONG                      cchClass = wcslen(i_wszClass);
    CComBSTR                   sbstrClass(4 + cchClass);
    if(sbstrClass.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        goto exit;
    }
    memcpy(sbstrClass.m_str    , L"Ref:",    sizeof(WCHAR)*4);
    memcpy(sbstrClass.m_str + 4, i_wszClass, sizeof(WCHAR)*(cchClass+1));

    //
    // Put the property (Eg. Group, Part, etc.)
    //
    hr = i_pObject->Put(i_wszComp, 0, NULL, CIM_REFERENCE);
    if(FAILED(hr))
    {
        goto exit;
    }

    //
    // Set Qualifiers on the property
    //
    hr = i_pObject->GetPropertyQualifierSet(i_wszComp, &spQualSet);
    if(FAILED(hr))
    {
        goto exit;
    }

    V_VT(&v) = VT_BOOL;
    V_BOOL(&v) = VARIANT_TRUE;
    hr = spQualSet->Put(g_wszPq_Key, &v, 0);
    if(FAILED(hr))
    {
        goto exit;
    }

    V_VT(&v)   = VT_BSTR;
    V_BSTR(&v) = sbstrClass.m_str;
    if(V_BSTR(&v) == NULL)
    {
        V_VT(&v) = VT_EMPTY;
        hr       = WBEM_E_OUT_OF_MEMORY;
        goto exit;
    }
    hr = spQualSet->Put(g_wszPq_CimType, &v, 0);
    V_VT(&v)   = VT_EMPTY;
    V_BSTR(&v) = NULL;
    if(FAILED(hr))
    {
        goto exit;
    }

exit:
    return hr;
}

bool CPusher::NeedToDeleteAssoc(
    IWbemClassObject*  i_pObj) const
/*++

Synopsis: 
    Sees if the association i_pObj is already in hashtable.
    If it is, no point in deleting i_pObj from repository only to recreate
    it later.

Arguments: [i_pObj] -   An IWbemClassObject representation of an assoc
           
Return Value: 
    true  if i_pObj not in hashtable
    false otherwise

--*/
{
    DBG_ASSERT(i_pObj            != NULL);
    DBG_ASSERT(g_pDynSch         != NULL);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT     hr     = WBEM_S_NO_ERROR;
    bool        bMatch = false;
    
    CComVariant vt;
    LPWSTR      wsz;

    CComPtr<IWbemQualifierSet>     spQualSet;

    CHashTable<WMI_ASSOCIATION *>* pHash  = g_pDynSch->GetHashAssociations();
    WMI_ASSOCIATION*               pAssoc;

    DBG_ASSERT(pHash != NULL);

    //
    // Compare the association names
    //
    hr = i_pObj->Get(g_wszProp_Class, 0, &vt, NULL, NULL);
    if(FAILED(hr) || vt.vt != VT_BSTR)
    {
        goto exit;
    }
    hr = pHash->Wmi_GetByKey(vt.bstrVal, &pAssoc);
    if(FAILED(hr))
    {
        goto exit;
    }
    vt.Clear();

    //
    // This is the only case we care about
    //
    if(pAssoc->dwExtended != USER_DEFINED_TO_REPOSITORY)
    {
        goto exit;
    }

    //
    // Compare the left association component
    //
    hr = i_pObj->GetPropertyQualifierSet(
        pAssoc->pType->pszLeft,
        &spQualSet);
    if(FAILED(hr))
    {
        goto exit;
    }
    spQualSet->Get(g_wszPq_CimType, 0, &vt, NULL);
    spQualSet = NULL;
    if(FAILED(hr) || vt.vt != VT_BSTR)
    {
        goto exit;
    }
    if( (wsz = wcschr(vt.bstrVal, L':')) == NULL )
    {
        goto exit;
    }
    wsz++;
    if(_wcsicmp(wsz, pAssoc->pcLeft->pszClassName) != 0)
    {
        goto exit;
    }
    vt.Clear();

    //
    // Compare the right association component
    //
    hr = i_pObj->GetPropertyQualifierSet(
        pAssoc->pType->pszRight,
        &spQualSet);
    if(FAILED(hr))
    {
        goto exit;
    }
    spQualSet->Get(g_wszPq_CimType, 0, &vt, NULL);
    spQualSet = NULL;
    if(FAILED(hr) || vt.vt != VT_BSTR)
    {
        goto exit;
    }
    if( (wsz = wcschr(vt.bstrVal, L':')) == NULL )
    {
        goto exit;
    }
    wsz++;
    if(_wcsicmp(wsz, pAssoc->pcRight->pszClassName) != 0)
    {
        goto exit;
    }
    vt.Clear();

    bMatch = true;
    pAssoc->dwExtended = USER_DEFINED_NOT_TO_REPOSITORY;

exit:
    return !bMatch;
}

HRESULT CPusher::DeleteChildren(LPCWSTR i_wszExtSuperClass)
{
    DBG_ASSERT(i_wszExtSuperClass != NULL);
    DBG_ASSERT(m_bInitSuccessful  == true);

    //
    // Only can be called from inside Initialize
    //
    DBG_ASSERT(m_bInitCalled      == true);
    DBG_ASSERT(m_bInitSuccessful  == true);

    IEnumWbemClassObject*pEnum     = NULL;
    HRESULT              hr        = WBEM_S_NO_ERROR;

    IWbemClassObject*    apObj[10] = {0};
    ULONG                nrObj     = 0;
    ULONG                i = 0;

    VARIANT              v;
    VariantInit(&v);

    CComBSTR bstrExtSuperClass = i_wszExtSuperClass;
    if(bstrExtSuperClass.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        goto exit;
    }

    hr = m_pNamespace->CreateClassEnum(
        bstrExtSuperClass, 
        WBEM_FLAG_FORWARD_ONLY, 
        m_pCtx,
        &pEnum);
    if(FAILED(hr))
    {
        goto exit;
    }

    hr = pEnum->Next(WBEM_INFINITE, 10, apObj, &nrObj);
    while(SUCCEEDED(hr) && nrObj > 0)
    {
        for(i = 0; i < nrObj; i++)
        {
            bool bDelete;
            if( i_wszExtSuperClass == g_wszExtElementSettingAssocParent ||
                i_wszExtSuperClass == g_wszExtGroupPartAssocParent)
            {
                bDelete = NeedToDeleteAssoc(apObj[i]);
            }
            else
            {
                bDelete = true;
            }
            if(bDelete)
            {
                hr = apObj[i]->Get(g_wszProp_Class, 0, &v, NULL, NULL);
                if(FAILED(hr))
                {
                    goto exit;
                }

                hr = m_pNamespace->DeleteClass(v.bstrVal, WBEM_FLAG_OWNER_UPDATE, m_pCtx, NULL);
                if(FAILED(hr))
                {
                    goto exit;
                }

                VariantClear(&v);
            }
            apObj[i]->Release();
            apObj[i] = NULL;
        }
        
        hr = pEnum->Next(WBEM_INFINITE, 10, apObj, &nrObj);
    }
    if(FAILED(hr))
    {
        goto exit;
    }

exit:
    if(pEnum)
    {
        pEnum->Release();
        pEnum = NULL;
    }
    VariantClear(&v);
    for(i = 0; i < 10; i++)
    {
        if(apObj[i])
        {
            apObj[i]->Release();
        }
    }
    return hr;
}

HRESULT CPusher::GetObject(
    LPCWSTR            i_wszClass, 
    IWbemClassObject** o_ppObj)
{
    DBG_ASSERT(o_ppObj != NULL);
    DBG_ASSERT(m_bInitCalled == true);
    DBG_ASSERT(m_bInitSuccessful == true);

    HRESULT hr = WBEM_S_NO_ERROR;
    IWbemClassObject* pObject;

    if(i_wszClass == g_wszExtElementParent)
    {
        *o_ppObj = m_spBaseElementObject;
        (*o_ppObj)->AddRef();
    }
    else if(i_wszClass == g_wszExtSettingParent)
    {
        *o_ppObj = m_spBaseSettingObject;
        (*o_ppObj)->AddRef();
    }
    else if(i_wszClass == g_wszExtElementSettingAssocParent)
    {
        *o_ppObj = m_spBaseElementSettingObject;
        (*o_ppObj)->AddRef();
    }
    else if(i_wszClass == g_wszExtGroupPartAssocParent)
    {
        *o_ppObj = m_spBaseGroupPartObject;
        (*o_ppObj)->AddRef();
    }
    else
    {
        const CComBSTR sbstrClass = i_wszClass;
        if(sbstrClass.m_str == NULL)
        {
            hr = WBEM_E_OUT_OF_MEMORY;
            goto exit;
        }
        hr = m_pNamespace->GetObject(sbstrClass, 0, m_pCtx, &pObject, NULL);
        if(FAILED(hr))
        {
            goto exit;
        }
        *o_ppObj = pObject;
    }

exit:
    return hr;
}

/*HRESULT CPusher::NeedToPutAssoc(
    WMI_ASSOCIATION* i_pAssoc,
    bool*            io_pbPutNeeded)
{
    DBG_ASSERT(m_bInitCalled     == true);
    DBG_ASSERT(m_bInitSuccessful == true);
    DBG_ASSERT(i_pAssoc          != NULL);
    DBG_ASSERT(io_pbPutNeeded    != NULL);

    HRESULT  hr               = WBEM_S_NO_ERROR;
    CComBSTR bstrAssoc;
    bool bExtendedQual        = false;
    bool bPutNeeded           = false;

    if(i_pAssoc->dwExtended != USER_DEFINED_TO_REPOSITORY)
    {
        goto exit;
    }
    
    bstrAssoc = i_pAssoc->pszAssociationName;
    if(bstrAssoc.m_str == NULL)
    {
        hr = WBEM_E_OUT_OF_MEMORY;
        goto exit;
    }

    HRESULT hrGetObject = m_pNamespace->GetObject(
        bstrAssoc, 
        WBEM_FLAG_RETURN_WBEM_COMPLETE, 
        m_pCtx, 
        NULL, 
        NULL);
    if( hrGetObject != WBEM_E_INVALID_CLASS && 
        hrGetObject != WBEM_E_NOT_FOUND)
    {
        hr = hrGetObject;
    }
    if(FAILED(hr))
    {
        goto exit;
    }

    if( hrGetObject == WBEM_E_INVALID_CLASS ||
        hrGetObject == WBEM_E_NOT_FOUND )
    {
        bPutNeeded = true;
    }

exit:
    if(SUCCEEDED(hr))
    {
        *io_pbPutNeeded = bPutNeeded;
    }
    return hr;
}*/