dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/winmgmt/coredll/sinks.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

2204 lines
63 KiB
C++
Raw Permalink Blame History

//***************************************************************************
//
// (c) 1997-2001 by Microsoft Corporation
//
// SINKS.CPP
//
// raymcc 3-Mar-99 Updated for separately threaded proxies
//
//***************************************************************************
#include "precomp.h"
#include <stdio.h>
#include <wbemcore.h>
#include <thrpool.h>
#include <evtlog.h>
#include <oahelp.inl>
#include <genutils.h>
#include <stdarg.h>
#include <autoptr.h>
#define LOWER_AUTH_LEVEL_NOTSET 0xFFFFFFFF
HRESULT LowerAuthLevel( IWbemObjectSink * psink, DWORD* pdwLastAuthnLevel );
static HRESULT ZapWriteOnlyProps(IWbemClassObject *pObj);
extern LONG g_nSinkCount;
extern LONG g_nStdSinkCount;
extern LONG g_nSynchronousSinkCount;
extern LONG g_nProviderSinkCount;
int _Trace(char *pFile, const char *fmt, ...);
//***************************************************************************
//
//***************************************************************************
CBasicObjectSink::CBasicObjectSink()
{
InterlockedIncrement(&g_nSinkCount);
}
CBasicObjectSink::~CBasicObjectSink()
{
InterlockedDecrement(&g_nSinkCount);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CBasicObjectSink::QueryInterface(REFIID riid, LPVOID* ppvObj)
{
if(riid == CLSID_WbemLocator)
{
// internal test
*ppvObj = NULL;
return S_OK;
}
if(riid == IID_IUnknown || riid == IID_IWbemObjectSink)
{
*ppvObj = (IWbemObjectSink*)this;
AddRef();
return S_OK;
}
else return E_NOINTERFACE;
}
//***************************************************************************
//
//***************************************************************************
ULONG STDMETHODCALLTYPE CObjectSink::AddRef()
{
return InterlockedIncrement(&m_lRef);
}
//***************************************************************************
//
//***************************************************************************
ULONG STDMETHODCALLTYPE CObjectSink::Release()
{
long lRef = InterlockedDecrement(&m_lRef);
if(lRef == 0)
delete this;
return lRef;
}
//***************************************************************************
//
//***************************************************************************
CSynchronousSink::CSynchronousSink(IWbemObjectSink* pProxy) :
m_hEvent(CreateEvent(NULL, FALSE, FALSE, NULL)),
m_str(NULL), m_pErrorObj(NULL), m_hres(WBEM_E_CRITICAL_ERROR)
{
if(pProxy)
{
m_pCurrentProxy = pProxy;
pProxy->AddRef();
}
else
m_pCurrentProxy = NULL;
InterlockedIncrement(&g_nSynchronousSinkCount);
};
//***************************************************************************
//
//***************************************************************************
CSynchronousSink::~CSynchronousSink()
{
if(m_pCurrentProxy)
m_pCurrentProxy->Release();
CloseHandle(m_hEvent);
SysFreeString(m_str);
if(m_pErrorObj)
m_pErrorObj->Release();
InterlockedDecrement(&g_nSynchronousSinkCount);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CSynchronousSink::Indicate(long lNumObjects,
IWbemClassObject** apObj)
{
CInCritSec ics(&m_cs);
for(long i = 0; i < lNumObjects; i++)
{
m_apObjects.Add(apObj[i]);
}
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CSynchronousSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags == WBEM_STATUS_PROGRESS)
{
if(m_pCurrentProxy)
return m_pCurrentProxy->SetStatus(lFlags, lParam, strParam, pObjParam);
else
return S_OK;
}
if(lFlags != 0) return WBEM_S_NO_ERROR;
CInCritSec ics(&m_cs);
m_hres = lParam;
m_str = SysAllocString(strParam);
if (m_pErrorObj)
m_pErrorObj->Release();
m_pErrorObj = pObjParam;
if(m_pErrorObj)
m_pErrorObj->AddRef();
SetEvent(m_hEvent);
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
void CSynchronousSink::Block()
{
if(m_hres != WBEM_E_CRITICAL_ERROR)
return;
CCoreQueue::QueueWaitForSingleObject(m_hEvent, INFINITE);
}
//***************************************************************************
//
//***************************************************************************
void CSynchronousSink::GetStatus(HRESULT* phres, BSTR* pstrParam,
IWbemClassObject** ppErrorObj)
{
CInCritSec ics(&m_cs);
if(phres)
*phres = m_hres;
if(pstrParam)
*pstrParam = SysAllocString(m_str);
if(ppErrorObj)
{
*ppErrorObj = m_pErrorObj;
if(m_pErrorObj)
m_pErrorObj->AddRef();
}
}
HRESULT LowerAuthLevel(IWbemObjectSink * psink, DWORD* pdwLastAuthnLevel )
{
IClientSecurity * pFromSec = NULL;
SCODE sc = psink->QueryInterface(IID_IClientSecurity, (void **) &pFromSec);
if(sc == S_OK)
{
OLECHAR * pPrincipal = NULL;
DWORD dwAuthnSvc, dwAuthzSvc, dwAuthnLevel, dwImpLevel, dwCapabilities;
sc = pFromSec->QueryBlanket(psink, &dwAuthnSvc, &dwAuthzSvc,
&pPrincipal,
&dwAuthnLevel, &dwImpLevel,
NULL, &dwCapabilities);
// If we have never retrieved the authentication level before, then we
// should record what it currently is
if ( LOWER_AUTH_LEVEL_NOTSET == *pdwLastAuthnLevel )
{
*pdwLastAuthnLevel = dwAuthnLevel;
}
if (FAILED(sc))
return sc;
if(*pdwLastAuthnLevel == RPC_C_AUTHN_LEVEL_NONE)
return WBEM_E_FAILED;
if(*pdwLastAuthnLevel == RPC_C_AUTHN_LEVEL_DEFAULT)
*pdwLastAuthnLevel = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
else
(*pdwLastAuthnLevel)--; // normal case is to try one lower
sc = pFromSec->SetBlanket(psink, dwAuthnSvc, dwAuthzSvc,
pPrincipal,
*pdwLastAuthnLevel, dwImpLevel,
NULL, dwCapabilities);
if(pPrincipal)
CoTaskMemFree(pPrincipal);
pFromSec->Release();
}
return sc;
}
//***************************************************************************
//
//***************************************************************************
CForwardingSink::CForwardingSink(CBasicObjectSink* pDest, long lRef)
: CObjectSink(lRef),
m_pDestIndicate(pDest->GetIndicateSink()),
m_pDestStatus(pDest->GetStatusSink()),
m_pDest(pDest)
{
m_pDestIndicate->AddRef();
m_pDestStatus->AddRef();
m_pDest->AddRef();
}
//***************************************************************************
//
//***************************************************************************
CForwardingSink::~CForwardingSink()
{
if(m_pDestIndicate)
m_pDestIndicate->Release();
if(m_pDestStatus)
m_pDestStatus->Release();
if(m_pDest)
m_pDest->Release();
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CForwardingSink::Indicate(long lObjectCount,
IWbemClassObject** pObjArray)
{
return m_pDestIndicate->Indicate(lObjectCount, pObjArray);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CForwardingSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
return m_pDestStatus->SetStatus(lFlags, lParam, strParam, pObjParam);
}
//***************************************************************************
//
//***************************************************************************
CCombiningSink::CCombiningSink(CBasicObjectSink* pDest, HRESULT hresToIgnore)
: CForwardingSink(pDest, 0), m_hresToIgnore(hresToIgnore),
m_hres(WBEM_S_NO_ERROR), m_pErrorObj(NULL), m_strParam(NULL)
{
}
//***************************************************************************
//
//***************************************************************************
CCombiningSink::~CCombiningSink()
{
// Time to call SetStatus on the destination
// =========================================
m_pDestStatus->SetStatus(0, m_hres,
(SUCCEEDED(m_hres)?m_strParam:NULL),
(SUCCEEDED(m_hres)?NULL:m_pErrorObj)
);
if(m_pErrorObj)
m_pErrorObj->Release();
SysFreeString(m_strParam);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CCombiningSink::SetStatus(long lFlags, long lParam, BSTR strParam,
IWbemClassObject* pObjParam)
{
if(lFlags != 0)
return m_pDestStatus->SetStatus(lFlags, lParam, strParam, pObjParam);
// An error occurred. For now, only store one
// ==========================================
if(strParam)
{
SysFreeString(m_strParam);
m_strParam = SysAllocString(strParam);
}
CInCritSec ics(&m_cs);
if(SUCCEEDED(m_hres) || (m_pErrorObj == NULL && pObjParam != NULL))
{
// This error needs to be recorded
// ===============================
if(FAILED(lParam))
{
// Record the error code, unless it is to be ignored
// =================================================
if(lParam != m_hresToIgnore)
{
m_hres = lParam;
}
// Record the error object anyway
// ==============================
if(m_pErrorObj)
m_pErrorObj->Release();
m_pErrorObj = pObjParam;
if(m_pErrorObj)
m_pErrorObj->AddRef();
}
else
{
if(lParam != m_hresToIgnore)
{
m_hres = lParam;
}
}
}
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
CAnySuccessSink::~CAnySuccessSink()
{
// If no real success occurred, report a failure
// =============================================
if(!m_bSuccess && SUCCEEDED(m_hres))
{
// We must report a failure since there were no successes, but there
// were no real failures either, so we must create an error code.
// =================================================================
if(m_hresIgnored == 0)
m_hres = m_hresNotError1;
else
m_hres = m_hresIgnored;
}
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CAnySuccessSink::SetStatus(long lFlags, long lParam, BSTR strParam,
IWbemClassObject* pObjParam)
{
if(lFlags == 0)
{
if(SUCCEEDED(lParam))
m_bSuccess = TRUE;
else if(lParam == m_hresNotError1 && m_hresIgnored == 0)
{
m_hresIgnored = m_hresNotError1;
lParam = WBEM_S_NO_ERROR;
}
else if(lParam == m_hresNotError2)
{
m_hresIgnored = m_hresNotError2;
lParam = WBEM_S_NO_ERROR;
}
}
return CCombiningSink::SetStatus(lFlags, lParam, strParam, pObjParam);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP COperationErrorSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags == 0 && FAILED(lParam))
{
HRESULT hres = WBEM_S_NO_ERROR;
IWbemClassObject* pErrorObj = NULL;
bool bErr = false;
try
{
CErrorObject Error(pObjParam);
Error.SetOperation(m_wsOperation);
Error.SetParamInformation(m_wsParameter);
Error.SetProviderName(m_wsProviderName);
pErrorObj = Error.GetObject();
}
// If an exception occurs, send the error to the client and
// return an error from the call.
catch ( CX_MemoryException )
{
lParam = WBEM_E_OUT_OF_MEMORY;
bErr = true;
}
catch(...)
{
ExceptionCounter c;
lParam = WBEM_E_CRITICAL_ERROR;
bErr = true;
}
hres = m_pDestStatus->SetStatus(lFlags, lParam, strParam, pErrorObj);
if ( NULL != pErrorObj )
{
pErrorObj->Release();
}
if ( bErr )
{
hres = lParam;
}
return hres;
}
else if(m_bFinal &&
lFlags != WBEM_STATUS_COMPLETE && lFlags != WBEM_STATUS_PROGRESS)
{
DEBUGTRACE((LOG_WBEMCORE, "Ignoring internal SetStatus call to the "
"client: 0x%X 0x%X %S\n", lFlags, lParam, strParam));
return WBEM_S_FALSE;
}
else if(lFlags == 0 && strParam &&
!m_wsOperation.EqualNoCase(L"PutInstance"))
{
ERRORTRACE((LOG_WBEMCORE, "Provider used strParam in SetStatus "
"outside of PutInstance! Actual operation was <%S>, string was <%S>. Ignoring\n", (const wchar_t*)m_wsOperation, strParam));
return m_pDestStatus->SetStatus(lFlags, lParam, NULL, pObjParam);
}
else
{
return m_pDestStatus->SetStatus(lFlags, lParam, strParam, pObjParam);
}
}
//***************************************************************************
//
//***************************************************************************
void COperationErrorSink::SetProviderName(LPCWSTR wszName)
{
m_wsProviderName = wszName;
}
//***************************************************************************
//
//***************************************************************************
void COperationErrorSink::SetParameterInfo(LPCWSTR wszParam)
{
m_wsParameter = wszParam;
}
//***************************************************************************
//
//***************************************************************************
CDecoratingSink::CDecoratingSink(CBasicObjectSink* pDest,
CWbemNamespace* pNamespace)
: CForwardingSink(pDest, 0), m_pNamespace(pNamespace)
{
m_pNamespace->AddRef();
}
//***************************************************************************
//
//***************************************************************************
CDecoratingSink::~CDecoratingSink()
{
m_pNamespace->Release();
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CDecoratingSink::Indicate(long lNumObjects,
IWbemClassObject** apObjects)
{
// Clone the indicated objects before decorating
HRESULT hres = WBEM_S_NO_ERROR;
if ( lNumObjects > 0 )
{
// We will optimize for indicates of a single object (which will probably
// be the most likely type of indicate. In which case we won't allocate any
// memory for the cloned object array, and rather will just use a stack variable.
IWbemClassObject* pClonedObject = NULL;
IWbemClassObject** apClonedObjects = &pClonedObject;
if ( lNumObjects > 1 )
{
try
{
// Allocate an array and zero it out
apClonedObjects = new IWbemClassObject*[lNumObjects];
if ( NULL != apClonedObjects )
{
ZeroMemory( apClonedObjects, lNumObjects * sizeof(IWbemClassObject*) );
}
else
{
hres = WBEM_E_OUT_OF_MEMORY;
}
}
catch( CX_MemoryException )
{
hres = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
ExceptionCounter c;
hres = WBEM_E_FAILED;
}
}
if ( SUCCEEDED( hres ) )
{
// Clone the objects into the array (error out if this fails)
for ( long lCtr = 0; SUCCEEDED( hres ) && lCtr < lNumObjects; lCtr++ )
{
if ( NULL != apObjects[lCtr] )
{
hres = apObjects[lCtr]->Clone( &apClonedObjects[lCtr] );
}
else
{
apClonedObjects[lCtr] = NULL;
}
}
// Now decorate the cloned objects and indicate them
if ( SUCCEEDED( hres ) )
{
for(int i = 0; i < lNumObjects; i++)
{
m_pNamespace->DecorateObject(apClonedObjects[i]);
}
hres = m_pDestIndicate->Indicate(lNumObjects, apClonedObjects);
}
// Clean up the array
for ( lCtr = 0; lCtr < lNumObjects; lCtr++ )
{
// Check for NULLs
if ( NULL != apClonedObjects[lCtr] )
{
apClonedObjects[lCtr]->Release();
}
}
// If we actually allocated memory, we need to clean it up here
if ( apClonedObjects != &pClonedObject )
{
delete [] apClonedObjects;
}
} // IF we allocated our block appropriately
}
else
{
hres = m_pDestIndicate->Indicate(lNumObjects, apObjects);
}
return hres;
}
//***************************************************************************
//
//***************************************************************************
CSingleMergingSink::~CSingleMergingSink()
{
if(SUCCEEDED(m_hres))
{
if(m_pResult == NULL)
{
// Nobody succeeded, but nobody failed either. Not found
// =====================================================
m_hres = WBEM_E_NOT_FOUND;
}
else if(m_pResult->InheritsFrom(m_wsTargetClass) == S_OK)
{
m_pDestIndicate->Indicate(1, &m_pResult);
}
else
{
// Found somewhere, but not in this class
// ======================================
m_hres = WBEM_E_NOT_FOUND;
}
}
if(m_pResult)
m_pResult->Release();
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CSingleMergingSink::Indicate(long lNumObjects,
IWbemClassObject** apObjects)
{
CInCritSec ics(&m_cs);
if(lNumObjects != 1)
{
ERRORTRACE((LOG_WBEMCORE, "Provider gave %d objects for GetObject!\n",
lNumObjects));
return WBEM_S_NO_ERROR;
}
if(m_pResult == NULL)
{
apObjects[0]->Clone(&m_pResult);
return WBEM_S_NO_ERROR;
}
CVar vName;
((CWbemInstance*)m_pResult)->GetClassName(&vName);
if(apObjects[0]->InheritsFrom(vName.GetLPWSTR()) == S_OK)
{
IWbemClassObject* pClone;
apObjects[0]->Clone(&pClone);
HRESULT hres = CWbemInstance::AsymmetricMerge((CWbemInstance*)m_pResult,
(CWbemInstance*)pClone);
if(FAILED(hres))
{
ERRORTRACE((LOG_WBEMCORE, "Failed to merge instances!!\n"));
pClone->Release();
}
else
{
m_pResult->Release();
m_pResult = pClone; // already AddRefed
}
}
else
{
HRESULT hres = CWbemInstance::AsymmetricMerge(
(CWbemInstance*)apObjects[0], (CWbemInstance*)m_pResult);
if(FAILED(hres))
{
ERRORTRACE((LOG_WBEMCORE, "Failed to merge instances!!\n"));
}
}
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
CLocaleMergingSink::CLocaleMergingSink(CBasicObjectSink *pDest, LPCWSTR wszLocale, LPCWSTR pNamespace)
: CCombiningSink(pDest, WBEM_S_NO_ERROR),
m_wsLocale(wszLocale),
m_pPrimaryNs(NULL),
m_pPrimarySession(NULL),
m_pPrimaryDriver(NULL),
m_pDefaultNs(NULL),
m_pDefaultSession(NULL),
m_pDefaultDriver(NULL)
{
GetDbPtr(pNamespace);
}
CLocaleMergingSink::~CLocaleMergingSink()
{
releaseNS();
}
//***************************************************************************
//
//***************************************************************************
HRESULT CLocaleMergingSink::LocalizeQualifiers(bool bInstance, bool bParentLocalized,
IWbemQualifierSet *pBase, IWbemQualifierSet *pLocalized, bool &bChg)
{
HRESULT hrInner;
HRESULT hr = WBEM_S_NO_ERROR;
pLocalized->BeginEnumeration(0);
BSTR strName = NULL;
VARIANT vVal;
VariantInit(&vVal);
long lFlavor;
while(pLocalized->Next(0, &strName, &vVal, &lFlavor) == S_OK)
{
// Ignore if this is an instance.
if (bInstance && !(lFlavor & WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE))
{
VariantClear(&vVal);
SysFreeString(strName);
continue;
}
if (!_wcsicmp(strName, L"amendment") ||
!_wcsicmp(strName, L"key") ||
!_wcsicmp(strName, L"singleton") ||
!_wcsicmp(strName, L"dynamic") ||
!_wcsicmp(strName, L"indexed") ||
!_wcsicmp(strName, L"cimtype") ||
!_wcsicmp(strName, L"static") ||
!_wcsicmp(strName, L"implemented") ||
!_wcsicmp(strName, L"abstract"))
{
VariantClear(&vVal);
SysFreeString(strName);
continue;
}
// If this is not a propagated qualifier,
// ignore it. (Bug #45799)
// =====================================
if (bParentLocalized &&
!(lFlavor & WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS))
{
VariantClear(&vVal);
SysFreeString(strName);
continue;
}
// Now, we need to test for this in the other
// class.
// The only localized qualifiers that do not override the
// default are where only parent qualifiers exist, but the
// child has overriden its own parent.
// =======================================================
VARIANT vBasicVal;
VariantInit(&vBasicVal);
long lBasicFlavor;
hrInner = pBase->Get(strName, 0, &vBasicVal, &lBasicFlavor);
if (hrInner != WBEM_E_NOT_FOUND)
{
if (bParentLocalized && // If there is no localized copy of this class
(lBasicFlavor & WBEM_FLAVOR_OVERRIDABLE) && // .. and this is an overridable qualifier
(lBasicFlavor & WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS) && // and this is propogated
(lBasicFlavor & WBEM_FLAVOR_ORIGIN_LOCAL)) // .. and this was actualy overridden
{
VariantClear(&vVal); // .. DON'T DO IT.
VariantClear(&vBasicVal);
SysFreeString(strName);
continue;
}
if (bParentLocalized &&
!(lBasicFlavor & WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS))
{
VariantClear(&vVal);
VariantClear(&vBasicVal);
SysFreeString(strName);
continue;
}
}
pBase->Put(strName, &vVal, (lFlavor&~WBEM_FLAVOR_ORIGIN_PROPAGATED) | WBEM_FLAVOR_AMENDED);
bChg = true;
VariantClear(&vVal);
VariantClear(&vBasicVal);
SysFreeString(strName);
}
return hr;
}
//***************************************************************************
//
//***************************************************************************
HRESULT CLocaleMergingSink::LocalizeProperties(bool bInstance, bool bParentLocalized, IWbemClassObject *pOriginal,
IWbemClassObject *pLocalized, bool &bChg)
{
HRESULT hr = WBEM_S_NO_ERROR;
pLocalized->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
BSTR strPropName;
LONG lLong;
CIMTYPE ct;
VARIANT vNewVal;
while(pLocalized->Next(0, &strPropName, &vNewVal, &ct, &lLong) == S_OK)
{
IWbemQualifierSet *pLocalizedQs = NULL, *pThisQs = NULL;
VARIANT vBasicVal;
VariantInit(&vBasicVal);
if (FAILED(pLocalized->GetPropertyQualifierSet(strPropName,&pLocalizedQs)))
{
SysFreeString(strPropName);
VariantClear(&vNewVal);
continue;
}
CReleaseMe rm1(pLocalizedQs);
if (FAILED(pOriginal->GetPropertyQualifierSet(strPropName, &pThisQs)))
{
SysFreeString(strPropName);
VariantClear(&vNewVal);
continue;
}
CReleaseMe rm2(pThisQs);
hr = LocalizeQualifiers(bInstance, bParentLocalized, pThisQs, pLocalizedQs, bChg);
if (FAILED(hr))
{
SysFreeString(strPropName);
VariantClear(&vNewVal);
continue;
}
SysFreeString(strPropName);
VariantClear(&vNewVal);
}
pLocalized->EndEnumeration();
return hr;
}
//***************************************************************************
//
//***************************************************************************
// This function sets up the pointer to the localized namespace.
void CLocaleMergingSink::GetDbPtr(const wchar_t * name_space)
{
if (m_pThisNamespace.EqualNoCase(name_space))
return;
releaseNS();
m_pThisNamespace = name_space;
if (wcslen(name_space) == 0)
return;
WString sNsName;
sNsName = m_pThisNamespace;
sNsName += L"\\";
sNsName += m_wsLocale;
IWmiDbSession *pTempSession = NULL;
HRESULT hRes = CRepository::GetDefaultSession(&pTempSession);
if (FAILED(hRes))
return;
hRes = CRepository::OpenScope(pTempSession, sNsName, 0, &m_pPrimaryDriver, &m_pPrimarySession, 0, &m_pPrimaryNs);
if (_wcsicmp(m_wsLocale, L"ms_409"))
{
sNsName = m_pThisNamespace;
sNsName += L"\\ms_409";
hRes = CRepository::OpenScope(pTempSession, sNsName, 0, &m_pDefaultDriver, &m_pDefaultSession, 0, &m_pDefaultNs);
}
pTempSession->Release();
}
void CLocaleMergingSink::releaseNS(void)
{
ReleaseIfNotNULL(m_pPrimarySession);
ReleaseIfNotNULL(m_pDefaultSession);
ReleaseIfNotNULL(m_pPrimaryNs);
ReleaseIfNotNULL(m_pPrimaryDriver);
ReleaseIfNotNULL(m_pDefaultNs);
ReleaseIfNotNULL(m_pDefaultDriver);
m_pPrimarySession = 0;
m_pDefaultSession = 0;
m_pPrimaryNs = 0;
m_pPrimaryDriver = 0;
m_pDefaultNs = 0;
m_pDefaultDriver = 0;
};
bool CLocaleMergingSink::hasLocale(const wchar_t * name_space)
{
GetDbPtr(name_space) ;
return (m_pPrimaryNs || m_pDefaultNs);
};
//***************************************************************************
//
//***************************************************************************
// Do the work.
STDMETHODIMP CLocaleMergingSink::Indicate(long lNumObjects,
IWbemClassObject** apObjects)
{
CInCritSec ics(&m_cs);
IWbemQualifierSet *pLocalizedQs = NULL, *pThisQs = NULL;
bool bParentLocalized = false;
bool bInstance = false;
HRESULT hr = WBEM_S_NO_ERROR;
HRESULT hRes;
for (int i = 0; i < lNumObjects; i++)
{
CWbemObject *pResult = (CWbemObject *)apObjects[i];
CVar vServer;
if (FAILED(pResult->GetProperty(L"__SERVER", &vServer)) || vServer.IsNull())
continue;
if (_wcsicmp(LPWSTR(vServer), ConfigMgr::GetMachineName())!=0)
continue;
VARIANT name_space;
VariantInit(&name_space);
CClearMe cm(&name_space);
HRESULT hres = pResult->Get(L"__NAMESPACE", 0, &name_space, NULL, NULL);
if (FAILED(hres) || hasLocale (V_BSTR(&name_space)) == false)
continue;
if (pResult->IsInstance())
bInstance = true;
CVar vName, vDeriv;
if (FAILED(pResult->GetClassName(&vName)))
continue;
WString wKey;
int nRes = 0;
bool bChg = false;
// Does this instance exist in the localized namespace?
// Does this class exist in the localized namespace?
// If not, loop through all the parents until we
// run out or we have a hit.
// =================================================
CWbemObject *pClassDef = NULL;
if (wcslen(vName.GetLPWSTR()) > 0)
{
WString sName = vName.GetLPWSTR();
hRes = WBEM_E_NOT_FOUND;
if (m_pPrimaryNs)
hRes = CRepository::GetObject(m_pPrimarySession, m_pPrimaryNs, sName, 0, (IWbemClassObject **) &pClassDef);
if (FAILED(hRes) && m_pDefaultNs)
hRes = CRepository::GetObject(m_pDefaultSession, m_pDefaultNs, sName, 0, (IWbemClassObject **) &pClassDef);
if (hRes == WBEM_E_NOT_FOUND)
{
bParentLocalized = TRUE;
pResult->GetDerivation(&vDeriv);
CVarVector *pvTemp = vDeriv.GetVarVector();
for (int j = 0; j < pvTemp->Size(); j++)
{
CVar vParentName = pvTemp->GetAt(j);
WString sParentName = vParentName.GetLPWSTR();
hRes = WBEM_E_NOT_FOUND;
if (m_pPrimaryNs)
hRes = CRepository::GetObject(m_pPrimarySession, m_pPrimaryNs, sParentName, 0, (IWbemClassObject **) &pClassDef);
if (FAILED(hRes) && m_pDefaultNs)
hRes = CRepository::GetObject(m_pDefaultSession, m_pDefaultNs, sParentName, 0, (IWbemClassObject **) &pClassDef);
}
}
}
if (pClassDef == NULL)
{
nRes = WBEM_S_NO_ERROR;
continue;
}
CReleaseMe rm11((IWbemClassObject*)pClassDef);
// At this point, we have the localized copy, and are
// ready to combine qualifiers. Start with class qualifiers.
// ============================================================
if (FAILED(pClassDef->GetQualifierSet(&pLocalizedQs)))
continue;
if (FAILED(pResult->GetQualifierSet(&pThisQs)))
{
pLocalizedQs->Release();
continue;
}
hr = LocalizeQualifiers(bInstance, bParentLocalized, pThisQs, pLocalizedQs, bChg);
pLocalizedQs->EndEnumeration();
pLocalizedQs->Release();
pThisQs->Release();
if (FAILED(hr))
break;
hr = LocalizeProperties(bInstance, bParentLocalized, pResult, pClassDef, bChg);
// Methods.
// Putting a method cancels enumeration, so we have to enumerate first.
IWbemClassObject *pLIn = NULL, *pLOut = NULL;
IWbemClassObject *pOIn = NULL, *pOOut = NULL;
BSTR bstrMethodName = NULL ;
int iPos = 0;
pClassDef->BeginMethodEnumeration(0);
while ( pClassDef->NextMethod(0, &bstrMethodName, 0, 0) == S_OK )
{
pLIn = NULL;
pOIn = NULL;
pLOut = NULL;
pOOut = NULL;
pClassDef->GetMethod(bstrMethodName, 0, &pLIn, &pLOut);
hr = pResult->GetMethod(bstrMethodName, 0, &pOIn, &pOOut);
CSysFreeMe fm(bstrMethodName);
CReleaseMe rm0(pLIn);
CReleaseMe rm1(pOIn);
CReleaseMe rm2(pLOut);
CReleaseMe rm3(pOOut);
// METHOD IN PARAMETERS
if (pLIn)
if (pOIn)
hr = LocalizeProperties(bInstance, bParentLocalized, pOIn, pLIn, bChg);
if (pLOut)
if (pOOut)
hr = LocalizeProperties(bInstance, bParentLocalized, pOOut, pLOut, bChg);
// METHOD QUALIFIERS
hr = pResult->GetMethodQualifierSet(bstrMethodName, &pThisQs);
if (FAILED(hr))
{
continue;
}
hr = pClassDef->GetMethodQualifierSet(bstrMethodName, &pLocalizedQs);
if (FAILED(hr))
{
pThisQs->Release();
continue;
}
hr = LocalizeQualifiers(bInstance, bParentLocalized, pThisQs, pLocalizedQs, bChg);
pResult->PutMethod(bstrMethodName, 0, pOIn, pOOut);
pThisQs->Release();
pLocalizedQs->Release();
}
pClassDef->EndMethodEnumeration();
if (bChg)
pResult->SetLocalized(true);
}
for(int i = 0; i < lNumObjects; i++)
{
CWbemObject *pResult = (CWbemObject *)apObjects[i];
if (FAILED(pResult->ValidateObject(WMIOBJECT_VALIDATEOBJECT_FLAG_FORCE)))
DebugBreak();
}
m_pDestIndicate->Indicate(lNumObjects, apObjects);
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CCountedSink::Indicate(long lNumObjects,
IWbemClassObject** apObjects)
{
if(lNumObjects != 1)
return WBEM_E_UNEXPECTED;
DWORD dwNewSent = (DWORD)InterlockedIncrement((LONG*)&m_dwSent);
if(dwNewSent > m_dwMax)
return WBEM_E_UNEXPECTED;
m_pDestIndicate->Indicate(1, apObjects);
if(dwNewSent == m_dwMax)
{
m_pDestStatus->SetStatus(0, WBEM_S_NO_ERROR, NULL, NULL);
return WBEM_S_FALSE;
}
else return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CCountedSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
// If SetStatus is 0, indicating that the enum is finished, but we
// didn't send back the requested number of objects, we should
// SetStatus to WBEM_S_FALSE.
if ( WBEM_S_NO_ERROR == lParam )
{
if ( m_dwSent != m_dwMax )
{
lParam = WBEM_S_FALSE;
}
}
return m_pDestStatus->SetStatus( lFlags, lParam, strParam, pObjParam );
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CFilteringSink::Indicate(long lObjectCount,
IWbemClassObject** apObjects)
{
try
{
// Allocate new array
// ==================
IWbemClassObject** apNewArray = new IWbemClassObject*[lObjectCount];
wmilib::auto_buffer<IWbemClassObject*> rm_(apNewArray);
if (!apNewArray)
return WBEM_E_OUT_OF_MEMORY;
long lNewIndex = 0;
for(int i = 0; i < lObjectCount; i++)
{
if(Test((CWbemObject*)apObjects[i]))
{
apNewArray[lNewIndex++] = apObjects[i];
}
}
HRESULT hres = WBEM_S_NO_ERROR;
if(lNewIndex > 0)
{
hres = m_pDestIndicate->Indicate(lNewIndex, apNewArray);
}
return hres;
}
catch (CX_MemoryException &) // becasue Test uses CStack that throws
{
return WBEM_E_OUT_OF_MEMORY;
}
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CErrorChangingSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags == 0 && lParam == m_hresFrom)
return m_pDestStatus->SetStatus(0, m_hresTo, NULL, NULL);
else
return m_pDestStatus->SetStatus(lFlags, lParam, strParam, pObjParam);
}
//***************************************************************************
//
//***************************************************************************
CNoDuplicatesSink::CNoDuplicatesSink(CBasicObjectSink* pDest)
: CFilteringSink(pDest), m_strDupClass(NULL)
{
}
//***************************************************************************
//
//***************************************************************************
CNoDuplicatesSink::~CNoDuplicatesSink()
{
SysFreeString(m_strDupClass);
}
//***************************************************************************
//
//***************************************************************************
BOOL CNoDuplicatesSink::Test(CWbemObject* pObj)
{
CInCritSec ics(&m_cs);
// Get the path
// ============
CVar vPath;
if(FAILED(pObj->GetPath(&vPath)) || vPath.IsNull()) return FALSE;
if(m_mapPaths.find(vPath.GetLPWSTR()) == m_mapPaths.end())
{
m_mapPaths[vPath.GetLPWSTR()] = true;
return TRUE;
}
else
{
// Duplicate!
// ==========
ERRORTRACE((LOG_WBEMCORE, "Duplicate objects returned with path %S\n",
vPath.GetLPWSTR()));
ConfigMgr::GetEventLog()->Report(EVENTLOG_ERROR_TYPE,
WBEM_MC_DUPLICATE_OBJECTS, vPath.GetLPWSTR());
if(m_strDupClass == NULL)
{
m_strDupClass = SysAllocString(vPath.GetLPWSTR());
}
return FALSE;
}
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CNoDuplicatesSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags == WBEM_STATUS_COMPLETE && lParam == WBEM_S_NO_ERROR &&
m_strDupClass != NULL)
{
// Success is being reported, but we have seen duplications
// ========================================================
return CFilteringSink::SetStatus(lFlags, WBEM_S_DUPLICATE_OBJECTS,
m_strDupClass, pObjParam);
}
else
{
return CFilteringSink::SetStatus(lFlags, lParam, strParam, pObjParam);
}
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CHandleClassProvErrorsSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags == WBEM_STATUS_COMPLETE && FAILED(lParam) &&
lParam != WBEM_E_NOT_FOUND)
{
// Log an error into the event log
// ===============================
ERRORTRACE((LOG_WBEMCORE,
"Class provider '%S' installed in namespace '%S' failed to enumerate classes, "
"returning error code 0x%lx. Operations will continue as if the class provider "
"had no classes. This provider-specific error condition needs to be corrected "
"before this class provider can contribute to this namespace.\n",
(LPWSTR)m_wsProvider, (LPWSTR) m_wsNamespace, lParam));
lParam = WBEM_E_NOT_FOUND;
}
return CForwardingSink::SetStatus(lFlags, lParam, strParam, pObjParam);
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CSuccessSuppressionSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lFlags != WBEM_STATUS_COMPLETE ||
(FAILED(lParam) && lParam != m_hresNotError1 &&
lParam != m_hresNotError2))
{
return CForwardingSink::SetStatus(lFlags, lParam, strParam, pObjParam);
}
else
{
return WBEM_S_NO_ERROR;
}
}
//***************************************************************************
//
//***************************************************************************
#ifdef OLD
CWrapperMap::CWrapperMap()
{
}
//***************************************************************************
//
//***************************************************************************
CWrapperMap::~CWrapperMap()
{
}
//***************************************************************************
//
//***************************************************************************
void CWrapperMap::Map(const REQUESTID& id, IWbemObjectSink* pSink,
CWrapperSink* pWrapper)
{
CInCritSec ics(&m_cs);
m_mapSink.insert(TValueType(pSink, id));
m_mapGuid[id] = pWrapper;
}
//***************************************************************************
//
//***************************************************************************
RELEASE_ME CWrapperSink* CWrapperMap::FindWrapper(const GUID& id)
{
CInCritSec ics(&m_cs);
CWrapperSink* pWrapper = NULL;
if(m_mapGuid.find(id) != m_mapGuid.end())
{
pWrapper = m_mapGuid[id];
pWrapper->AddRef();
}
return pWrapper;
}
//***************************************************************************
//
//***************************************************************************
HRESULT CWrapperMap::FindWrappers(IWbemObjectSink* pSink,
CRefedPointerArray<CWrapperSink>& apWrappers)
{
CInCritSec ics(&m_cs);
TIterator it = m_mapSink.find(pSink);
while(it != m_mapSink.end() && it->first == pSink)
{
GUID& rguid = it->second;
apWrappers.Add(m_mapGuid[rguid]);
it++;
}
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
void CWrapperMap::Unmap(const REQUESTID& id, IWbemObjectSink* pSink)
{
CInCritSec ics(&m_cs);
m_mapGuid.erase(id);
TIterator it = m_mapSink.find(pSink);
while(it != m_mapSink.end() && it->first == pSink)
{
if(it->second == id)
{
m_mapSink.erase(it);
return;
}
it++;
}
ERRORTRACE((LOG_WBEMCORE, "Unable to unmap a sink --- not found\n"));
}
#endif
//***************************************************************************
//
//***************************************************************************
CDynPropsSink::CDynPropsSink(CBasicObjectSink* pDest, CWbemNamespace * pNs, long lRef) : CForwardingSink(pDest, lRef)
{
m_pNs = pNs;
if(m_pNs)
m_pNs->AddRef();
}
//***************************************************************************
//
//***************************************************************************
CDynPropsSink::~CDynPropsSink()
{
//
// Removing the impersonation at this point. There is no need to impersonate
// at this point since the sink below it is the CCombiningSink eventually
// ending up at the finalizer which correctly makes the calls to the client
//
//CAutoImpersonate ai;
//
// Send all the cached entries
DWORD dwCacheSize = m_UnsentCache.GetSize();
for(DWORD dwCnt = 0; dwCnt < dwCacheSize; dwCnt++)
{
IWbemClassObject* pObj = m_UnsentCache[dwCnt];
if(m_pNs)
m_pNs->GetOrPutDynProps((CWbemObject *)pObj, CWbemNamespace::GET);
m_pDestIndicate->Indicate(1, &pObj);
}
if(m_pNs)
m_pNs->Release();
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CDynPropsSink::Indicate(long lObjectCount,
IWbemClassObject** pObjArray)
{
// If there are no dyn props then immediately do the indicate
IWbemClassObject** apNewArray = new IWbemClassObject*[lObjectCount];
if (!apNewArray)
return WBEM_E_OUT_OF_MEMORY;
CVar vDynTest;
HRESULT hRes = S_OK;
long lIndex = 0 ;
for(long lCnt = 0; lCnt < lObjectCount; lCnt++)
{
CWbemObject *pWbemObj = (CWbemObject *)pObjArray[lCnt];
HRESULT hres = pWbemObj->GetQualifier(L"DYNPROPS", &vDynTest);
if (hres == S_OK && vDynTest.GetBool() == VARIANT_TRUE)
{
hRes = m_UnsentCache.Add(pWbemObj);
}
else
{
apNewArray[lIndex++] = pObjArray[lCnt] ;
}
}
if ( lIndex )
{
CAutoImpersonate ai;
hRes = m_pDestIndicate->Indicate(lIndex, apNewArray);
if ( FAILED ( ai.Impersonate ( ) ) )
{
hRes = WBEM_E_FAILED ;
}
}
delete [] apNewArray ;
return hRes;
}
//***************************************************************************
//
//***************************************************************************
STDMETHODIMP CMethodSink::Indicate(long lObjectCount,
IWbemClassObject** pObjArray)
{
if(lObjectCount == 1 && m_pRes == NULL)
{
pObjArray[0]->Clone(&m_pRes);
}
return S_OK;
}
STDMETHODIMP CMethodSink::SetStatus(long lFlags, long lParam,
BSTR strParam, IWbemClassObject* pObjParam)
{
if(lParam == S_OK && m_pRes)
{
m_pDestIndicate->Indicate(1, &m_pRes);
}
if(m_pRes)
m_pRes->Release();
return CForwardingSink::SetStatus(lFlags, lParam, strParam, pObjParam);
}
//***************************************************************************
//
// ZapWriteOnlyProps
//
// Removes write-only properties from an object.
// Precondition: Object has been tested for presence of "HasWriteOnlyProps"
// on the object itself.
//
//***************************************************************************
static HRESULT ZapWriteOnlyProps(IWbemClassObject *pObj)
{
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_NULL;
SAFEARRAY *pNames = 0;
pObj->GetNames(L"WriteOnly", WBEM_FLAG_ONLY_IF_TRUE, 0, &pNames);
LONG lUpper;
SafeArrayGetUBound(pNames, 1, &lUpper);
for (long i = 0; i <= lUpper; i++)
{
BSTR strName = 0;
SafeArrayGetElement(pNames, &i, &strName);
pObj->Put(strName, 0, &v, 0);
}
SafeArrayDestroy(pNames);
return WBEM_S_NO_ERROR;
}
//***************************************************************************
//
//***************************************************************************
//
CStdSink::CStdSink(IWbemObjectSink *pRealDest)
{
m_pDest = pRealDest;
m_hRes = 0;
m_bCancelForwarded = FALSE;
m_lRefCount = 0L;
if ( NULL != m_pDest )
m_pDest->AddRef();
InterlockedIncrement(&g_nStdSinkCount);
}
//***************************************************************************
//
//***************************************************************************
//
CStdSink::~CStdSink()
{
if ( NULL != m_pDest )
m_pDest->Release();
InterlockedDecrement(&g_nStdSinkCount);
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT CStdSink::Cancel()
{
HRESULT hResTmp;
m_hRes = WBEM_E_CALL_CANCELLED;
if (m_bCancelForwarded)
return m_hRes;
try
{
hResTmp = m_pDest->SetStatus(0, m_hRes, 0, 0);
}
catch (...) // untrusted code ?
{
ExceptionCounter c;
m_hRes = WBEM_E_CRITICAL_ERROR;
}
m_bCancelForwarded = TRUE;
return m_hRes;
}
//***************************************************************************
//
//***************************************************************************
//
ULONG STDMETHODCALLTYPE CStdSink::AddRef()
{
return InterlockedIncrement( &m_lRefCount );
}
//***************************************************************************
//
//***************************************************************************
//
ULONG STDMETHODCALLTYPE CStdSink::Release()
{
LONG lRes = InterlockedDecrement( &m_lRefCount );
if (lRes == 0)
delete this;
return lRes;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStdSink::QueryInterface(REFIID riid, LPVOID* ppvObj)
{
return m_pDest->QueryInterface(riid, ppvObj);
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStdSink::Indicate(
long lObjectCount,
IWbemClassObject** pObjArray
)
{
HRESULT hRes;
if (m_hRes == WBEM_E_CALL_CANCELLED)
{
return Cancel();
}
try
{
hRes = m_pDest->Indicate(lObjectCount, pObjArray);
}
catch (...) // untrusted code ?
{
ExceptionCounter c;
hRes = Cancel();
}
return hRes;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStdSink::SetStatus(
long lFlags,
long lParam,
BSTR strParam,
IWbemClassObject* pObjParam
)
{
HRESULT hRes;
if (m_hRes == WBEM_E_CALL_CANCELLED)
{
return Cancel();
}
try
{
hRes = m_pDest->SetStatus(lFlags, lParam, strParam, pObjParam);
}
catch (...) // untrusted code ?
{
ExceptionCounter c;
hRes = Cancel();
}
return hRes;
}
//***************************************************************************
//
//***************************************************************************
//
CFlexArray g_aProviderSinks;
CCritSec g_csProvSinkCs;
//***************************************************************************
//
//***************************************************************************
//
HRESULT WINAPI CProviderSink::Dump(FILE *f)
{
CInCritSec ics(&g_csProvSinkCs);
fprintf(f, "---Begin Provider Sink Info---\n");
for (int i = 0; i < g_aProviderSinks.Size(); i++)
{
CProviderSink *pSink = (CProviderSink *) g_aProviderSinks[i];
if (pSink)
{
fprintf(f, "Provider Sink 0x%p\n", pSink);
fprintf(f, " Total Indicates = %d\n", pSink->m_lIndicateCount);
// Check that this is non-NULL
if ( NULL != pSink->m_pszDebugInfo )
{
fprintf(f, " Debug Info = %S\n", pSink->m_pszDebugInfo);
}
else
{
fprintf(f, " Debug Info = NULL\n");
}
fprintf(f, " SetStatus called? %d\n", pSink->m_bDone);
fprintf(f, " hRes = 0x%X\n", pSink->m_hRes);
fprintf(f, " m_pNextSink = 0x%p\n", pSink->m_pNextSink);
}
}
fprintf(f, "---End Provider Sink Info---\n");
return 0;
}
//***************************************************************************
//
//***************************************************************************
//
CProviderSink::CProviderSink(
LONG lStartingRefCount,
LPWSTR pszDebugInf
):m_pNextSink(0)
{
m_lRefCount = lStartingRefCount;
InterlockedIncrement(&g_nSinkCount);
InterlockedIncrement(&g_nProviderSinkCount);
m_hRes = 0;
m_bDone = FALSE;
__try
{
InitializeCriticalSection(&m_cs);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
throw CX_MemoryException();
}
m_lIndicateCount = 0;
m_pszDebugInfo = 0;
if (pszDebugInf)
{
int nStrLen = wcslen(pszDebugInf);
m_pszDebugInfo = new wchar_t[nStrLen+1];
if (m_pszDebugInfo)
wcscpy(m_pszDebugInfo, pszDebugInf);
}
EnterCriticalSection(&g_csProvSinkCs);
g_aProviderSinks.Add(this);
LeaveCriticalSection(&g_csProvSinkCs);
}
//***************************************************************************
//
//***************************************************************************
//
CProviderSink::~CProviderSink()
{
{
CInCritSec ics(&g_csProvSinkCs);
for (int i = 0; i < g_aProviderSinks.Size(); i++)
{
if (this == (CProviderSink *) g_aProviderSinks[i])
{
g_aProviderSinks.RemoveAt(i);
break;
}
}
}
// Cleanup AFTER we remove from the array so the Diagnostic Thread won't
// crash.
ReleaseIfNotNULL(m_pNextSink);
InterlockedDecrement(&g_nSinkCount);
InterlockedDecrement(&g_nProviderSinkCount);
DeleteCriticalSection(&m_cs);
delete [] m_pszDebugInfo;
}
//***************************************************************************
//
//***************************************************************************
//
ULONG CProviderSink::AddRef()
{
LONG lRes = InterlockedIncrement(&m_lRefCount);
return (ULONG) lRes;
}
//***************************************************************************
//
//***************************************************************************
//
ULONG CProviderSink::LocalAddRef()
{
LONG lRes = InterlockedIncrement(&m_lRefCount);
return lRes;
}
//***************************************************************************
//
//***************************************************************************
//
ULONG CProviderSink::LocalRelease()
{
LONG lRes = InterlockedDecrement(&m_lRefCount);
if (lRes == 0)
delete this;
return lRes;
}
//***************************************************************************
//
//***************************************************************************
//
ULONG CProviderSink::Release()
{
LONG lRes = InterlockedDecrement(&m_lRefCount);
if (lRes == 0)
delete this;
return (ULONG) lRes;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT CProviderSink::QueryInterface(REFIID riid, LPVOID* ppvObj)
{
if (riid == IID_IUnknown || riid == IID_IWbemObjectSink)
{
*ppvObj = (IWbemObjectSink*)this;
AddRef();
return S_OK;
}
else return E_NOINTERFACE;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT CProviderSink::Indicate(
long lObjectCount,
IWbemClassObject** pObjArray
)
{
if (m_hRes)
return m_hRes;
IWbemObjectSink* pNextSink = NULL;
{
CInCritSec ics(&m_cs);
pNextSink = m_pNextSink;
if ( NULL != pNextSink )
{
pNextSink->AddRef();
}
}
// AutoRelease
CReleaseMe rm( pNextSink );
HRESULT hRes;
if ( NULL != pNextSink )
{
m_lIndicateCount += lObjectCount;
hRes = pNextSink->Indicate(lObjectCount, pObjArray);
}
else
{
hRes = WBEM_E_CRITICAL_ERROR;
}
return hRes;
}
//***************************************************************************
//
//***************************************************************************
//
void CProviderSink::Cancel()
{
if (m_bDone)
return;
IWbemObjectSink* pNextSink = NULL;
EnterCriticalSection(&m_cs);
m_hRes = WBEM_E_CALL_CANCELLED;
pNextSink = m_pNextSink;
if ( NULL != m_pNextSink )
{
// We will release it outside the critical section
m_pNextSink = NULL;
}
LeaveCriticalSection(&m_cs);
// Auto Release
CReleaseMe rm( pNextSink );
if ( pNextSink )
{
pNextSink->SetStatus(0, WBEM_E_CALL_CANCELLED, 0, 0);
}
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT CProviderSink::SetStatus(
long lFlags,
long lParam,
BSTR strParam,
IWbemClassObject* pObjParam
)
{
if (m_hRes)
return m_hRes;
IWbemObjectSink* pNextSink = NULL;
EnterCriticalSection(&m_cs);
pNextSink = m_pNextSink;
if ( NULL != m_pNextSink )
{
// We will always release it outside the critical section
// If this is the completion status, then we should go ahead and set
// the member variable to NULL. We're done with the sink.
if ( lFlags == WBEM_STATUS_COMPLETE )
{
m_pNextSink = NULL;
}
else
{
pNextSink->AddRef();
}
}
LeaveCriticalSection(&m_cs);
// Auto Release
CReleaseMe rm( pNextSink );
HRESULT hRes = WBEM_S_NO_ERROR;
if ( NULL != pNextSink )
{
pNextSink->SetStatus(lFlags, lParam, strParam, pObjParam);
m_bDone = TRUE;
}
return hRes;
}
//***************************************************************************
//
//***************************************************************************
//
long g_lNumStatusSinks = 0L;
CStatusSink::CStatusSink( void )
: m_hRes( WBEM_S_NO_ERROR ),
m_lRefCount( 1 )
{
InterlockedIncrement( &g_lNumStatusSinks );
}
//***************************************************************************
//
//***************************************************************************
//
CStatusSink::~CStatusSink()
{
InterlockedDecrement( &g_lNumStatusSinks );
}
//***************************************************************************
//
//***************************************************************************
//
ULONG STDMETHODCALLTYPE CStatusSink::AddRef()
{
return InterlockedIncrement( &m_lRefCount );
}
//***************************************************************************
//
//***************************************************************************
//
ULONG STDMETHODCALLTYPE CStatusSink::Release()
{
LONG lRes = InterlockedDecrement( &m_lRefCount );
if (lRes == 0)
delete this;
return lRes;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStatusSink::QueryInterface(REFIID riid, LPVOID* ppvObj)
{
if( riid == IID_IUnknown || riid == IID_IWbemObjectSink )
{
*ppvObj = (IWbemObjectSink*)this;
AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStatusSink::Indicate(
long lObjectCount,
IWbemClassObject** pObjArray
)
{
// Why are we even here??!?!?!?
_DBG_ASSERT( 0 );
return WBEM_E_FAILED;
}
//***************************************************************************
//
//***************************************************************************
//
HRESULT STDMETHODCALLTYPE CStatusSink::SetStatus(
long lFlags,
long lParam,
BSTR strParam,
IWbemClassObject* pObjParam
)
{
if ( lFlags == WBEM_STATUS_COMPLETE )
{
if ( SUCCEEDED( m_hRes ) && FAILED( lParam ) )
{
m_hRes = lParam;
}
}
return WBEM_S_NO_ERROR;
}
Reference in New Issue View Git Blame Copy Permalink