able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/providers/viewprovider/vpserv.cpp

1732 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//***************************************************************************
//
// VPSERV.CPP
//
// Module: WBEM VIEW PROVIDER
//
// Purpose: Contains the WBEM services interfaces
//
// Copyright (c) 1998-2001 Microsoft Corporation, All Rights Reserved
//
//***************************************************************************
//need the following three lines
//to get the security stuff to work
#include "precomp.h"
#include <provexpt.h>
#include <provcoll.h>
#include <provtempl.h>
#include <provmt.h>
#include <typeinfo.h>
#include <process.h>
#include <objbase.h>
#include <objidl.h>
#include <stdio.h>
#include <wbemidl.h>
#include <provcont.h>
#include <provevt.h>
#include <provthrd.h>
#include <provlog.h>
#include <cominit.h>
#include <dsgetdc.h>
#include <lmcons.h>
#include <instpath.h>
#include <genlex.h>
#include <sql_1.h>
#include <objpath.h>
#include <vpdefs.h>
#include <vpquals.h>
#include <vpserv.h>
#include <vptasks.h>
#include <vpcfac.h>
extern CRITICAL_SECTION g_CriticalSection;
extern HRESULT SetSecurityLevelAndCloaking(IUnknown* pInterface, const wchar_t* prncpl);
#ifdef UNICODE
#if 0
extern HRESULT GetCurrentSecuritySettings(DWORD *pdwAuthnSvc, DWORD *pdwAuthzSvc,
DWORD *pdwAuthLevel, DWORD *pdwImpLevel,
DWORD *pdwCapabilities);
void VPGetUserName()
{
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
//first get current security info then set it on the proxy...
DWORD dwAuthnSvc = 0;
DWORD dwAuthzSvc = 0;
DWORD dwAuthLevel = 0;
DWORD dwImpLevel = 0;
DWORD dwCapabilities = 0;
HRESULT hr = GetCurrentSecuritySettings(&dwAuthnSvc, &dwAuthzSvc, &dwAuthLevel, &dwImpLevel, &dwCapabilities);
HANDLE hThreadTok = NULL;
if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &hThreadTok) )
{
DWORD dwBytesReturned = 0;
UCHAR tokBuff [1024];
PTOKEN_USER ptokUser = (PTOKEN_USER)tokBuff;
if (GetTokenInformation(hThreadTok, TokenUser, ptokUser,
sizeof(tokBuff), &dwBytesReturned))
{
wchar_t buffN[1024];
DWORD buffNlen = 1024;
wchar_t buffD[1024];
DWORD buffDlen = 1024;
SID_NAME_USE snu;
if (!LookupAccountSid(NULL, ptokUser->User.Sid, buffN, &buffNlen, buffD, &buffDlen, &snu))
{
DWORD dwErr = GetLastError();
}
}
CloseHandle(hThreadTok);
}
}
#endif
#endif
wchar_t *UnicodeStringDuplicate ( const wchar_t *string )
{
if ( string )
{
int textLength = wcslen ( string ) ;
wchar_t *textBuffer = new wchar_t [ textLength + 1 ] ;
wcscpy ( textBuffer , string ) ;
return textBuffer ;
}
else
{
return NULL ;
}
}
wchar_t *UnicodeStringAppend ( const wchar_t *prefix , const wchar_t *suffix )
{
int prefixTextLength = 0 ;
if ( prefix )
{
prefixTextLength = wcstombs ( NULL , prefix , 0 ) ;
}
int suffixTextLength = 0 ;
if ( suffix )
{
suffixTextLength = wcstombs ( NULL , suffix , 0 ) ;
}
if ( prefix || suffix )
{
int textLength = prefixTextLength + suffixTextLength ;
wchar_t *textBuffer = new wchar_t [ textLength + 1 ] ;
if ( prefix )
{
wcscpy ( textBuffer , prefix ) ;
}
if ( suffix )
{
wcscpy ( & textBuffer [ prefixTextLength ] , suffix ) ;
}
return textBuffer ;
}
else
return NULL ;
}
CWbemServerWrap::CWbemServerWrap(IWbemServices *pServ, const wchar_t* prncpl, const wchar_t* path)
: m_Principal(NULL), m_Path(NULL)
{
m_ref = 0;
m_MainServ = pServ;
if (prncpl != NULL)
{
m_Principal = UnicodeStringDuplicate(prncpl);
}
if (path != NULL)
{
m_Path = SysAllocString(path);
}
if (m_MainServ)
{
m_MainServ->AddRef();
}
}
CWbemServerWrap::~CWbemServerWrap()
{
if (m_MainServ)
{
m_MainServ->Release();
}
#ifdef UNICODE
if (m_Lock.Lock())
{
m_ProxyPool.RemoveAll();
m_Lock.Unlock();
}
#endif
if (m_Principal != NULL)
{
delete [] m_Principal;
}
if (m_Path != NULL)
{
SysFreeString(m_Path);
}
}
IWbemServices* CWbemServerWrap::GetServerOrProxy()
{
IWbemServices * retVal = NULL;
#ifdef UNICODE
if (m_MainServ == NULL)
{
return m_MainServ;
}
//if (IsRemote())
{
if (m_Lock.Lock())
{
POSITION t_pos = m_ProxyPool.GetHeadPosition();
while (t_pos)
{
CWbemProxyServerWrap &t_srvRef = m_ProxyPool.GetNext(t_pos);
if (!t_srvRef.m_InUse)
{
t_srvRef.m_InUse = TRUE;
retVal = t_srvRef.m_Proxy;
break;
}
}
//calling back into COM so must unlock
//addref MainServ then release it afterward;
IWbemServices *t_MainCopy = m_MainServ;
t_MainCopy->AddRef();
m_Lock.Unlock();
if (retVal == NULL)
{
IClientSecurity *pcs = NULL;
if ( SUCCEEDED (t_MainCopy->QueryInterface(IID_IClientSecurity, (void**)&pcs)) )
{
if (FAILED(pcs->CopyProxy(t_MainCopy, (IUnknown **)(&retVal))))
{
retVal = NULL;
}
else
{
CWbemProxyServerWrap t_srv(retVal);
t_srv.m_InUse = TRUE;
if (m_Lock.Lock())
{
//only store and use if m_MainServ is unchanged
if (t_MainCopy == m_MainServ)
{
m_ProxyPool.AddTail(t_srv);
}
else
{
//pathological case, mainserv was bad and has changed
//could recurse at this point but is it worth it?
//not thought so at this time.
retVal->Release();
retVal = NULL;
}
m_Lock.Unlock();
}
else
{
//can't use this proxy if I can't store it
retVal->Release();
retVal = NULL;
}
}
pcs->Release();
}
}
t_MainCopy->Release();
if (retVal && FAILED(SetSecurityLevelAndCloaking(retVal, IsRemote() ? m_Principal : COLE_DEFAULT_PRINCIPAL)))
{
retVal->AddRef(); //addref for the release that Returning the proxy will do
ReturnServerOrProxy(retVal);
retVal = NULL;
}
}
}
//else
//{
// retVal = m_MainServ;
//}
#else
retVal = m_MainServ;
#endif
if (retVal)
{
retVal->AddRef();
}
return retVal;
}
void CWbemServerWrap::ReturnServerOrProxy(IWbemServices* a_pServ)
{
#ifdef UNICODE
//if (IsRemote())
{
if (m_Lock.Lock())
{
POSITION t_pos = m_ProxyPool.GetHeadPosition();
while (t_pos)
{
CWbemProxyServerWrap &t_proxyRef = m_ProxyPool.GetNext(t_pos);
if (t_proxyRef.m_Proxy == a_pServ)
{
t_proxyRef.m_InUse = FALSE;
break;
}
}
m_Lock.Unlock();
}
}
#endif
a_pServ->Release();
}
BOOL CWbemServerWrap::ProxyBelongsTo(IWbemServices *a_proxy)
{
BOOL retVal = FALSE;
#ifdef UNICODE
if (IsRemote())
{
if (m_Lock.Lock())
{
POSITION t_pos = m_ProxyPool.GetHeadPosition();
while (t_pos)
{
CWbemProxyServerWrap &t_proxyRef = m_ProxyPool.GetNext(t_pos);
if (t_proxyRef.m_Proxy == a_proxy)
{
retVal = TRUE;
break;
}
}
m_Lock.Unlock();
}
}
#endif
return retVal;
}
void CWbemServerWrap::SetMainServer(IWbemServices *a_pServ)
{
#ifdef UNICODE
if (m_Lock.Lock())
{
if (m_MainServ)
{
m_MainServ->Release();
}
m_MainServ = a_pServ;
if (m_MainServ)
{
m_MainServ->AddRef();
}
m_ProxyPool.RemoveAll();
m_Lock.Unlock();
}
#endif
}
ULONG CWbemServerWrap::AddRef()
{
return (ULONG)(InterlockedIncrement(&m_ref));
}
ULONG CWbemServerWrap::Release()
{
ULONG i = (ULONG)(InterlockedDecrement(&m_ref));
if (i == 0)
{
delete this;
}
return i;
}
void CIWbemServMap::EmptyMap()
{
if (Lock())
{
RemoveAll();
Unlock();
}
}
/////////////////////////////////////////////////////////////////////////////
// Functions constructor, destructor and IUnknown
//***************************************************************************
//
// CViewProvServ ::CViewProvServ
// CViewProvServ ::~CViewProvServ
//
//***************************************************************************
CViewProvServ ::CViewProvServ () :
sm_Locator (NULL),
sm_ConnectionMade (NULL),
m_UserName (NULL),
m_Initialised (FALSE),
m_Server (NULL),
m_Namespace (NULL),
m_NotificationClassObject (NULL),
m_ExtendedNotificationClassObject (NULL),
m_GetNotifyCalled (FALSE),
m_GetExtendedNotifyCalled (FALSE ),
m_localeId (NULL)
{
EnterCriticalSection(&g_CriticalSection);
CViewProvClassFactory :: objectsInProgress++ ;
LeaveCriticalSection(&g_CriticalSection);
m_ReferenceCount = 0 ;
/*
* Implementation
*/
sm_ConnectionMade = CreateEvent(NULL, TRUE, FALSE, NULL);
}
CViewProvServ ::~CViewProvServ(void)
{
delete [] m_localeId ;
delete [] m_Namespace ;
if ( m_Server )
m_Server->Release () ;
if ( m_NotificationClassObject )
m_NotificationClassObject->Release () ;
if ( m_ExtendedNotificationClassObject )
m_ExtendedNotificationClassObject->Release () ;
if (sm_Locator != NULL)
{
sm_Locator->Release();
}
if (NULL != sm_ConnectionMade)
{
CloseHandle(sm_ConnectionMade);
}
sm_ServerMap.EmptyMap();
if (sm_ServerMap.Lock())
{
sm_OutStandingConnections.RemoveAll();
sm_ServerMap.Unlock();
}
if (m_UserName != NULL)
{
SysFreeString(m_UserName);
}
EnterCriticalSection(&g_CriticalSection);
CViewProvClassFactory :: objectsInProgress--;
LeaveCriticalSection(&g_CriticalSection);
}
HRESULT CViewProvServ::GetUnsecApp(IUnsecuredApartment** ppLoc)
{
if (NULL == ppLoc)
{
return WBEM_E_INVALID_PARAMETER;
}
EnterCriticalSection(&g_CriticalSection);
HRESULT hr = WBEM_NO_ERROR;
if (NULL == sm_UnsecApp)
{
hr = CoCreateInstance(CLSID_UnsecuredApartment, NULL, CLSCTX_LOCAL_SERVER,
IID_IUnsecuredApartment, ( void ** )&sm_UnsecApp);
if (FAILED(hr))
{
sm_UnsecApp = NULL;
}
else
{
sm_UnsecApp->AddRef();
}
}
else
{
sm_UnsecApp->AddRef();
}
*ppLoc = sm_UnsecApp;
LeaveCriticalSection(&g_CriticalSection);
return hr;
}
#if 0
typedef HRESULT (__stdcall *VP_PROC_DllGetClassObject)(REFCLSID rclsid , REFIID riid, void **ppv);
#endif
HRESULT CViewProvServ::GetLocator(IWbemLocator **ppLoc)
{
if (NULL == ppLoc)
{
return WBEM_E_INVALID_PARAMETER;
}
else
{
*ppLoc = NULL;
}
HRESULT hr = WBEM_E_FAILED;
if (m_criticalSection.Lock())
{
if (NULL == sm_Locator)
{
m_criticalSection.Unlock();
#ifdef UNICODE
hr = CoCreateInstance(CLSID_WbemLocator, NULL,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator, ( void ** )ppLoc);
#else
hr = CoCreateInstance(CLSID_WbemUnauthenticatedLocator, NULL,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator, ( void ** )ppLoc);
#endif
if (m_criticalSection.Lock())
{
//another thread may have connected for us...
if (NULL == sm_Locator)
{
if (SUCCEEDED(hr))
{
sm_Locator = *ppLoc;
sm_Locator->AddRef();
}
}
else
{
if (FAILED(hr))
{
hr = WBEM_NO_ERROR;
sm_Locator->AddRef();
*ppLoc = sm_Locator;
}
}
}
else
{
return hr;
}
}
else
{
hr = WBEM_NO_ERROR;
sm_Locator->AddRef();
*ppLoc = sm_Locator;
}
m_criticalSection.Unlock();
}
return hr;
}
//***************************************************************************
//
// CViewProvServ ::QueryInterface
// CViewProvServ ::AddRef
// CViewProvServ ::Release
//
// Purpose: IUnknown members for CViewProvServ object.
//***************************************************************************
STDMETHODIMP CViewProvServ ::QueryInterface (
REFIID iid ,
LPVOID FAR *iplpv
)
{
SetStructuredExceptionHandler seh;
try
{
if (iplpv == NULL)
{
return E_INVALIDARG;
}
*iplpv = NULL ;
if ( iid == IID_IUnknown )
{
*iplpv = ( IWbemServices* ) this ;
}
else if ( iid == IID_IWbemServices )
{
*iplpv = ( IWbemServices* ) this ;
}
else if ( iid == IID_IWbemProviderInit )
{
*iplpv = ( IWbemProviderInit* ) this ;
}
if ( *iplpv )
{
( ( LPUNKNOWN ) *iplpv )->AddRef () ;
return S_OK ;
}
else
{
return E_NOINTERFACE ;
}
}
catch(Structured_Exception e_SE)
{
return E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
return E_OUTOFMEMORY;
}
catch(...)
{
return E_UNEXPECTED;
}
}
STDMETHODIMP_(ULONG) CViewProvServ ::AddRef(void)
{
SetStructuredExceptionHandler seh;
try
{
return InterlockedIncrement ( & m_ReferenceCount ) ;
}
catch(Structured_Exception e_SE)
{
return 0;
}
catch(Heap_Exception e_HE)
{
return 0;
}
catch(...)
{
return 0;
}
}
STDMETHODIMP_(ULONG) CViewProvServ ::Release(void)
{
SetStructuredExceptionHandler seh;
try
{
LONG t_Ref ;
if ( ( t_Ref = InterlockedDecrement ( & m_ReferenceCount ) ) == 0 )
{
delete this ;
return 0 ;
}
else
{
return t_Ref ;
}
}
catch(Structured_Exception e_SE)
{
return 0;
}
catch(Heap_Exception e_HE)
{
return 0;
}
catch(...)
{
return 0;
}
}
IWbemServices *CViewProvServ :: GetServer ()
{
if ( m_Server )
m_Server->AddRef () ;
return m_Server ;
}
void CViewProvServ :: SetLocaleId ( wchar_t *localeId )
{
m_localeId = UnicodeStringDuplicate ( localeId ) ;
}
wchar_t *CViewProvServ :: GetNamespace ()
{
return m_Namespace ;
}
void CViewProvServ :: SetNamespace ( wchar_t *a_Namespace )
{
m_Namespace = UnicodeStringDuplicate ( a_Namespace ) ;
}
IWbemClassObject *CViewProvServ :: GetNotificationObject (
WbemProvErrorObject &a_errorObject,
IWbemContext *pCtx
)
{
if ( m_NotificationClassObject )
{
m_NotificationClassObject->AddRef () ;
}
else
{
BOOL t_Status = CreateNotificationObject ( a_errorObject, pCtx ) ;
if ( t_Status )
{
/*
* Keep around until we close
*/
m_NotificationClassObject->AddRef () ;
}
}
return m_NotificationClassObject ;
}
IWbemClassObject *CViewProvServ :: GetExtendedNotificationObject (
WbemProvErrorObject &a_errorObject,
IWbemContext *pCtx
)
{
if ( m_ExtendedNotificationClassObject )
{
m_ExtendedNotificationClassObject->AddRef () ;
}
else
{
BOOL t_Status = CreateExtendedNotificationObject ( a_errorObject, pCtx ) ;
if ( t_Status )
{
/*
* Keep around until we close
*/
m_ExtendedNotificationClassObject->AddRef () ;
}
}
return m_ExtendedNotificationClassObject ;
}
BOOL CViewProvServ :: CreateExtendedNotificationObject (
WbemProvErrorObject &a_errorObject,
IWbemContext *pCtx
)
{
if ( m_GetExtendedNotifyCalled )
{
if ( m_ExtendedNotificationClassObject )
return TRUE ;
else
return FALSE ;
}
else
m_GetExtendedNotifyCalled = TRUE ;
BOOL t_Status = TRUE ;
BSTR t_bstrTemp = SysAllocString(WBEM_CLASS_EXTENDEDSTATUS);
HRESULT t_Result = m_Server->GetObject (
t_bstrTemp ,
0 ,
pCtx,
& m_ExtendedNotificationClassObject ,
NULL
) ;
SysFreeString(t_bstrTemp);
if ( ! SUCCEEDED ( t_Result ) )
{
t_Status = FALSE ;
a_errorObject.SetStatus ( WBEM_PROV_E_INVALID_OBJECT ) ;
a_errorObject.SetWbemStatus ( WBEM_E_FAILED ) ;
a_errorObject.SetMessage ( L"Failed to get __ExtendedStatus" ) ;
m_ExtendedNotificationClassObject = NULL ;
}
return t_Status ;
}
BOOL CViewProvServ :: CreateNotificationObject (
WbemProvErrorObject &a_errorObject,
IWbemContext *pCtx
)
{
if ( m_GetNotifyCalled )
{
if ( m_NotificationClassObject )
return TRUE ;
else
return FALSE ;
}
else
m_GetNotifyCalled = TRUE ;
BOOL t_Status = TRUE ;
BSTR t_bstrTemp = SysAllocString(WBEM_CLASS_EXTENDEDSTATUS);
HRESULT t_Result = m_Server->GetObject (
t_bstrTemp ,
0 ,
pCtx,
& m_NotificationClassObject ,
NULL
) ;
SysFreeString(t_bstrTemp);
if ( ! SUCCEEDED ( t_Result ) )
{
t_Status = FALSE ;
a_errorObject.SetStatus ( WBEM_PROV_E_INVALID_OBJECT ) ;
a_errorObject.SetWbemStatus ( WBEM_E_FAILED ) ;
a_errorObject.SetMessage ( L"Failed to get __ExtendedStatus" ) ;
m_NotificationClassObject = NULL;
}
return t_Status ;
}
/////////////////////////////////////////////////////////////////////////////
// Functions for the IWbemServices interface that are handled here
HRESULT CViewProvServ :: CancelAsyncCall (
IWbemObjectSink __RPC_FAR *pSink
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: QueryObjectSink (
long lFlags,
IWbemObjectSink __RPC_FAR* __RPC_FAR* ppHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: GetObject (
const BSTR ObjectPath,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemClassObject __RPC_FAR* __RPC_FAR *ppObject,
IWbemCallResult __RPC_FAR* __RPC_FAR *ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: GetObjectAsync (
const BSTR ObjectPath,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
HRESULT hr = S_OK;
SetStructuredExceptionHandler seh;
GetObjectTaskObject *t_AsyncEvent = NULL;
try
{
if (pHandler == NULL)
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
hr = WbemCoImpersonateClient();
#ifdef UNICODE
#if 0
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
VPGetUserName();
#endif
#endif
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("CViewProvServ::GetObjectAsync ()")
) ;
)
if (SUCCEEDED(hr))
{
/*
* Create Asynchronous GetObjectByPath object
*/
t_AsyncEvent = new GetObjectTaskObject ( this , ObjectPath , lFlags , pHandler , pCtx, NULL, NULL ) ;
t_AsyncEvent->GetObject();
t_AsyncEvent->Release();
t_AsyncEvent = NULL;
WbemCoRevertToSelf();
}
else
{
hr = WBEM_E_ACCESS_DENIED;
}
DebugOut1(
CViewProvServ::sm_debugLog->WriteW (
L"Returning from CViewProvServ::GetObjectAsync ( (%s) ) with Result = (%lx)" ,
ObjectPath ,
hr
) ;
)
}
}
catch(Structured_Exception e_SE)
{
hr = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
hr = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
hr = WBEM_E_UNEXPECTED;
}
try
{
if (t_AsyncEvent != NULL)
{
t_AsyncEvent->CleanUpObjSinks(TRUE);
t_AsyncEvent->Release();
}
}
catch(Structured_Exception e_SE)
{
hr = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
hr = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
hr = WBEM_E_UNEXPECTED;
}
return hr ;
}
HRESULT CViewProvServ :: PutClass (
IWbemClassObject __RPC_FAR* pClass ,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemCallResult __RPC_FAR* __RPC_FAR* ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: PutClassAsync (
IWbemClassObject __RPC_FAR* pClass,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: DeleteClass (
const BSTR Class,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemCallResult __RPC_FAR* __RPC_FAR* ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: DeleteClassAsync (
const BSTR Class,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: CreateClassEnum (
const BSTR Superclass,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IEnumWbemClassObject __RPC_FAR *__RPC_FAR *ppEnum
)
{
return WBEM_E_NOT_AVAILABLE ;
}
SCODE CViewProvServ :: CreateClassEnumAsync (
const BSTR Superclass,
long lFlags,
IWbemContext __RPC_FAR* pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: PutInstance (
IWbemClassObject __RPC_FAR *pInstance,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemCallResult __RPC_FAR *__RPC_FAR *ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: PutInstanceAsync (
IWbemClassObject __RPC_FAR* pInstance,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
HRESULT t_Result = S_OK ;
SetStructuredExceptionHandler seh;
PutInstanceTaskObject *t_AsyncEvent = NULL;
try
{
if (pHandler == NULL)
{
t_Result = WBEM_E_INVALID_PARAMETER;
}
else
{
t_Result = WbemCoImpersonateClient();
#ifdef UNICODE
#if 0
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
VPGetUserName();
#endif
#endif
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("CViewProvServ::PutInstanceAsync ()")
) ;
)
if (SUCCEEDED(t_Result))
{
/*
* Create Asynchronous GetObjectByPath object
*/
t_AsyncEvent = new PutInstanceTaskObject ( this , pInstance , lFlags , pHandler , pCtx ) ;
t_AsyncEvent->PutInstance();
t_AsyncEvent->Release();
t_AsyncEvent = NULL;
WbemCoRevertToSelf();
}
else
{
t_Result = WBEM_E_ACCESS_DENIED;
}
DebugOut1(
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("Returning from CViewProvServ::PutInstanceAsync with Result = (%lx)"),
t_Result
) ;
)
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
try
{
if (t_AsyncEvent != NULL)
{
t_AsyncEvent->Release();
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
return t_Result ;
}
HRESULT CViewProvServ :: DeleteInstance (
const BSTR ObjectPath,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemCallResult __RPC_FAR *__RPC_FAR *ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: DeleteInstanceAsync (
const BSTR ObjectPath,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR *pHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: CreateInstanceEnum (
const BSTR Class,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IEnumWbemClassObject __RPC_FAR *__RPC_FAR *ppEnum
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: CreateInstanceEnumAsync (
const BSTR Class,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
HRESULT t_Result = S_OK ;
SetStructuredExceptionHandler seh;
ExecQueryTaskObject *t_AsyncEvent = NULL;
BSTR Query = NULL;
try
{
if (pHandler == NULL)
{
t_Result = WBEM_E_INVALID_PARAMETER;
}
else
{
t_Result = WbemCoImpersonateClient();
#ifdef UNICODE
#if 0
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
VPGetUserName();
#endif
#endif
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteW (
L"CViewProvServ::CreateInstanceEnumAsync ( (%s) )" ,
Class
) ;
)
if (SUCCEEDED(t_Result))
{
/*
* Create Synchronous Enum Instance object
*/
Query = SysAllocStringLen(NULL, 33 + (wcslen(Class) * 2));
if (Query == NULL)
{
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
}
wcscpy(Query, ENUM_INST_QUERY_START);
wcscat(Query, Class);
wcscat(Query, ENUM_INST_QUERY_MID);
wcscat(Query, Class);
wcscat(Query, END_QUOTE);
t_AsyncEvent = new ExecQueryTaskObject ( this , WBEM_QUERY_LANGUAGE_SQL1 , Query , lFlags , pHandler , pCtx ) ;
t_AsyncEvent->ExecQuery();
t_AsyncEvent->Release();
t_AsyncEvent = NULL;
SysFreeString(Query);
WbemCoRevertToSelf();
}
else
{
t_Result = WBEM_E_ACCESS_DENIED;
}
DebugOut1(
CViewProvServ::sm_debugLog->WriteW (
L"Returning from CViewProvServ::CreateInstanceEnumAsync ( (%s),(%s) ) with Result = (%lx)" ,
Class,
Query,
t_Result
) ;
)
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
try
{
if (t_AsyncEvent != NULL)
{
t_AsyncEvent->CleanUpObjSinks(TRUE);
t_AsyncEvent->Release();
SysFreeString(Query);
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
return t_Result ;
}
HRESULT CViewProvServ :: ExecQuery (
const BSTR QueryLanguage,
const BSTR Query,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IEnumWbemClassObject __RPC_FAR *__RPC_FAR *ppEnum
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: ExecQueryAsync (
const BSTR QueryFormat,
const BSTR Query,
long lFlags,
IWbemContext __RPC_FAR* pCtx,
IWbemObjectSink __RPC_FAR* pHandler
)
{
HRESULT t_Result = S_OK ;
SetStructuredExceptionHandler seh;
ExecQueryTaskObject *t_AsyncEvent = NULL;
try
{
if (pHandler == NULL)
{
t_Result = WBEM_E_INVALID_PARAMETER;
}
else
{
t_Result = WbemCoImpersonateClient();
#ifdef UNICODE
#if 0
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
VPGetUserName();
#endif
#endif
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteW (
L"CViewProvServ::ExecQueryAsync ( (%s),(%s) )" ,
QueryFormat ,
Query
) ;
)
if (SUCCEEDED(t_Result))
{
/*
* Create Synchronous Enum Instance object
*/
pHandler->SetStatus(WBEM_STATUS_REQUIREMENTS, S_OK, NULL, NULL);
t_AsyncEvent = new ExecQueryTaskObject ( this , QueryFormat , Query , lFlags , pHandler , pCtx ) ;
t_AsyncEvent->ExecQuery();
t_AsyncEvent->Release();
t_AsyncEvent = NULL;
WbemCoRevertToSelf();
}
else
{
t_Result = WBEM_E_ACCESS_DENIED;
}
DebugOut1(
CViewProvServ::sm_debugLog->WriteW (
L"Returning from CViewProvServ::ExecqQueryAsync ( (%s),(%s) ) with Result = (%lx)" ,
QueryFormat ,
Query ,
t_Result
) ;
)
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
try
{
if (t_AsyncEvent != NULL)
{
t_AsyncEvent->CleanUpObjSinks(TRUE);
t_AsyncEvent->Release();
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
return t_Result ;
}
HRESULT CViewProvServ :: ExecNotificationQuery (
const BSTR QueryLanguage,
const BSTR Query,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IEnumWbemClassObject __RPC_FAR *__RPC_FAR *ppEnum
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT CViewProvServ :: ExecNotificationQueryAsync (
const BSTR QueryLanguage,
const BSTR Query,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemObjectSink __RPC_FAR *pHandler
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT STDMETHODCALLTYPE CViewProvServ :: ExecMethod(
const BSTR ObjectPath,
const BSTR MethodName,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemClassObject __RPC_FAR *pInParams,
IWbemClassObject __RPC_FAR *__RPC_FAR *ppOutParams,
IWbemCallResult __RPC_FAR *__RPC_FAR *ppCallResult
)
{
return WBEM_E_NOT_AVAILABLE ;
}
HRESULT STDMETHODCALLTYPE CViewProvServ :: ExecMethodAsync (
const BSTR ObjectPath,
const BSTR MethodName,
long lFlags,
IWbemContext __RPC_FAR *pCtx,
IWbemClassObject __RPC_FAR *pInParams,
IWbemObjectSink __RPC_FAR *pResponseHandler
)
{
HRESULT t_Result = S_OK ;
SetStructuredExceptionHandler seh;
ExecMethodTaskObject *t_AsyncEvent = NULL;
try
{
if (pResponseHandler == NULL)
{
t_Result = WBEM_E_INVALID_PARAMETER;
}
else
{
t_Result = WbemCoImpersonateClient();
#ifdef UNICODE
#if 0
DWORD dwBuffSz = 1024;
wchar_t strBuff[1024];
GetUserName(strBuff, &dwBuffSz);
VPGetUserName();
#endif
#endif
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("CViewProvServ::ExecMethodAsync ()")
) ;
)
if (SUCCEEDED(t_Result))
{
/*
* Create Asynchronous GetObjectByPath object
*/
t_AsyncEvent = new ExecMethodTaskObject ( this , ObjectPath , MethodName ,
lFlags , pInParams , pResponseHandler , pCtx ) ;
t_AsyncEvent->ExecMethod();
t_AsyncEvent->Release();
t_AsyncEvent = NULL;
WbemCoRevertToSelf();
}
else
{
t_Result = WBEM_E_ACCESS_DENIED;
}
DebugOut1(
CViewProvServ::sm_debugLog->WriteW (
L"Returning from CViewProvServ::ExecMethodAsync ( (%s) ) with Result = (%lx)" ,
ObjectPath ,
t_Result
) ;
)
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
try
{
if (t_AsyncEvent != NULL)
{
t_AsyncEvent->Release();
}
}
catch(Structured_Exception e_SE)
{
t_Result = WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
t_Result = WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
t_Result = WBEM_E_UNEXPECTED;
}
return t_Result ;
}
HRESULT CViewProvServ :: Initialize(
LPWSTR pszUser,
LONG lFlags,
LPWSTR pszNamespace,
LPWSTR pszLocale,
IWbemServices *pCIMOM, // For anybody
IWbemContext *pCtx,
IWbemProviderInitSink *pInitSink // For init signals
)
{
SetStructuredExceptionHandler seh;
try
{
DebugOut1(
CViewProvServ::sm_debugLog->Write (
_T("\r\n")
) ;
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("CViewProvServ::Initialize ")
) ;
)
if ((pCIMOM == NULL) || (pInitSink == NULL) || (pszNamespace == NULL))
{
return WBEM_E_INVALID_PARAMETER;
}
#ifndef UNICODE
if (pszUser == NULL)
{
return WBEM_E_INVALID_PARAMETER;
}
m_UserName = SysAllocString(pszUser);
#endif
m_Server = pCIMOM ;
m_Server->AddRef () ;
m_NamespacePath.SetNamespacePath ( pszNamespace ) ;
pInitSink->SetStatus ( WBEM_S_INITIALIZED , 0 ) ;
DebugOut1(
CViewProvServ::sm_debugLog->WriteFileAndLine (
_T(__FILE__),__LINE__,
_T("Returning From CImpPropProv::Initialize () ")
) ;
)
}
catch(Structured_Exception e_SE)
{
return WBEM_E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
return WBEM_E_OUT_OF_MEMORY;
}
catch(...)
{
return WBEM_E_UNEXPECTED;
}
return WBEM_NO_ERROR ;
}
HRESULT STDMETHODCALLTYPE CViewProvServ::OpenNamespace (
const BSTR ObjectPath,
long lFlags,
IWbemContext FAR* pCtx,
IWbemServices FAR* FAR* pNewContext,
IWbemCallResult FAR* FAR* ppErrorObject
)
{
return WBEM_E_NOT_AVAILABLE ;
}
Reference in a new issue Copy permalink