/*++

Copyright (C) 1996-2001 Microsoft Corporation

Module Name:

    SVCQ.CPP

Abstract:

    Implemntation of asynchronous request queue classes.

    Classes implemented:

    CAsyncReq and derivatives    Asynchrnous requests to WINMGMT.
    CAsyncServiceQueue           The queue of such requests.

History:

    raymcc        16-Jul-96       Created.
    levn          12-Sep-96       Implemented a few requests.
                                  Added LoadProviders

--*/

#include "precomp.h"
#include <wbemcore.h>
#include <svcq.h>
#include <oahelp.inl>

CAsyncServiceQueue::CAsyncServiceQueue(_IWmiArbitrator * pArb)
: m_bInit( FALSE )
{
    m_lRef = 1;
    m_bInit = SetThreadLimits(50, 60, 0);
    CCoreQueue::SetArbitrator(pArb);
}

void CAsyncServiceQueue::IncThreadLimit()
{
    InterlockedIncrement(&m_lMaxThreads);
    InterlockedIncrement(&m_lHiPriMaxThreads);
}

void CAsyncServiceQueue::DecThreadLimit()
{
    InterlockedDecrement(&m_lMaxThreads);
    InterlockedDecrement(&m_lHiPriMaxThreads);
}


void CAsyncServiceQueue::InitializeThread()
{
    DEBUGTRACE((LOG_WBEMCORE, "STARTING a main queue thread %d for a total of "
                    "%d\n", GetCurrentThreadId(), m_lNumThreads));
    CWbemQueue::InitializeThread();
}

void CAsyncServiceQueue::UninitializeThread()
{
    DEBUGTRACE((LOG_WBEMCORE, "STOPPING a main queue thread %d for a total of "
                    "%d\n", GetCurrentThreadId(), m_lNumThreads));
    CWbemQueue::UninitializeThread();
}


//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CAsyncReq::CAsyncReq(IWbemObjectSink* pHandler, IWbemContext* pContext,
                        bool bSeparatelyThreaded)
    : CWbemRequest(pContext, bSeparatelyThreaded)
{
    if(pHandler)
    {
        if(m_pContext == NULL)
        {
            // Oop!
            m_pHandler = NULL;
            m_fOk = false;
            return;
        }
        IWbemCausalityAccess* pCA = NULL;
        m_pContext->QueryInterface(IID_IWbemCausalityAccess, (void**)&pCA);
        REQUESTID id;
        pCA->GetRequestId(&id);
        pCA->Release();

        m_pHandler = new CStdSink(pHandler);
        if (m_pHandler)
        {
            m_pHandler->AddRef();
        }
        else
        {
            m_fOk = false;
        }

    }
    else
    {
        m_pHandler = NULL;
    }
}

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CAsyncReq::~CAsyncReq()
{
    if(m_pHandler)
        m_pHandler->Release();
}

void CAsyncReq::TerminateRequest(HRESULT hRes)
{
    if(m_pHandler)
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    return;
}


/*
    * =============================================================================
	|
	| HRESULT CAsyncReq::SetTaskHandle ( _IWmiCoreHandle *phTask )
	| ------------------------------------------------------------
	| 
	| Sets the task handle for the request. This is overrides the virtual 
	| SetTaskHandle declared in CCoreExecReq. We need additional functionality,
	| specifically the ability to set the request sink. In order to do so, we first
	| need a valid request sink which we have at this level.
	|
	|
	* =============================================================================
*/

HRESULT CAsyncReq::SetTaskHandle ( _IWmiCoreHandle *phTask )
{
	HRESULT hRes = WBEM_S_NO_ERROR ;
	
    if (phTask)
    {
        phTask->AddRef();
        m_phTask = phTask;
    }
	
	if ( m_pHandler )
	{
		((CWmiTask*)m_phTask)->SetRequestSink(m_pHandler) ;
	}
	return hRes ;
}


CWbemQueue* CAsyncReq::GetQueue()
{
    return ConfigMgr::GetAsyncSvcQueue();
}
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CNamespaceReq::CNamespaceReq(CWbemNamespace* pNamespace,
                             IWbemObjectSink* pHandler, IWbemContext* pContext,
                             bool bSeparatelyThreaded)
                    : CAsyncReq(pHandler, pContext, bSeparatelyThreaded)
{
    m_pNamespace = pNamespace;
    pNamespace->AddRef();
}

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CNamespaceReq::~CNamespaceReq()
{
    m_pNamespace->Release();
}


//*****************************************************************************
//*****************************************************************************
//*****************************************************************************

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CAsyncReq_OpenNamespace::CAsyncReq_OpenNamespace(CWbemNamespace* pParentNs,
                                                 LPWSTR wszNamespace,
                                                 long lSecurityFlags,
                                                 DWORD dwPermission,
                                                 IWbemContext* pContext,
                                                 CCallResult* pResult, bool bForClient)
              : CAsyncReq(NULL, pContext), m_wsNamespace(wszNamespace),
                m_lSecurityFlags(lSecurityFlags), m_dwPermission(dwPermission), m_pResult(pResult),
                m_pParentNs(pParentNs), m_bForClient(bForClient)
{
    m_pResult->AddRef();
    m_pParentNs->AddRef();
}

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
CAsyncReq_OpenNamespace::~CAsyncReq_OpenNamespace()
{
    m_pResult->Release();
    m_pParentNs->Release();
}

//***************************************************************************
//
//  See svcq.h for documentation.
//
//***************************************************************************
HRESULT CAsyncReq_OpenNamespace::Execute()
{
    SCODE hres;

    BOOL bRepositoryOnly = (m_lSecurityFlags & WBEM_FLAG_CONNECT_REPOSITORY_ONLY);
    m_lSecurityFlags &= ~WBEM_FLAG_CONNECT_REPOSITORY_ONLY;

    CWbemNamespace* pNewNs = CWbemNamespace::CreateInstance();

    if (pNewNs == NULL)
    {
        m_pResult->SetStatus(WBEM_E_OUT_OF_MEMORY, NULL, NULL);
        return WBEM_E_OUT_OF_MEMORY;
    }

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    if (pTask)
    {
//        pTask->printf("TID=%d;", GetCurrentThreadId());
//        pTask->printf("<OpenNamespace=%S>", LPWSTR(m_wsNamespace));
    }

    hres = pNewNs->Initialize(m_wsNamespace,
                        m_pParentNs->GetUserName(),
                        m_lSecurityFlags, m_dwPermission, m_bForClient, bRepositoryOnly,
                        m_pParentNs->GetClientMachine(), m_pParentNs->GetClientProcID(), FALSE, NULL);

    if (FAILED(hres))
    {
        m_pResult->SetStatus(hres, NULL, NULL);
        pNewNs->Release();
        return hres;
    }
    if (hres = pNewNs->GetStatus())
    {
        m_pResult->SetStatus(hres, NULL, NULL);
        pNewNs->Release();
        return hres;
    }

    // check for security if this isnt the local 9x case

    if((m_lSecurityFlags & SecFlagWin9XLocal) == 0)
    {
        DWORD dwAccess = pNewNs->GetUserAccess();
        if((dwAccess  & WBEM_ENABLE) == 0)
        {
            pNewNs->Release();
            m_pResult->SetStatus(WBEM_E_ACCESS_DENIED, NULL, NULL);
            return WBEM_E_ACCESS_DENIED;
        }
        pNewNs->SetPermissions(dwAccess);
    }

    pNewNs->SetLocale(m_pParentNs->GetLocale());
    m_pResult->SetResultServices(pNewNs);
    pNewNs->Release();

    m_pResult->SetStatus(WBEM_S_NO_ERROR, NULL, NULL);
    return WBEM_NO_ERROR;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_DeleteClassAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;

    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<DeleteClass=%S>", LPWSTR(m_wsClass));
    }
    */

    try
    {
        hRes = m_pNamespace->Exec_DeleteClass(m_wsClass, m_lFlags, m_pContext,
                                            m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_ExecQueryAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<Query=%S>", LPWSTR(m_wsQuery));
    }
    */

    //pTask->SetRequestSink(m_pHandler);

    try
    {
        hRes = CQueryEngine::ExecQuery(m_pNamespace, m_wsQueryFormat, m_wsQuery,
                            m_lFlags, m_pContext, m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_PutClassAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        CVARIANT v;
        hRes = m_pClass->Get(L"__CLASS", 0, &v, 0, 0);
        pTask->printf("<PutClass=%S>", v.GetStr());
    }
    */

    try
    {
        hRes = m_pNamespace->Exec_PutClass(m_pClass, m_lFlags, m_pContext,
            m_pHandler
            );
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_DeleteInstanceAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<DeleteInst=%S>", LPWSTR(m_wsPath));
    }
    */

    try
    {
        hRes = m_pNamespace->Exec_DeleteInstance(m_wsPath, m_lFlags, m_pContext,
            m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_PutInstanceAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        CVARIANT v;
        hRes = m_pInstance->Get(L"__PATH", 0, &v, 0, 0);
        pTask->printf("<PutInstance=%S>", v.GetStr());
    }
    */

    try
    {
      hRes= m_pNamespace->Exec_PutInstance(m_pInstance, m_lFlags, m_pContext,
        m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_CreateClassEnumAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<CreateClassEnum: superclass=%S>", LPWSTR(m_wsParent));
    }
    */

    //pTask->SetRequestSink(m_pHandler);

    try
    {
        hRes = m_pNamespace->Exec_CreateClassEnum(m_wsParent, m_lFlags,
            m_pContext, m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_CreateInstanceEnumAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<CreateInstanceEnum=%S>", LPWSTR(m_wsClass));
    }
    */

    //pTask->SetRequestSink(m_pHandler);

    try
    {
        hRes = m_pNamespace->Exec_CreateInstanceEnum(m_wsClass, m_lFlags,
            m_pContext, m_pHandler
            );
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_GetObjectAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<GetObject=%S>", LPWSTR(m_wsObjectPath));
    }
    */

    try
    {
        hRes = m_pNamespace->Exec_GetObject(m_wsObjectPath, m_lFlags,
            m_pContext, m_pHandler);
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_ExecMethodAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<ExecMethod=[%S] %S>", LPWSTR(m_wsMethodName), LPWSTR(m_wsObjectPath));
    }
    */

    try
    {
        hRes = m_pNamespace->Exec_ExecMethod(m_wsObjectPath, m_wsMethodName,
            m_lFlags, m_pInParams, m_pContext, m_pHandler
            );
    }
    catch (...)
    {
        ExceptionCounter c;    
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_ExecNotificationQueryAsync::CAsyncReq_ExecNotificationQueryAsync(
    CWbemNamespace* pNamespace,
    IWbemEventSubsystem_m4* pEss,
    BSTR QueryFormat, BSTR Query, long lFlags,
    IWbemObjectSink *pHandler, IWbemContext* pContext, HRESULT* phRes,
    HANDLE hEssDoneEvent
    ) :
        CNamespaceReq(pNamespace, pHandler, pContext, false),// no threadswitch!
        m_wsQueryFormat(QueryFormat), m_wsQuery(Query), m_lFlags(lFlags),
        m_phRes(phRes), m_pEss(pEss)
{
    if (m_pEss)
        m_pEss->AddRef();

    m_hEssDoneEvent = hEssDoneEvent;
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_ExecNotificationQueryAsync::~CAsyncReq_ExecNotificationQueryAsync()
{
    if (m_pEss)
        m_pEss->Release();
}


//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_ExecNotificationQueryAsync::Execute()
{
    HRESULT hRes;

    CWmiTask *pTask = (CWmiTask *) m_phTask;
    
    if (pTask)
    {
//        pTask->printf("TID=%d;", GetCurrentThreadId());
//        pTask->printf("<ExecNotificationQuery=%S>", LPWSTR(m_wsQuery));
    }
    else
    {
        DEBUGTRACE((LOG_WBEMCORE, "NotificationQuery %S without a Task!!\n", LPWSTR(m_wsQuery)));
        SetEvent(m_hEssDoneEvent);
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
        return hRes;
    }

    //pTask->SetRequestSink(m_pHandler);

    try
    {
        WString sAdjustedNs = "\\\\.\\";
        sAdjustedNs += m_pNamespace->GetName();

        hRes = m_pEss->RegisterNotificationSink(sAdjustedNs, m_wsQueryFormat, m_wsQuery, m_lFlags,
                    m_pContext, m_pHandler);

        *m_phRes = hRes;
    }
    catch(...)
    {
        ExceptionCounter c;
        hRes = WBEM_E_CRITICAL_ERROR;
        m_pHandler->SetStatus( 0, hRes, NULL, NULL);
    }

    SetEvent(m_hEssDoneEvent);

    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_CancelAsyncCall::CAsyncReq_CancelAsyncCall(
                            IWbemObjectSink* pSink, HRESULT* phres)
    : CAsyncReq(NULL, NULL), m_phres(phres), m_pSink(pSink)
{
    if (m_pSink)
        m_pSink->AddRef();
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_CancelAsyncCall::~CAsyncReq_CancelAsyncCall()
{
    if(m_pSink)
        m_pSink->Release();
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_CancelAsyncCall::Execute()
{
    CWmiTask *pTask = (CWmiTask *) m_phTask;
    /*
    if (pTask)
    {
        pTask->printf("TID=%d;", GetCurrentThreadId());
        pTask->printf("<CancelAsyncCall [sink = 0x%X]>", m_pSink);
    }
    */

    HRESULT hres = CWbemNamespace::Exec_CancelAsyncCall(m_pSink);
    if(m_phres)
        *m_phres = hres;
    return hres;
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_CancelProvAsyncCall::CAsyncReq_CancelProvAsyncCall(
                            IWbemServices* pProv, IWbemObjectSink* pSink,
							IWbemObjectSink* pStatusSink )
    : CAsyncReq(NULL, NULL), m_pProv(pProv), m_pSink(pSink), m_pStatusSink( pStatusSink )
{
    if ( NULL != m_pProv )
        m_pProv->AddRef();

    if ( NULL != m_pSink )
        m_pSink->AddRef();

    if ( NULL != m_pStatusSink )
        m_pStatusSink->AddRef();

}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_CancelProvAsyncCall::~CAsyncReq_CancelProvAsyncCall()
{
    if ( NULL != m_pProv )
        m_pProv->Release();

    if ( NULL != m_pSink )
        m_pSink->Release();

    if ( NULL != m_pStatusSink )
        m_pStatusSink->Release();
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_CancelProvAsyncCall::Execute()
{
    HRESULT hres = CWbemNamespace::Exec_CancelProvAsyncCall( m_pProv, m_pSink );

	if ( NULL != m_pStatusSink )
	{
		m_pStatusSink->SetStatus( 0L, hres, NULL, NULL );
	}

    return hres;
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_RemoveNotifySink::CAsyncReq_RemoveNotifySink(
                            IWbemObjectSink* pSink, IWbemObjectSink* pStatusSink)
    : CAsyncReq(NULL, NULL), m_pSink(pSink),m_pStatusSink( pStatusSink )
{
    if (m_pSink)
        m_pSink->AddRef();

	if ( m_pStatusSink )
	{
		m_pStatusSink->AddRef();
	}
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_RemoveNotifySink::~CAsyncReq_RemoveNotifySink()
{
    if(m_pSink)
        m_pSink->Release();

	if ( m_pStatusSink )
	{
		m_pStatusSink->Release();
	}

}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_RemoveNotifySink::Execute()
{
	HRESULT hRes = WBEM_E_FAILED;
    IWbemEventSubsystem_m4* pEss = ConfigMgr::GetEssSink();
    if (pEss)
    {
        if (m_pSink)
            hRes = pEss->RemoveNotificationSink(m_pSink);
        pEss->Release();
    }

	if ( NULL != m_pStatusSink )
	{
		m_pStatusSink->SetStatus( 0L, hRes, NULL, NULL );
	}

    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_OpenNamespace::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_OpenNamespace, Name= %S, in parent namespace %S\n", m_wsNamespace,
        m_pParentNs->GetName()));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_DeleteClassAsync::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_DeleteClassAsync, class=%S in namespace %S using flags 0x%x\n", m_wsClass, m_pNamespace->GetName(), m_lFlags));
};

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_ExecQueryAsync::DumpError()
{
    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_ExecQueryAsync, Query= %S in namespace %S using flags 0x%x\n", m_wsQuery,
        m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_PutClassAsync::DumpError()
{
    CVar var;
    CWbemClass * pCls = (CWbemClass *)m_pClass;
    if(0 == pCls->GetProperty(L"__class", &var))
        DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_PutClassAsync, class=%S in namespace %S using flags 0x%x\n", var.GetLPWSTR(),
        m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_PutInstanceAsync::DumpError()
{
    BSTR mof = 0;
    if(0 == m_pInstance->GetObjectText(0, &mof))
    {
        DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_PutInstanceAsync instance= %S in namespace %S using flags 0x%x\n", mof, m_pNamespace->GetName(), m_lFlags));
        SysFreeString(mof);
    }
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_CreateClassEnumAsync::DumpError()
{
    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_CreateClassEnumAsync, Parent= %S in namespace %S using flags 0x%x\n",
         m_wsParent, m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_CreateInstanceEnumAsync::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_CreateInstanceEnumAsync, Class= %S in namespace %S using flags 0x%x\n",
            m_wsClass, m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_GetObjectAsync::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_GetObjectAsync, Path= %S in namespace %S using flags 0x%x\n", m_wsObjectPath,
        m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_ExecMethodAsync::DumpError()
{
    BSTR bstrArgs = NULL;
    if(m_pInParams)
        m_pInParams->GetObjectText(0, &bstrArgs);

    DEBUGTRACE((LOG_WBEMCORE,
    "CAsyncReq_ExecMethodAsync, Path= %S, Method=%S, args=%S in namespace %S using flags 0x%x\n",
        m_wsObjectPath, m_wsMethodName, (bstrArgs) ? bstrArgs : L"<no args>",
        m_pNamespace->GetName(), m_lFlags));
    if(bstrArgs)
        SysFreeString(bstrArgs);
}

//******************************************************************************
//
//******************************************************************************

void CAsyncReq_ExecNotificationQueryAsync::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_ExecNotificationQueryAsync, Query= %S in namespace %S using flags 0x%x\n", m_wsQuery,
        m_pNamespace->GetName(), m_lFlags));
}

//******************************************************************************
//
//******************************************************************************

void CAsyncReq_DeleteInstanceAsync::DumpError()
{    DEBUGTRACE((LOG_WBEMCORE,
        "CAsyncReq_DeleteInstanceAsync, path=%S in namespace %S using flags 0x%x\n", m_wsPath, m_pNamespace->GetName(), m_lFlags));
};


//******************************************************************************
//
//******************************************************************************
// ok
CAsyncReq_Open::CAsyncReq_Open(
        CWbemNamespace *pNs,
        LPWSTR strScope,
        LPWSTR strParam,
        long lFlags,
        IWbemContext *pCtx,
        IWbemObjectSinkEx *pSink
        )
        :
        CAsyncReq(pSink, pCtx)
{
    m_pNs = pNs;
    m_pNs->AddRef();
    m_pszScope = Macro_CloneLPWSTR(strScope);
    m_pszParam = Macro_CloneLPWSTR(strParam);
    m_lUserFlags = lFlags;
    m_pSink = pSink;
    m_pSink->AddRef();
}

//******************************************************************************
//
//******************************************************************************
// ok
CAsyncReq_Open::~CAsyncReq_Open()
{
    delete [] m_pszScope;
    delete [] m_pszParam;
    ReleaseIfNotNULL(m_pNs);
    ReleaseIfNotNULL(m_pSink);
}

//******************************************************************************
//
//******************************************************************************
// ok
HRESULT CAsyncReq_Open::Execute()
{
    HRESULT hRes;
    hRes = m_pNs->Exec_Open(m_pszScope, m_pszParam, m_lUserFlags,
        m_pContext, m_pSink);
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_Open::DumpError()
{
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Add::CAsyncReq_Add(
        CWbemNamespace *pNs,
        LPWSTR strObjectPath,
        long lFlags,
        IWbemContext *pCtx,
        IWbemObjectSink *pSink
        )
        :
        CAsyncReq(pSink, pCtx)
{
    m_pszObjectPath = Macro_CloneLPWSTR(strObjectPath);
    m_lUserFlags = lFlags;
    m_pNs = pNs;
    m_pNs->AddRef();
    m_pSink = pSink;
    m_pSink->AddRef();
}


//******************************************************************************
//
//******************************************************************************
//

CAsyncReq_Add::~CAsyncReq_Add()
{
    delete m_pszObjectPath;
    ReleaseIfNotNULL(m_pNs);
    ReleaseIfNotNULL(m_pSink);
}

//******************************************************************************
//
//******************************************************************************
//

HRESULT CAsyncReq_Add::Execute()
{
    HRESULT hRes;
    hRes = m_pNs->Exec_Add(m_pszObjectPath, m_lUserFlags, m_pContext, m_pSink);
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//

void CAsyncReq_Add::DumpError()
{
    // nothing
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Remove::CAsyncReq_Remove(
        CWbemNamespace *pNs,
        LPWSTR strObjectPath,
        long lFlags,
        IWbemContext *pCtx,
        IWbemObjectSink *pSink
        )
        : CAsyncReq(pSink, pCtx)

{
    m_pszObjectPath = Macro_CloneLPWSTR(strObjectPath);
    m_lUserFlags = lFlags;
    m_pNs = pNs;
    m_pNs->AddRef();
    m_pSink = pSink;
    m_pSink->AddRef();
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Remove::~CAsyncReq_Remove()
{
    delete m_pszObjectPath;
    ReleaseIfNotNULL(m_pNs);
    ReleaseIfNotNULL(m_pSink);
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_Remove::Execute()
{
    HRESULT hRes;
    hRes = m_pNs->Exec_Add(m_pszObjectPath, m_lUserFlags, m_pContext, m_pSink);
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_Remove::DumpError()
{
    // nothing
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Refresh::CAsyncReq_Refresh(
        CWbemNamespace *pNs,
        IWbemClassObject **pTarget,
        long lFlags,
        IWbemContext *pCtx,
        IWbemObjectSinkEx *pSink
        )
        : CAsyncReq(pSink, pCtx)

{
    m_pNs = pNs;
    m_pNs->AddRef();
    m_pTarget = 0;
    if (pTarget)
    {
        m_pTarget = *pTarget;
        m_pTarget->AddRef();
    }
    m_lUserFlags = lFlags;
    m_pSink = pSink;
    m_pSink->AddRef();
}


//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Refresh::~CAsyncReq_Refresh()
{
    ReleaseIfNotNULL(m_pNs);
    ReleaseIfNotNULL(m_pTarget);
    ReleaseIfNotNULL(m_pSink);
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_Refresh::Execute()
{
    HRESULT hRes;
    hRes = m_pNs->Exec_Refresh(m_pTarget, m_lUserFlags, m_pContext, m_pSink);
    return hRes;
}


//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_Refresh::DumpError()
{
    // none
}


//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Rename::CAsyncReq_Rename(
        CWbemNamespace *pNs,
        LPWSTR strOldObjectPath,
        LPWSTR strNewObjectPath,
        long lFlags,
        IWbemContext *pCtx,
        IWbemObjectSink *pSink
        )
        : CAsyncReq(pSink, pCtx)

{
    m_pszOldObjectPath = Macro_CloneLPWSTR(strOldObjectPath);
    m_pszNewObjectPath = Macro_CloneLPWSTR(strNewObjectPath);
    m_lUserFlags = lFlags;
    m_pNs = pNs;
    m_pNs->AddRef();
    m_pSink = pSink;
    m_pSink->AddRef();
}

//******************************************************************************
//
//******************************************************************************
//
CAsyncReq_Rename::~CAsyncReq_Rename()
{
    delete m_pszOldObjectPath;
    delete m_pszNewObjectPath;
    ReleaseIfNotNULL(m_pNs);
    ReleaseIfNotNULL(m_pSink);
}

//******************************************************************************
//
//******************************************************************************
//
HRESULT CAsyncReq_Rename::Execute()
{
    HRESULT hRes;
    hRes = m_pNs->Exec_Rename(m_pszOldObjectPath, m_pszNewObjectPath,
        m_lUserFlags, m_pContext, m_pSink);
    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_Rename::DumpError()
{
    // none
}

//******************************************************************************
//
//******************************************************************************
//

HRESULT CAsyncReq_DynAux_GetInstances :: Execute ()
{
    HRESULT hRes = m_pNamespace->Exec_DynAux_GetInstances (

        m_pClassDef ,
        m_lFlags ,
        m_pContext ,
        m_pSink
    ) ;

    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_DynAux_GetInstances ::DumpError()
{
    // none
}

//******************************************************************************
//
//******************************************************************************
//

HRESULT CAsyncReq_DynAux_ExecQueryAsync :: Execute ()
{
    HRESULT hRes = m_pNamespace->Exec_DynAux_ExecQueryAsync (

        m_pClassDef ,
        m_Query,
        m_QueryFormat,
        m_lFlags ,
        m_pContext ,
        m_pSink
    ) ;

    return hRes;
}

//******************************************************************************
//
//******************************************************************************
//
void CAsyncReq_DynAux_ExecQueryAsync ::DumpError()
{
    // none
}