1732 lines
30 KiB
C++
1732 lines
30 KiB
C++
//***************************************************************************
|
|
|
|
//
|
|
|
|
// 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 ;
|
|
}
|