4795 lines
144 KiB
C++
4795 lines
144 KiB
C++
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Microsoft WMIOLE DB Provider
|
|
// (C) Copyright 1999 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// CWBEMWRAP.CPP | CWbem* class implementation. These are classes talking to WMI
|
|
//
|
|
// NTRaid:: 139685 Transaction support removed
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#define _WIN32_DCOM
|
|
|
|
#include "headers.h"
|
|
//#include <wbemprov.h>
|
|
|
|
#define CLASSSEPARATOR L"."
|
|
#define WBEMERROR_QUALIFIER_NOT_FOUND 0x80043000
|
|
#define WBEMERROR_PROPERTY_NOT_FOUND 0x80043001
|
|
#define WBEMERROR_QUALIFER_TOBE_FETCHED 0x80043001
|
|
#define NUMBEROFINSTANCESTOBEFETCHED 50
|
|
#define LOCALESTRING_MAXSIZE 40
|
|
#define SEARCHPREFERENCE_NAMESIZE 128
|
|
|
|
const WCHAR szSelectCountQry[] = L"select __PATH from ";
|
|
const WCHAR szWhereClause[] = L" WHERE __CLASS=\"";
|
|
const WCHAR szDoubleQuotes[] = L"\"";
|
|
const WCHAR szReferenceOfQry[] = L"REFERENCES";
|
|
const WCHAR szAssociatersQry[] = L"ASSOCIATORS";
|
|
const WCHAR szWQL[] = L"WQL";
|
|
const WCHAR szLDAP[] = L"LDAP";
|
|
const WCHAR szLDAPSQL[] = L"SQL";
|
|
const WCHAR szInstance[] = L"WMIInstance";
|
|
const WCHAR szCollection[] = L"Collection";
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL AllocateAndCopy( WCHAR *& pwcsDestination, WCHAR * pwcsSource )
|
|
{
|
|
BOOL fRc = FALSE;
|
|
if( wcslen( pwcsSource ) > 0){
|
|
pwcsDestination = new WCHAR[wcslen(pwcsSource)+2];
|
|
wcscpy(pwcsDestination,pwcsSource);
|
|
fRc = TRUE;
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT MapWbemErrorToOLEDBError(HRESULT hrToMap)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
switch( hrToMap ){
|
|
|
|
case WBEM_S_NO_MORE_DATA:
|
|
hr = WBEM_S_NO_MORE_DATA;
|
|
break;
|
|
|
|
case S_OK:
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case WBEM_E_ACCESS_DENIED :
|
|
hr = DB_SEC_E_PERMISSIONDENIED;
|
|
LogMessage("Access denied to do this operation" , hr);
|
|
break;
|
|
|
|
case WBEM_E_CANNOT_BE_KEY:
|
|
hr = DB_E_ERRORSOCCURRED;
|
|
LogMessage("Error in setting a property as Key" , hr);
|
|
break;
|
|
|
|
case WBEM_E_NOT_FOUND :
|
|
hr = E_UNEXPECTED;
|
|
LogMessage("Object not found" , hr);
|
|
break;
|
|
|
|
case WBEM_E_INVALID_CLASS :
|
|
hr = DB_E_NOTABLE;
|
|
LogMessage("The class specified is not present" , hr);
|
|
break;
|
|
|
|
case WBEMERROR_PROPERTY_NOT_FOUND :
|
|
hr = DB_E_BADCOLUMNID;
|
|
LogMessage("Object not found" , hr);
|
|
break;
|
|
|
|
|
|
case WBEM_E_INVALID_OPERATION :
|
|
hr = DB_E_DROPRESTRICTED;
|
|
LogMessage("Provider not able to drop do the operation as the operation is invalid" , hr);
|
|
break;
|
|
|
|
case WBEMERROR_QUALIFIER_NOT_FOUND :
|
|
hr = DB_E_BADCOLUMNID;
|
|
LogMessage("Qualifier does not exist" , hr);
|
|
break;
|
|
|
|
case WBEM_E_PROPAGATED_PROPERTY :
|
|
hr = DB_E_DROPRESTRICTED;
|
|
LogMessage("Error due to attempt to delete a property that was not owned" , hr);
|
|
break;
|
|
|
|
case WBEM_E_INVALID_NAMESPACE:
|
|
hr = DB_E_ERRORSOCCURRED;
|
|
LogMessage("Invalid Namespace" , hr);
|
|
break;
|
|
|
|
case E_ACCESSDENIED:
|
|
hr = DB_SEC_E_PERMISSIONDENIED;
|
|
LogMessage("Acess Denied" , hr);
|
|
break;
|
|
|
|
case WBEM_E_INVALID_QUERY:
|
|
hr = DB_E_ERRORSINCOMMAND;
|
|
LogMessage("Error in the query string" , hr);
|
|
break;
|
|
|
|
case WBEM_E_PROVIDER_NOT_CAPABLE:
|
|
hr = WBEM_E_PROVIDER_NOT_CAPABLE;
|
|
break;
|
|
|
|
case DB_E_ALREADYINITIALIZED:
|
|
hr = DB_E_ALREADYINITIALIZED;
|
|
break;
|
|
|
|
case WBEM_E_OUT_OF_MEMORY:
|
|
case E_OUTOFMEMORY:
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
|
|
//NTRaid 138547
|
|
case WBEM_E_LOCAL_CREDENTIALS:
|
|
hr = DB_E_ERRORSOCCURRED;
|
|
LogMessage("User Name and password cannot be given for local machine" , hr);
|
|
break;
|
|
|
|
// NTRaid:144995
|
|
case WBEM_E_TRANSPORT_FAILURE:
|
|
case HRESULT_FROM_WIN32(RPC_S_CALL_FAILED_DNE):
|
|
case HRESULT_FROM_WIN32(RPC_S_CALL_FAILED):
|
|
case HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE):
|
|
hr = E_FAIL;
|
|
LogMessage("Connection broken due to RPC failure" , hr);
|
|
break;
|
|
|
|
case WBEM_E_INVALID_QUERY_TYPE:
|
|
hr = DB_E_ERRORSINCOMMAND;
|
|
LogMessage("Invalid Query Type" , hr);
|
|
break;
|
|
|
|
case S_FALSE:
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
default:
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
return hr;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemConnectionWrapper::CWbemConnectionWrapper()
|
|
{
|
|
// HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED);
|
|
// CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_IDENTIFY, NULL, EOAC_NONE, 0 );
|
|
InitVars();
|
|
}
|
|
|
|
HRESULT CWbemConnectionWrapper::FInit(CWbemConnectionWrapper *pWrap , WCHAR *pstrPath,INSTANCELISTTYPE instListType )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
InitVars();
|
|
CBSTR strPath(pstrPath);
|
|
IWbemServicesEx *pSerEx = NULL;
|
|
LONG lFlag = instListType == SCOPE ? WBEM_FLAG_OPEN_SCOPE : WBEM_FLAG_OPEN_COLLECTION;
|
|
// Call the function to initialize the
|
|
hr = m_PrivelagesToken.FInit();
|
|
if(SUCCEEDED(hr) && SUCCEEDED(pWrap->GetServicesPtr()->QueryInterface(IID_IWbemServicesEx,(void **)&pSerEx)))
|
|
{
|
|
if(pstrPath)
|
|
{
|
|
IWbemServicesEx *pCollectionEx = NULL;
|
|
if(SUCCEEDED(hr =pSerEx->Open(strPath,NULL,lFlag,NULL,&pCollectionEx,NULL)))
|
|
{
|
|
if(SUCCEEDED(hr = pCollectionEx->QueryInterface(IID_IWbemServices,(void **)&m_pIWbemServices)))
|
|
{
|
|
m_pDataSourceCon = pWrap;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = pSerEx->QueryInterface(IID_IWbemServices,(void **)&m_pIWbemServices);
|
|
}
|
|
SAFE_RELEASE_PTR(pSerEx);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemConnectionWrapper::~CWbemConnectionWrapper()
|
|
{
|
|
// CoUninitialize();
|
|
SAFE_RELEASE_PTR(m_pIWbemServices);
|
|
SAFE_RELEASE_PTR(m_pCtx);
|
|
if(m_strUser)
|
|
{
|
|
SysFreeString(m_strUser);
|
|
}
|
|
if(m_strPassword)
|
|
{
|
|
SysFreeString(m_strPassword);
|
|
}
|
|
if(m_strLocale)
|
|
{
|
|
SysFreeString(m_strLocale);
|
|
}
|
|
if(m_strAuthority)
|
|
{
|
|
SysFreeString(m_strAuthority);
|
|
}
|
|
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemConnectionWrapper::InitVars()
|
|
{
|
|
m_vNamespace.SetStr(DEFAULT_NAMESPACE);
|
|
|
|
m_pIWbemServices = NULL;
|
|
m_pCtx = NULL;
|
|
m_dwAuthnLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
|
|
m_dwImpLevel = RPC_C_AUTHN_LEVEL_CONNECT;
|
|
m_strUser = NULL;
|
|
m_strPassword = NULL;
|
|
m_strLocale = NULL;
|
|
m_pDataSourceCon = NULL;
|
|
m_strAuthority = NULL;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CWbemConnectionWrapper::ValidConnection()
|
|
{
|
|
BOOL bRet = FALSE;
|
|
if( m_pIWbemServices ){
|
|
bRet = TRUE;
|
|
}
|
|
if( S_OK == GetConnectionToWbem() ){
|
|
bRet = TRUE;
|
|
}
|
|
return bRet;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemConnectionWrapper::SetValidNamespace(VARIANT * v)
|
|
{
|
|
if((V_VT(v) == VT_NULL ) || (V_VT(v) == VT_EMPTY )){
|
|
m_vNamespace.SetStr(DEFAULT_NAMESPACE);
|
|
}
|
|
else{
|
|
m_vNamespace.SetStr(V_BSTR(v));
|
|
}
|
|
}
|
|
|
|
void CWbemConnectionWrapper::SetUserInfo(BSTR strUser,BSTR strPassword,BSTR strAuthority)
|
|
{
|
|
m_strUser = Wmioledb_SysAllocString(strUser);
|
|
m_strPassword = Wmioledb_SysAllocString(strPassword);
|
|
m_strAuthority = Wmioledb_SysAllocString(strAuthority);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::GetConnectionToWbem( void )
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
IWbemLocator *pLoc = 0;
|
|
IWbemServicesEx *pSer = NULL;
|
|
|
|
hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pLoc);
|
|
if(SUCCEEDED(hr )){
|
|
|
|
hr = pLoc->ConnectServer(m_vNamespace,m_strUser, m_strPassword, m_strLocale,0, m_strAuthority, 0, &m_pIWbemServices );
|
|
if( SUCCEEDED(hr)){
|
|
IClientSecurity *pClientSecurity = NULL;
|
|
if(SUCCEEDED(m_pIWbemServices->QueryInterface(IID_IClientSecurity,(void **)&pClientSecurity)))
|
|
{
|
|
hr = CoSetProxyBlanket( m_pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHN_NONE, NULL,
|
|
m_dwAuthnLevel, m_dwImpLevel, NULL, EOAC_NONE );
|
|
pClientSecurity->Release();
|
|
}
|
|
|
|
HRESULT hr1 = m_pIWbemServices->QueryInterface(IID_IWbemServicesEx,(void **)&pSer);
|
|
SAFE_RELEASE_PTR(pSer);
|
|
}
|
|
pLoc->Release();
|
|
}
|
|
if(SUCCEEDED(hr) && !g_pIWbemCtxClassFac)
|
|
{
|
|
CoGetClassObject(CLSID_WbemContext,CLSCTX_INPROC_SERVER,NULL,IID_IClassFactory,(void **)&g_pIWbemCtxClassFac);
|
|
}
|
|
if(hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = WBEM_E_INVALID_NAMESPACE;
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set the conneciton attributes for the connection
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemConnectionWrapper::SetConnAttributes(DWORD dwAuthnLevel , DWORD dwImpLevel)
|
|
{
|
|
m_dwAuthnLevel = dwAuthnLevel;
|
|
m_dwImpLevel = dwImpLevel;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::DeleteClass(BSTR strClassName)
|
|
{
|
|
HRESULT hr = m_pIWbemServices->DeleteClass(strClassName, 0,NULL,NULL);
|
|
if(hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Begin a transaction
|
|
// Removing transaction support as per alanbos mail ( core is removing the support)
|
|
// 06/30/2000
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::BeginTransaction(ULONG uTimeout,ULONG uFlags,GUID *pTransGUID)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
/* IWbemTransaction * pWbemTrans = NULL;
|
|
IWbemServicesEx *pTest = NULL;
|
|
|
|
if(SUCCEEDED(hr = GetServicesPtr()->QueryInterface(IID_IWbemTransaction,(void **)&pWbemTrans)))
|
|
{
|
|
hr = pWbemTrans->Begin(uTimeout,uFlags,pTransGUID);
|
|
}
|
|
|
|
SAFE_RELEASE_PTR(pWbemTrans);
|
|
*/
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Commit/Rollback a transaction
|
|
// Removing transaction support as per alanbos mail ( core is removing the support)
|
|
// 06/30/2000
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::CompleteTransaction(BOOL bRollBack,ULONG uFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
/* IWbemTransaction * pWbemTrans = NULL;
|
|
|
|
if(SUCCEEDED(hr = GetServicesPtr()->QueryInterface(IID_IWbemTransaction,(void **)&pWbemTrans)))
|
|
{
|
|
if(bRollBack)
|
|
{
|
|
hr = pWbemTrans->Rollback(uFlags);
|
|
}
|
|
else
|
|
{
|
|
hr = pWbemTrans->Commit(uFlags);
|
|
}
|
|
}
|
|
|
|
SAFE_RELEASE_PTR(pWbemTrans);
|
|
*/
|
|
return hr;
|
|
}
|
|
|
|
IWbemServices* CWbemConnectionWrapper::GetServicesPtr()
|
|
{
|
|
return m_pIWbemServices;
|
|
}
|
|
|
|
WCHAR * CWbemConnectionWrapper::GetNamespace()
|
|
{
|
|
WCHAR *pNameSpace = NULL;
|
|
if(!m_pDataSourceCon)
|
|
{
|
|
pNameSpace = m_vNamespace.GetStr();
|
|
}
|
|
else
|
|
{
|
|
pNameSpace = m_pDataSourceCon->GetNamespace();
|
|
}
|
|
|
|
return pNameSpace;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set the Locale Identifier
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemConnectionWrapper::SetLocale(LONG lLocaleID)
|
|
{
|
|
WCHAR wstrLocale[LOCALESTRING_MAXSIZE];
|
|
swprintf(wstrLocale,L"MS_%x",lLocaleID);
|
|
m_strLocale = Wmioledb_SysAllocString(wstrLocale);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Create an new namespace and initialize the wrapper
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::CreateNameSpace()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BSTR strNameSpace = NULL;
|
|
BSTR strParentNameSpace = NULL;
|
|
CURLParser urlParser;
|
|
|
|
if(m_pIWbemServices)
|
|
{
|
|
hr = DB_E_ALREADYINITIALIZED;
|
|
}
|
|
else
|
|
{
|
|
VARIANT varTemp;
|
|
VariantInit(&varTemp);
|
|
varTemp.vt = VT_BSTR;
|
|
urlParser.SetPath(m_vNamespace.GetStr());
|
|
if(SUCCEEDED(hr = urlParser.ParseNameSpace(strParentNameSpace,strNameSpace)))
|
|
{
|
|
varTemp.bstrVal = strParentNameSpace;
|
|
SetValidNamespace(&varTemp);
|
|
// connect to the Parent namespace
|
|
if(SUCCEEDED(hr =GetConnectionToWbem()))
|
|
{
|
|
IWbemClassObject *pClass = NULL;
|
|
CBSTR strNamespaceClass(L"__NameSpace");
|
|
|
|
if(SUCCEEDED(hr = m_pIWbemServices->GetObject((BSTR)strNamespaceClass,WBEM_FLAG_RETURN_WBEM_COMPLETE,NULL,&pClass,NULL)))
|
|
{
|
|
// Create the namespace instance and save the object
|
|
// after saving the name
|
|
IWbemClassObject *pNewInstance = NULL;
|
|
if(SUCCEEDED(hr = pClass->SpawnInstance(0,&pNewInstance)))
|
|
{
|
|
varTemp.bstrVal = strNameSpace;
|
|
if(SUCCEEDED(hr = pNewInstance->Put(L"Name",0,&varTemp,CIM_STRING)) &&
|
|
SUCCEEDED(hr = m_pIWbemServices->PutInstance(pNewInstance,WBEM_FLAG_CREATE_ONLY,NULL,NULL)))
|
|
{
|
|
// Open the namespace and replace the IWbemServices pointer to point to new namespcee
|
|
IWbemServices *pTempSer = NULL;
|
|
if(SUCCEEDED(hr = m_pIWbemServices->OpenNamespace(strNameSpace,WBEM_FLAG_RETURN_WBEM_COMPLETE,m_pCtx,&pTempSer,NULL)))
|
|
{
|
|
SAFE_RELEASE_PTR(m_pIWbemServices);
|
|
pTempSer->QueryInterface(IID_IWbemServices,(void **)&m_pIWbemServices);
|
|
SAFE_RELEASE_PTR(pTempSer);
|
|
}
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pNewInstance);
|
|
}
|
|
}
|
|
SysFreeString(strParentNameSpace);
|
|
SysFreeString(strNameSpace);
|
|
urlParser.GetNameSpace(strNameSpace);
|
|
varTemp.bstrVal = strNameSpace;
|
|
|
|
// Set the correct namespace
|
|
SetValidNamespace(&varTemp);
|
|
SysFreeString(strNameSpace);
|
|
|
|
hr = MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
SAFE_DELETE_PTR(m_pIWbemServices);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Delete a namespace
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::DeleteNameSpace()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BSTR strNameSpace = NULL;
|
|
BSTR strParentNameSpace = NULL;
|
|
CURLParser urlParser;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
VARIANT varTemp;
|
|
VariantInit(&varTemp);
|
|
varTemp.vt = VT_BSTR;
|
|
urlParser.SetPath(m_vNamespace.GetStr());
|
|
if(SUCCEEDED(hr = urlParser.ParseNameSpace(strParentNameSpace,strNameSpace)))
|
|
{
|
|
// Store the pointer in temporary variable
|
|
IWbemServices *pSerTemp = NULL;
|
|
m_pIWbemServices->QueryInterface(IID_IWbemServices,(void **)&pSerTemp);
|
|
|
|
SAFE_RELEASE_PTR(m_pIWbemServices);
|
|
|
|
varTemp.bstrVal = strParentNameSpace;
|
|
SetValidNamespace(&varTemp);
|
|
// connect to the Parent namespace
|
|
if(SUCCEEDED(hr =GetConnectionToWbem()))
|
|
{
|
|
WCHAR strNameSpaceObject[PATH_MAXLENGTH];
|
|
wcscpy(strNameSpaceObject,L"");
|
|
swprintf(strNameSpaceObject,L"__NAMESPACE.Name=\"%s\"",strNameSpace);
|
|
|
|
CBSTR strNameSpacePath(strNameSpaceObject);
|
|
|
|
// Delete the namespace instance
|
|
if(FAILED(hr = m_pIWbemServices->DeleteInstance(strNameSpacePath,WBEM_FLAG_RETURN_WBEM_COMPLETE,m_pCtx,NULL)))
|
|
{
|
|
SAFE_RELEASE_PTR(m_pIWbemServices);
|
|
strNameSpacePath.Clear();
|
|
urlParser.GetNameSpace((BSTR &)strNameSpacePath);
|
|
varTemp.bstrVal = (BSTR)strNameSpacePath;
|
|
// Set the correct namespace
|
|
SetValidNamespace(&varTemp);
|
|
pSerTemp->QueryInterface(IID_IWbemServices, (void **)&m_pIWbemServices);
|
|
|
|
}
|
|
else
|
|
{
|
|
SAFE_RELEASE_PTR(m_pIWbemServices);
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pSerTemp);
|
|
SysFreeString(strParentNameSpace);
|
|
SysFreeString(strNameSpace);
|
|
}
|
|
hr = MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Delete a namespace
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::GetObjectAccessRights(BSTR strPath,
|
|
ULONG *pcAccessEntries,
|
|
EXPLICIT_ACCESS_W **prgAccessEntries,
|
|
ULONG ulAccessEntries,
|
|
EXPLICIT_ACCESS_W *pAccessEntries)
|
|
{
|
|
IWbemServicesEx *pSerEx = NULL;
|
|
IWbemRawSdAccessor *pSdAccessor = NULL;
|
|
HRESULT hr = S_OK;
|
|
SECURITY_DESCRIPTOR sd;
|
|
InitializeSecurityDescriptor(&sd,SECURITY_DESCRIPTOR_REVISION);
|
|
|
|
*pcAccessEntries = 0;
|
|
*prgAccessEntries = NULL;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CWbemSecurityDescriptor wbemSD;
|
|
if(SUCCEEDED(hr = wbemSD.Init(m_pIWbemServices,strPath,GetContext())))
|
|
{
|
|
PACL pDacl;
|
|
BOOL bDacl = TRUE;
|
|
BOOL bDefaultDacl = TRUE;
|
|
if(GetSecurityDescriptorDacl(wbemSD.GetSecurityDescriptor(),&bDacl,&pDacl,&bDefaultDacl) && bDacl )
|
|
{
|
|
hr = GetExplicitEntriesFromAclW(pDacl,pcAccessEntries,prgAccessEntries);
|
|
}
|
|
else
|
|
// DACL for SD was null
|
|
if(bDacl == FALSE)
|
|
{
|
|
hr = FALSE;
|
|
}
|
|
}
|
|
else
|
|
if(hr == WBEM_E_NULL_SECURITY_DESCRIPTOR)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Delete a namespace
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemConnectionWrapper::SetObjectAccessRights(BSTR strPath,
|
|
ULONG ulAccessEntries,
|
|
EXPLICIT_ACCESS_W *pAccessEntries)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CWbemSecurityDescriptor wbemSD;
|
|
if(SUCCEEDED(hr = wbemSD.Init(m_pIWbemServices,strPath,GetContext())))
|
|
{
|
|
PACL pDacl;
|
|
BOOL bDacl = TRUE;
|
|
BOOL bDefaultDacl = TRUE;
|
|
// Get the security descriptor DACL for the given Security descriptor
|
|
if(GetSecurityDescriptorDacl(wbemSD.GetSecurityDescriptor(),&bDacl,&pDacl,&bDefaultDacl) && bDacl )
|
|
{
|
|
PACL pNewDacl;
|
|
BOOL bRet = SetEntriesInAclW(ulAccessEntries,pAccessEntries,pDacl,&pNewDacl);
|
|
if(bRet)
|
|
{
|
|
if(SetSecurityDescriptorDacl(wbemSD.GetSecurityDescriptor(),TRUE,pNewDacl,TRUE))
|
|
{
|
|
hr = wbemSD.PutSD();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
// DACL for SD was null
|
|
if(bDacl == FALSE)
|
|
{
|
|
hr = FALSE;
|
|
}
|
|
}
|
|
else
|
|
if(hr == WBEM_E_NULL_SECURITY_DESCRIPTOR)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWbemConnectionWrapper::SetObjectOwner(BSTR strPath,TRUSTEE_W *pOwner)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CWbemSecurityDescriptor wbemSD;
|
|
if(SUCCEEDED(hr = wbemSD.Init(m_pIWbemServices,strPath,GetContext())))
|
|
{
|
|
PSID psid;
|
|
if(!wbemSD.GetSID(pOwner,psid))
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
if(SetSecurityDescriptorOwner(wbemSD.GetSecurityDescriptor(),psid,TRUE))
|
|
{
|
|
// set the Security descriptor for the object
|
|
hr = wbemSD.PutSD();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
}
|
|
else
|
|
if(hr == WBEM_E_NULL_SECURITY_DESCRIPTOR)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWbemConnectionWrapper::GetObjectOwner( BSTR strPath,TRUSTEE_W ** ppOwner)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CWbemSecurityDescriptor wbemSD;
|
|
if(SUCCEEDED(hr = wbemSD.Init(m_pIWbemServices,strPath,GetContext())))
|
|
{
|
|
PSID psid;
|
|
BOOL bOwnerDefaulted = TRUE;
|
|
if(!GetSecurityDescriptorOwner(wbemSD.GetSecurityDescriptor(),&psid,&bOwnerDefaulted))
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
if(psid == NULL)
|
|
{
|
|
hr = SEC_E_NOOWNER;
|
|
}
|
|
else
|
|
BuildTrusteeWithSidW(*ppOwner,psid);
|
|
}
|
|
else
|
|
if(hr == WBEM_E_NULL_SECURITY_DESCRIPTOR)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWbemConnectionWrapper::IsObjectAccessAllowed( BSTR strPath,EXPLICIT_ACCESS_W *pAccessEntry,BOOL *pfResult)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
*pfResult = FALSE;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CWbemSecurityDescriptor wbemSD;
|
|
if(SUCCEEDED(hr = wbemSD.Init(m_pIWbemServices,strPath,GetContext())))
|
|
{
|
|
PACL pDacl;
|
|
BOOL bDacl = TRUE;
|
|
BOOL bDefaultDacl = TRUE;
|
|
ACCESS_MASK AccMask;
|
|
// Get the security descriptor DACL for the given Security descriptor
|
|
if(GetSecurityDescriptorDacl(wbemSD.GetSecurityDescriptor(),&bDacl,&pDacl,&bDefaultDacl) && bDacl )
|
|
{
|
|
// Get the permissions for a particular trustee
|
|
if(ERROR_SUCCESS == (hr = GetEffectiveRightsFromAclW(pDacl,&(pAccessEntry->Trustee),&AccMask)))
|
|
{
|
|
ACCESS_MASK AccMaskTemp;
|
|
AccMaskTemp = AccMask & pAccessEntry->grfAccessPermissions;
|
|
if(AccMaskTemp >= pAccessEntry->grfAccessPermissions)
|
|
{
|
|
*pfResult = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
if(hr == WBEM_E_NULL_SECURITY_DESCRIPTOR)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL CWbemConnectionWrapper::IsValidObject(BSTR strPath)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bRet = FALSE;
|
|
|
|
if(m_pIWbemServices == NULL)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
if(SUCCEEDED(hr = m_pIWbemServices->GetObject(strPath,WBEM_FLAG_RETURN_WBEM_COMPLETE,GetContext(),NULL,NULL)))
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
HRESULT CWbemConnectionWrapper::GetParameters(BSTR strPath,BSTR &strClassName,BSTR *strNameSpace)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
IWbemLocator *pLoc = NULL;
|
|
IWbemServices *pSer = NULL;
|
|
IWbemClassObject *pObject = NULL;
|
|
VARIANT varProp;
|
|
VariantInit(&varProp);
|
|
|
|
|
|
hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pLoc);
|
|
if(SUCCEEDED(hr ))
|
|
{
|
|
|
|
hr = pLoc->ConnectServer(strNameSpace ? *strNameSpace : strPath,
|
|
m_strUser, m_strPassword, m_strLocale,0, m_strAuthority, 0, &pSer);
|
|
|
|
if( SUCCEEDED(hr))
|
|
{
|
|
IClientSecurity *pClientSecurity = NULL;
|
|
|
|
hr = pSer->QueryInterface(IID_IClientSecurity,(void **)&pClientSecurity);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = CoSetProxyBlanket( pSer,RPC_C_AUTHN_WINNT, RPC_C_AUTHN_NONE, NULL,
|
|
m_dwAuthnLevel, m_dwImpLevel, NULL, EOAC_NONE );
|
|
|
|
SAFE_RELEASE_PTR(pClientSecurity);
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
if(strNameSpace)
|
|
{
|
|
hr = pSer->GetObject(strPath,0,NULL,&pObject,NULL);
|
|
}
|
|
else
|
|
{
|
|
hr = pSer->QueryInterface(IID_IWbemClassObject , (void **)&pObject);
|
|
}
|
|
|
|
if(SUCCEEDED(hr) && SUCCEEDED(hr = pObject->Get(L"__CLASS",0,&varProp,NULL,NULL)))
|
|
{
|
|
strClassName = Wmioledb_SysAllocString(varProp.bstrVal);
|
|
VariantClear(&varProp);
|
|
}
|
|
SAFE_RELEASE_PTR(pObject);
|
|
SAFE_RELEASE_PTR(pSer);
|
|
}
|
|
SAFE_RELEASE_PTR(pLoc);
|
|
}
|
|
|
|
if(hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = WBEM_E_INVALID_NAMESPACE;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
// get the class name of the object pointed by the classname
|
|
// NTRaid : 134967
|
|
// 07/12/00
|
|
HRESULT CWbemConnectionWrapper::GetClassName(BSTR strPath,BSTR &strClassName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemClassObject *pObject = NULL;
|
|
|
|
if(SUCCEEDED(hr = m_pIWbemServices->GetObject(strPath,WBEM_FLAG_RETURN_WBEM_COMPLETE,GetContext(),&pObject,NULL)))
|
|
{
|
|
VARIANT varVal;
|
|
VariantInit(&varVal);
|
|
if(SUCCEEDED(hr = pObject->Get(L"__CLASS",0,&varVal,NULL,NULL)))
|
|
{
|
|
strClassName = Wmioledb_SysAllocString(varVal.bstrVal);
|
|
}
|
|
VariantClear(&varVal);
|
|
}
|
|
SAFE_RELEASE_PTR(pObject);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
// 07/12/2000
|
|
// NTRaid : 142348
|
|
// function which executes Action queries
|
|
HRESULT CWbemConnectionWrapper::ExecuteQuery(CQuery *pQuery)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IEnumWbemClassObject *pEnumObject = NULL;
|
|
|
|
CBSTR stQryLanguage(pQuery->GetQueryLang());
|
|
CBSTR strQuery(pQuery->GetQuery());
|
|
|
|
hr = m_pIWbemServices->ExecQuery(stQryLanguage,strQuery,0,GetContext(),&pEnumObject);
|
|
SAFE_RELEASE_PTR(pEnumObject);
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
// function which gets the pointer to the the object for which it is pointing
|
|
// If the connection doesn not point to object then this returns the namespace
|
|
|
|
HRESULT CWbemConnectionWrapper::GetNodeName(BSTR &strNode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemClassObject *pObject = NULL;
|
|
if(SUCCEEDED(hr = m_pIWbemServices->QueryInterface(IID_IWbemClassObject,(void **)&pObject)))
|
|
{
|
|
VARIANT var;
|
|
VariantInit(&var);
|
|
if(FAILED(hr = pObject->Get(L"__URL",0,&var,NULL,NULL)))
|
|
{
|
|
hr = pObject->Get(L"__PATH",0,&var,NULL,NULL);
|
|
}
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
strNode = Wmioledb_SysAllocString(var.bstrVal);
|
|
}
|
|
SAFE_RELEASE_PTR(pObject);
|
|
VariantClear(&var);
|
|
}
|
|
else
|
|
{
|
|
strNode = Wmioledb_SysAllocString(GetNamespace());
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*********************************************************************************************************************
|
|
//
|
|
// CWbemClassParameters
|
|
//
|
|
//*********************************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassParameters::CWbemClassParameters(DWORD dwFlags,WCHAR * pClassName,CWbemConnectionWrapper * pWrap )
|
|
{
|
|
m_dwNavFlags = 0;
|
|
m_dwFlags = dwFlags;
|
|
m_dwQueryFlags = WBEM_FLAG_SHALLOW;
|
|
m_pConnection = pWrap;
|
|
m_pwcsClassName = NULL;
|
|
m_bSystemProperties = FALSE;
|
|
m_pwcsClassName = NULL;
|
|
m_pwcsParentClassName = NULL;
|
|
m_pIContext = NULL;
|
|
}
|
|
|
|
/*
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassParameters::CWbemClassParameters(DWORD dwFlags,IDispatch *pDisp,CWbemConnectionWrapper * pWrap )
|
|
{
|
|
m_dwNavFlags = 0;
|
|
m_dwFlags = dwFlags;
|
|
m_pConnection = pWrap;
|
|
m_pwcsClassName = NULL;
|
|
m_bSystemProperties = FALSE;
|
|
|
|
m_pwcsParentClassName = NULL;
|
|
// GetClassNameForWbemObject(pDisp);
|
|
}
|
|
|
|
*/
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassParameters::~CWbemClassParameters()
|
|
{
|
|
DeleteClassName();
|
|
SAFE_RELEASE_PTR(m_pIContext);
|
|
SAFE_DELETE_ARRAY(m_pwcsClassName);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get the class name and copy it to the member variable from
|
|
// the instance pointed by the IDispatch pointer
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::GetClassNameForWbemObject(IWbemClassObject *pInstance )
|
|
{
|
|
HRESULT hr = 0;
|
|
BSTR strClassPropName;
|
|
VARIANT varClassName;
|
|
|
|
VariantInit(&varClassName);
|
|
|
|
strClassPropName = Wmioledb_SysAllocString(L"__CLASS");
|
|
|
|
hr = pInstance->Get(strClassPropName,0,&varClassName,NULL, NULL);
|
|
|
|
if( hr == S_OK )
|
|
{
|
|
SAFE_DELETE_ARRAY(m_pwcsClassName)
|
|
m_pwcsClassName = new WCHAR[SysStringLen(varClassName.bstrVal)];
|
|
wcscpy(m_pwcsClassName,(WCHAR *)varClassName.bstrVal);
|
|
}
|
|
|
|
VariantClear(&varClassName);
|
|
SysFreeString(strClassPropName);
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// function to set the enumerator flags
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemClassParameters::SetEnumeratorFlags(DWORD dwFlags)
|
|
{
|
|
m_dwNavFlags |= dwFlags;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// function to set the enumerator flags
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemClassParameters::SetQueryFlags(DWORD dwFlags)
|
|
{
|
|
m_dwQueryFlags = dwFlags;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// function which seperates class name and its
|
|
// parent classname if present in the name
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::ParseClassName()
|
|
{
|
|
WCHAR *pTemp = NULL;
|
|
pTemp = wcsstr(m_pwcsClassName,CLASSSEPARATOR);
|
|
HRESULT hr = S_OK;
|
|
|
|
if(pTemp != NULL)
|
|
{
|
|
m_pwcsParentClassName = new WCHAR[pTemp - m_pwcsClassName + 1];
|
|
//NTRaid:111763 & NTRaid:111764
|
|
// 06/07/00
|
|
if(m_pwcsParentClassName)
|
|
{
|
|
memset(m_pwcsParentClassName , 0,(pTemp - m_pwcsClassName + 1) * sizeof(WCHAR));
|
|
memcpy(m_pwcsParentClassName,m_pwcsClassName,(pTemp - m_pwcsClassName) * sizeof(WCHAR));
|
|
|
|
pTemp += wcslen(CLASSSEPARATOR);
|
|
|
|
wcscpy(m_pwcsClassName,pTemp);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
m_pwcsParentClassName = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get class Name
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWbemClassParameters::GetClassName()
|
|
{
|
|
return m_pwcsClassName;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to remove an object from a container
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::RemoveObjectFromContainer(BSTR strContainerObj,BSTR strObject)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemServicesEx * pServicesEx = NULL;
|
|
IWbemServicesEx * pContainerServicesEx = NULL;
|
|
|
|
if(SUCCEEDED(hr = GetServicesPtr()->QueryInterface(IID_IWbemServicesEx,(void **)&pServicesEx)))
|
|
{
|
|
if(SUCCEEDED(hr =pServicesEx->Open(strContainerObj,NULL,WBEM_FLAG_OPEN_COLLECTION,NULL,&pContainerServicesEx,NULL)))
|
|
{
|
|
hr = pContainerServicesEx->Remove(strObject,0,NULL,NULL);
|
|
SAFE_RELEASE_PTR(pContainerServicesEx);
|
|
}
|
|
SAFE_RELEASE_PTR(pServicesEx);
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to add an object to a container
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::AddObjectFromContainer(BSTR strContainerObj,BSTR strObject)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemServicesEx * pServicesEx = NULL;
|
|
IWbemServicesEx * pContainerServicesEx = NULL;
|
|
|
|
if(SUCCEEDED(hr = GetServicesPtr()->QueryInterface(IID_IWbemServicesEx,(void **)&pServicesEx)))
|
|
{
|
|
if(SUCCEEDED(hr =pServicesEx->Open(strContainerObj,NULL,WBEM_FLAG_OPEN_COLLECTION,NULL,&pContainerServicesEx,NULL)))
|
|
{
|
|
hr = pContainerServicesEx->Add(strObject,0,NULL,NULL);
|
|
SAFE_RELEASE_PTR(pContainerServicesEx);
|
|
}
|
|
SAFE_RELEASE_PTR(pServicesEx);
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to clone an object from one scope to another
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::CloneAndAddNewObjectInScope(CWbemClassWrapper *pClass,BSTR strObj,WCHAR *& pstrNewPath)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemServicesEx * pServicesEx = NULL;
|
|
IWbemServicesEx * pContainerServicesEx = NULL;
|
|
IWbemClassObject* pNewObject = NULL;
|
|
|
|
if(SUCCEEDED( hr = ((CWbemClassInstanceWrapper *)pClass)->CloneInstance(pNewObject)))
|
|
{
|
|
if(SUCCEEDED(hr = GetServicesPtr()->QueryInterface(IID_IWbemServicesEx,(void **)&pServicesEx)))
|
|
{
|
|
// Open object as scope
|
|
if(SUCCEEDED(hr =pServicesEx->Open(strObj,NULL,WBEM_FLAG_OPEN_SCOPE,NULL,&pContainerServicesEx,NULL)))
|
|
{
|
|
if(SUCCEEDED(hr = pContainerServicesEx->PutInstance(pNewObject,WBEM_FLAG_CREATE_ONLY,GetContext(),NULL)))
|
|
{
|
|
CVARIANT var;
|
|
CBSTR strProp;
|
|
strProp.SetStr(L"__PATH");
|
|
|
|
HRESULT hr = pNewObject->Get(L"__PATH",0,var,NULL,NULL);
|
|
if( hr == S_OK )
|
|
{
|
|
try
|
|
{
|
|
pstrNewPath = new WCHAR[wcslen(var.GetStr()) + 1];
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_ARRAY(pstrNewPath);
|
|
SAFE_RELEASE_PTR(pContainerServicesEx);
|
|
SAFE_RELEASE_PTR(pServicesEx);
|
|
SAFE_RELEASE_PTR(pNewObject);
|
|
throw;
|
|
}
|
|
if(pstrNewPath)
|
|
{
|
|
wcscpy(pstrNewPath,var.GetStr());
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pContainerServicesEx);
|
|
}
|
|
SAFE_RELEASE_PTR(pServicesEx);
|
|
}
|
|
SAFE_RELEASE_PTR(pNewObject);
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set the search preferences for DS provider
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassParameters::SetSearchPreferences(ULONG cProps , DBPROP rgProp[])
|
|
{
|
|
HRESULT hr = S_OK;
|
|
UINT nStrId = 0;
|
|
WCHAR wcsPreferenceName[SEARCHPREFERENCE_NAMESIZE];
|
|
VARIANT varValue;
|
|
|
|
memset(wcsPreferenceName,0,SEARCHPREFERENCE_NAMESIZE * sizeof(WCHAR));
|
|
VariantInit(&varValue);
|
|
|
|
for(ULONG i = 0 ; i < cProps ; i++)
|
|
{
|
|
nStrId = 0;
|
|
if(!m_pIContext)
|
|
{
|
|
hr = g_pIWbemCtxClassFac->CreateInstance(NULL,IID_IWbemContext,(void **)&m_pIContext);
|
|
}
|
|
else
|
|
{
|
|
m_pIContext->DeleteAll();
|
|
}
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
switch(rgProp[i].dwPropertyID)
|
|
{
|
|
case DBPROP_WMIOLEDB_DS_DEREFALIAS :
|
|
nStrId = IDS_DS_DEREFALIAS;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_SIZELIMIT :
|
|
nStrId = IDS_DS_SIZELIMIT;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_PAGEDTIMELIMIT:
|
|
nStrId = IDS_DS_PAGEDTIMELIMIT;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_ASYNCH:
|
|
nStrId = IDS_DS_ASYNC;
|
|
varValue.vt = VT_BOOL;
|
|
varValue.lVal = rgProp[i].vValue.boolVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_ATTRIBONLY:
|
|
nStrId = IDS_DS_ATTRIBONLY;
|
|
varValue.vt = VT_BOOL;
|
|
varValue.lVal = rgProp[i].vValue.boolVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_TOMBSTONE:
|
|
nStrId = IDS_DS_TOMBSTONE;
|
|
varValue.vt = VT_BOOL;
|
|
varValue.lVal = rgProp[i].vValue.boolVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_SEARCHSCOPE:
|
|
nStrId = IDS_DS_SEARCHSCOPE;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_TIMEOUT:
|
|
nStrId = IDS_DS_TIMEOUT;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_PAGESIZE:
|
|
nStrId = IDS_DS_PAGESIZE;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_TIMELIMIT:
|
|
nStrId = IDS_DS_TIMELIMIT;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_CHASEREF:
|
|
nStrId = IDS_DS_CHASEREF;
|
|
varValue.vt = VT_I4;
|
|
varValue.lVal = rgProp[i].vValue.lVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_FILTER:
|
|
nStrId = IDS_DS_FILTER;
|
|
varValue.vt = VT_BSTR;
|
|
varValue.bstrVal = rgProp[i].vValue.bstrVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_ATTRIBUTES:
|
|
nStrId = IDS_DS_ATTRIBUTES;
|
|
varValue.vt = VT_BSTR;
|
|
varValue.bstrVal = rgProp[i].vValue.bstrVal;
|
|
break;
|
|
|
|
case DBPROP_WMIOLEDB_DS_CACHERESULTS:
|
|
nStrId = IDS_DS_CACHERESULTS;
|
|
varValue.vt = VT_BOOL;
|
|
varValue.lVal = rgProp[i].vValue.boolVal;
|
|
break;
|
|
|
|
}
|
|
}
|
|
WMIOledb_LoadStringW(nStrId,wcsPreferenceName,SEARCHPREFERENCE_NAMESIZE * sizeof(WCHAR));
|
|
m_pIContext->SetValue(wcsPreferenceName,0,&varValue);
|
|
VariantClear(&varValue);
|
|
wcscpy(wcsPreferenceName,L"");
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//************************************************************************************************
|
|
//
|
|
// Common base class functions in dealing with a class definition or an instance
|
|
//
|
|
//************************************************************************************************
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassWrapper::CWbemClassWrapper( CWbemClassParameters * p )
|
|
{
|
|
m_pParms = p;
|
|
m_pClass = NULL;
|
|
m_pIWbemClassQualifierSet = NULL;
|
|
m_pIWbemPropertyQualifierSet = NULL;
|
|
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassWrapper::~CWbemClassWrapper( )
|
|
{
|
|
m_pPropQualifList.RemoveAll();
|
|
|
|
if( m_pIWbemClassQualifierSet != NULL)
|
|
{
|
|
m_pIWbemClassQualifierSet->EndEnumeration();
|
|
}
|
|
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
SAFE_RELEASE_PTR(m_pIWbemClassQualifierSet);
|
|
SAFE_RELEASE_PTR(m_pIWbemPropertyQualifierSet);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// funciton to check if the pointer to IWbemQualiferSet for property qualifer is valid
|
|
// If not then it will get the pointer to it
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::IsValidPropertyQualifier(BSTR strProperty)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemQualifierSet *pQualifierSet = NULL;
|
|
|
|
if(NULL == m_pPropQualifList.GetPropertyQualifierSet(strProperty))
|
|
{
|
|
if(S_OK ==(hr = m_pClass->GetPropertyQualifierSet(strProperty, &pQualifierSet)))
|
|
{
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
hr = m_pPropQualifList.Add(pQualifierSet,strProperty);
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// funciton to check if the pointer to IWbemQualiferSet for class qualifer is valid
|
|
// If not then it will get the pointer to it and starts the enumeration on the qualiferset
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::IsValidClassQualifier()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pIWbemClassQualifierSet)
|
|
{
|
|
if(S_OK == (hr = m_pClass->GetQualifierSet(&m_pIWbemClassQualifierSet)))
|
|
hr = m_pIWbemClassQualifierSet->BeginEnumeration(0);
|
|
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::GetPropertyQualifier(BSTR pPropertyQualifier, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
|
|
{
|
|
HRESULT hr;
|
|
// if( S_OK == (hr = IsValidPropertyQualifier(pPropertyQualifier)))
|
|
{
|
|
hr = m_pIWbemPropertyQualifierSet->Get(pPropertyQualifier,0, vValue, plFlavor);
|
|
//hr = m_pPropQualifList.GetPropertyQualifierSet(pPropertyQualifier)->Get(pPropertyQualifier,0, vValue, plFlavor);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::ValidClass( )
|
|
{
|
|
CBSTR bstrClassName(m_pParms->m_pwcsClassName);
|
|
IWbemClassObject *pClass = NULL;
|
|
HRESULT hr = 0;
|
|
|
|
//==========================================================
|
|
// NOTE: This is simply a utility class, we MUST have
|
|
// a valid pointer set when this class is constructed
|
|
//==========================================================
|
|
if( m_pClass == NULL ){
|
|
|
|
hr = m_pParms->GetServicesPtr()->GetObject(bstrClassName, 0, NULL, &pClass, NULL);
|
|
if( hr == WBEM_E_NOT_FOUND || hr == WBEM_E_INVALID_OBJECT_PATH)
|
|
return DB_E_NOTABLE;
|
|
else
|
|
if( hr == S_OK)
|
|
pClass->Release();
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
return S_OK;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::SetProperty(BSTR pProperty, VARIANT * vValue,CIMTYPE lType )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if(lType == -1)
|
|
{
|
|
hr = m_pClass->Put(pProperty,0, vValue,NULL);
|
|
}
|
|
else
|
|
{
|
|
hr = m_pClass->Put(pProperty,0, vValue,lType);
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::SetPropertyQualifier(BSTR pProperty, BSTR Qualifier, VARIANT * vValue, LONG lQualifierFlags )
|
|
{
|
|
HRESULT hr;
|
|
|
|
//==============================================================
|
|
// If coming thru here the first time, get the qualifier set
|
|
// otherwise, just use it
|
|
//==============================================================
|
|
// hr = m_pClass->GetPropertyQualifierSet(pProperty, &m_pIWbemPropertyQualifierSet);
|
|
if( S_OK == (hr = IsValidPropertyQualifier(pProperty)))
|
|
{
|
|
hr = m_pPropQualifList.GetPropertyQualifierSet(pProperty)->Put(Qualifier, vValue, lQualifierFlags);
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::DeletePropertyQualifier(BSTR pProperty, BSTR Qualifier )
|
|
{
|
|
HRESULT hr;
|
|
|
|
//==============================================================
|
|
// If coming thru here the first time, get the qualifier set
|
|
// otherwise, just use it
|
|
//==============================================================
|
|
// hr = m_pClass->GetPropertyQualifierSet(pProperty, &m_pIWbemPropertyQualifierSet);
|
|
if( S_OK == (hr = IsValidPropertyQualifier(pProperty)))
|
|
{
|
|
hr = m_pPropQualifList.GetPropertyQualifierSet(pProperty)->Delete(Qualifier);
|
|
}
|
|
|
|
if(hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = WBEMERROR_QUALIFIER_NOT_FOUND;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::BeginPropertyEnumeration()
|
|
{
|
|
LONG lFlags = (m_pParms->m_bSystemProperties == TRUE)? 0 : WBEM_FLAG_NONSYSTEM_ONLY;
|
|
HRESULT hr = m_pClass->BeginEnumeration(lFlags);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::EndPropertyEnumeration()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
m_pClass->EndEnumeration();
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::TotalPropertiesInClass(ULONG & ulPropCount, ULONG & ulSysPropCount)
|
|
{
|
|
HRESULT hr;
|
|
ulPropCount = 0L;
|
|
ulSysPropCount = 0;
|
|
LONG lFlavour = 0;
|
|
|
|
if( S_OK == (hr = BeginPropertyEnumeration())){
|
|
|
|
while( S_OK == (hr = GetNextProperty(NULL,NULL,NULL,&lFlavour))){
|
|
// If the property is system property increment the systemproperty count
|
|
if(lFlavour == WBEM_FLAVOR_ORIGIN_SYSTEM)
|
|
ulSysPropCount++;
|
|
else
|
|
ulPropCount ++;
|
|
|
|
}
|
|
|
|
if ( WBEM_S_NO_MORE_DATA == hr ){
|
|
hr = S_OK;
|
|
}
|
|
EndPropertyEnumeration();
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
|
|
{
|
|
HRESULT hr;
|
|
if( !pProperty ){
|
|
hr = m_pClass->Next(0,NULL,NULL,pType,plFlavor);
|
|
}
|
|
else{
|
|
hr = m_pClass->Next(0,pProperty, vValue, pType, plFlavor);
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::GetProperty(BSTR pProperty, VARIANT * var,CIMTYPE * pType , LONG * plFlavor )
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = m_pClass->Get(pProperty,0,var,pType,plFlavor);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::DeleteProperty(BSTR pProperty )
|
|
{
|
|
HRESULT hr;
|
|
hr = m_pClass->Delete(pProperty);
|
|
|
|
if( hr == WBEM_E_NOT_FOUND)
|
|
hr = WBEMERROR_PROPERTY_NOT_FOUND;
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get the number of qualifer for a property
|
|
HRESULT CWbemClassWrapper::TotalPropertyQualifier(BSTR strPropName , ULONG & ulCount )
|
|
{
|
|
HRESULT hr;
|
|
ulCount = 0L;
|
|
|
|
if( S_OK == (hr = BeginPropertyQualifierEnumeration(strPropName)))
|
|
{
|
|
while( S_OK == (hr = m_pIWbemPropertyQualifierSet->Next(0,NULL,NULL,NULL)))
|
|
{
|
|
ulCount ++;
|
|
}
|
|
|
|
if ( WBEM_S_NO_MORE_DATA == hr ){
|
|
hr = S_OK;
|
|
}
|
|
EndPropertyQualifierEnumeration();
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Get the property qualifier and begin the enumeration
|
|
HRESULT CWbemClassWrapper::BeginPropertyQualifierEnumeration(BSTR strPropName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
//Release the previous quality Qualifier
|
|
if(m_pIWbemPropertyQualifierSet)
|
|
{
|
|
m_pIWbemPropertyQualifierSet->Release();
|
|
m_pIWbemPropertyQualifierSet = NULL;
|
|
}
|
|
|
|
if( S_OK == (hr = m_pClass->GetPropertyQualifierSet(strPropName,&m_pIWbemPropertyQualifierSet)))
|
|
hr = m_pIWbemPropertyQualifierSet->BeginEnumeration(0);
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
HRESULT CWbemClassWrapper::GetPropertyQualifier(BSTR pProperty,BSTR PropertyQualifier, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemQualifierSet *pQualiferSet = NULL;
|
|
|
|
if( S_OK == (hr = IsValidPropertyQualifier(pProperty)))
|
|
{
|
|
pQualiferSet = m_pPropQualifList.GetPropertyQualifierSet(pProperty);
|
|
hr = pQualiferSet->Get(PropertyQualifier, 0,vValue, plFlavor);
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Get the property qualifier and begin the enumeration
|
|
HRESULT CWbemClassWrapper::GetNextPropertyQualifier(BSTR pProperty, BSTR * pPropertyQualifier, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemQualifierSet * pQualiferSet = NULL;
|
|
WCHAR * pStrQualiferTemp = NULL;
|
|
DBROWOFFSET lRelativePos = 1;
|
|
|
|
if( S_OK == (hr = IsValidPropertyQualifier(pProperty)))
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_pPropQualifList.GetQualiferPosObject(pProperty)->GetDirFlag() == FALSE)
|
|
lRelativePos = 0;
|
|
|
|
// Check if the qualifer is already fetched
|
|
hr = m_pPropQualifList.GetQualiferPosObject(pProperty)->GetRelative(lRelativePos,pStrQualiferTemp);
|
|
|
|
if( hr == WBEMERROR_QUALIFER_TOBE_FETCHED)
|
|
{
|
|
pQualiferSet = m_pPropQualifList.GetPropertyQualifierSet(pProperty);
|
|
|
|
|
|
if(S_OK ==(hr = pQualiferSet->Next(0,pPropertyQualifier, vValue, plFlavor)))
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
hr = m_pPropQualifList.GetQualiferPosObject(pProperty)->Add(*pPropertyQualifier);
|
|
}
|
|
// If already fetched get the qualifier name from the QualiferPosList
|
|
else
|
|
if( hr = S_OK)
|
|
{
|
|
*pPropertyQualifier = Wmioledb_SysAllocString(pStrQualiferTemp);
|
|
m_pPropQualifList.GetQualiferPosObject(pProperty)->SetRelPos(lRelativePos);
|
|
hr = GetPropertyQualifier(pProperty,*pPropertyQualifier,vValue,pType,plFlavor);
|
|
m_pPropQualifList.GetQualiferPosObject(pProperty)->SetDirFlag(FETCHDIRFORWARD);
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Get the property qualifier
|
|
HRESULT CWbemClassWrapper::GetPrevPropertyQualifier(BSTR pProperty, BSTR * pPropertyQualifier, VARIANT * vValue,CIMTYPE * pType , LONG * plFlavor )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR *pStrQualiferTemp = NULL;
|
|
DBROWOFFSET lRelativePos = -1;
|
|
|
|
if( S_OK == (hr = IsValidPropertyQualifier(pProperty)))
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_pPropQualifList.GetQualiferPosObject(pProperty)->GetDirFlag() == TRUE)
|
|
lRelativePos = 0;
|
|
|
|
// Get the name of the qualifier previous in the list
|
|
hr = m_pPropQualifList.GetQualiferPosObject(pProperty)->GetRelative(lRelativePos,pStrQualiferTemp);
|
|
|
|
if( hr == DB_E_BADSTARTPOSITION)
|
|
{
|
|
hr = DB_S_ENDOFROWSET;
|
|
}
|
|
if(hr == S_OK)
|
|
{
|
|
*pPropertyQualifier = Wmioledb_SysAllocString(pStrQualiferTemp);
|
|
m_pPropQualifList.GetQualiferPosObject(pProperty)->SetRelPos(lRelativePos);
|
|
hr = GetPropertyQualifier(pProperty,*pPropertyQualifier,vValue,pType,plFlavor);
|
|
m_pPropQualifList.GetQualiferPosObject(pProperty)->SetDirFlag(FETCHDIRBACKWARD);
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// End the property qualifer enumeration and release the pointers
|
|
HRESULT CWbemClassWrapper::EndPropertyQualifierEnumeration()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
m_pIWbemPropertyQualifierSet->EndEnumeration();
|
|
m_pIWbemPropertyQualifierSet->Release();
|
|
m_pIWbemPropertyQualifierSet = NULL;
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::SetClass( IWbemClassObject * pPtr)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if( pPtr ){
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
m_pClass = pPtr;
|
|
m_pClass->AddRef();
|
|
hr = S_OK;
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// if strPath parameter is NULL then the object to be obtained is same as the object represented by the
|
|
// connection. THis is because GetObject is not working for absolute UMI paths
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassWrapper * CWbemClassWrapper::GetInstance(BSTR strPath)
|
|
{
|
|
|
|
CWbemClassInstanceWrapper * pInst = NULL;
|
|
HRESULT hr = S_OK;
|
|
IWbemClassObject * pClass = NULL;
|
|
|
|
//============================================================
|
|
// Get the required instance
|
|
//============================================================
|
|
if(strPath == NULL)
|
|
{
|
|
hr = (m_pParms->GetServicesPtr())->QueryInterface(IID_IWbemClassObject,(void **)&pClass);
|
|
}
|
|
else
|
|
{
|
|
hr = (m_pParms->GetServicesPtr())->GetObject(strPath,0,m_pParms->GetContext(),&pClass ,NULL);
|
|
}
|
|
|
|
if( hr == S_OK )
|
|
{
|
|
pInst = new CWbemClassInstanceWrapper(m_pParms);
|
|
//NTRaid:111778
|
|
// 06/07/00
|
|
if(pInst)
|
|
{
|
|
pInst->SetClass(pClass );
|
|
}
|
|
SAFE_RELEASE_PTR(pClass);
|
|
}
|
|
|
|
return (CWbemClassWrapper *)pInst;
|
|
}
|
|
|
|
|
|
// Get the key properties
|
|
HRESULT CWbemClassWrapper::GetKeyPropertyNames( SAFEARRAY **ppsaNames)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = m_pClass->GetNames(NULL,WBEM_FLAG_ALWAYS | WBEM_FLAG_KEYS_ONLY , NULL, ppsaNames);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get a next class/instance qualifer
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::GetNextClassQualifier(BSTR * pClassQualifier, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
WCHAR * pStrQualifierTemp = NULL;
|
|
DBROWOFFSET lRelativePos = 1;
|
|
|
|
if( S_OK == (hr = IsValidClassQualifier()))
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_QualifierPos.GetDirFlag() == FALSE)
|
|
lRelativePos = 0;
|
|
|
|
// Check if the qualifer is already fetched
|
|
hr = m_QualifierPos.GetRelative(lRelativePos,pStrQualifierTemp);
|
|
|
|
if( hr == WBEMERROR_QUALIFER_TOBE_FETCHED)
|
|
{
|
|
|
|
if(S_OK ==( hr = m_pIWbemClassQualifierSet->Next(0,pClassQualifier, vValue, plFlavor)))
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
hr = m_QualifierPos.Add(*pClassQualifier);
|
|
}
|
|
else
|
|
if( hr == S_OK)
|
|
{
|
|
*pClassQualifier = Wmioledb_SysAllocString(pStrQualifierTemp);
|
|
m_QualifierPos.SetRelPos(lRelativePos);
|
|
hr = GetClassQualifier(*pClassQualifier,vValue,pType,plFlavor);
|
|
m_QualifierPos.SetDirFlag(FETCHDIRFORWARD);
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Get the property qualifier and begin the enumeration
|
|
HRESULT CWbemClassWrapper::GetPrevClassQualifier(BSTR * pClassQualifier, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR * pStrQualiferTemp = NULL;
|
|
DBROWOFFSET lRelativePos = 1;
|
|
|
|
if( S_OK == (hr = IsValidClassQualifier()))
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_QualifierPos.GetDirFlag() == TRUE)
|
|
lRelativePos = 0;
|
|
|
|
// Get the name of the qualifier previous in the list
|
|
hr = m_QualifierPos.GetRelative(lRelativePos,pStrQualiferTemp);
|
|
|
|
if( hr == DB_E_BADSTARTPOSITION)
|
|
{
|
|
hr = DB_S_ENDOFROWSET;
|
|
}
|
|
if(hr == S_OK)
|
|
{
|
|
*pClassQualifier = Wmioledb_SysAllocString(pStrQualiferTemp);
|
|
m_QualifierPos.SetRelPos(lRelativePos);
|
|
hr = GetClassQualifier(*pClassQualifier,vValue,pType,plFlavor);
|
|
m_QualifierPos.SetDirFlag(FETCHDIRBACKWARD);
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get a particular class/instance qualifer
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::GetClassQualifier(BSTR ClassQualifier, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
HRESULT hr;
|
|
if( S_OK == (hr = IsValidClassQualifier()))
|
|
{
|
|
hr = m_pIWbemClassQualifierSet->Get(ClassQualifier,0, vValue, plFlavor);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWbemClassWrapper::ReleaseClassQualifier()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if(m_pIWbemClassQualifierSet != NULL)
|
|
{
|
|
m_pIWbemClassQualifierSet->EndEnumeration();
|
|
m_pIWbemClassQualifierSet->Release();
|
|
m_pIWbemClassQualifierSet = NULL;
|
|
m_QualifierPos.RemoveAll();
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
void CWbemClassWrapper::ReleasePropertyQualifier(BSTR strQualifier)
|
|
{
|
|
m_pPropQualifList.Remove(strQualifier);
|
|
|
|
}
|
|
|
|
|
|
// If qualifername parameter is null, then the class qualifer has
|
|
// to be positioned
|
|
HRESULT CWbemClassWrapper::SetQualifierRelPos(DBROWOFFSET lRelPos ,BSTR strPropertyName)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
BSTR strQualifier;
|
|
|
|
if(strPropertyName != NULL)
|
|
{
|
|
if( S_OK == (hr = IsValidPropertyQualifier(strPropertyName)))
|
|
{
|
|
hr = m_pPropQualifList.GetQualiferPosObject(strPropertyName)->SetRelPos(lRelPos);
|
|
if(hr == WBEMERROR_QUALIFER_TOBE_FETCHED)
|
|
{
|
|
do
|
|
{
|
|
if(S_OK != (hr =m_pPropQualifList.GetPropertyQualifierSet(strPropertyName)->Next(0,&strQualifier, NULL, NULL)))
|
|
break;
|
|
else
|
|
{
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
if(FAILED(hr = m_pPropQualifList.GetQualiferPosObject(strPropertyName)->Add(strQualifier)))
|
|
{
|
|
SAFE_FREE_SYSSTRING(strQualifier);
|
|
break;
|
|
}
|
|
SAFE_FREE_SYSSTRING(strQualifier);
|
|
lRelPos--;
|
|
}
|
|
}while(hr == WBEMERROR_QUALIFER_TOBE_FETCHED || lRelPos != 0);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if( S_OK == (hr = IsValidClassQualifier()))
|
|
{
|
|
hr = m_QualifierPos.SetRelPos(lRelPos);
|
|
if(hr == WBEMERROR_QUALIFER_TOBE_FETCHED)
|
|
{
|
|
do
|
|
{
|
|
if(S_OK != (hr =m_pIWbemClassQualifierSet->Next(0,&strQualifier, NULL, NULL)))
|
|
break;
|
|
else
|
|
{
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
if(FAILED(hr = m_QualifierPos.Add(strQualifier)))
|
|
{
|
|
break;
|
|
SAFE_FREE_SYSSTRING(strQualifier);
|
|
}
|
|
lRelPos--;
|
|
SAFE_FREE_SYSSTRING(strQualifier);
|
|
}
|
|
}while(hr == WBEMERROR_QUALIFER_TOBE_FETCHED || lRelPos != 0);
|
|
}
|
|
}
|
|
|
|
if( hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = DB_E_BADSTARTPOSITION;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassWrapper::SetClassQualifier(BSTR Qualifier, VARIANT * vValue, LONG lQualifierFlags )
|
|
{
|
|
|
|
HRESULT hr;
|
|
//==============================================================
|
|
// call this function to get the qualifer set if not obtained
|
|
//==============================================================
|
|
hr = IsValidClassQualifier();
|
|
if ( SUCCEEDED(hr) ){
|
|
hr = m_pIWbemClassQualifierSet->Put(Qualifier, vValue, lQualifierFlags);
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//************************************************************************************************
|
|
//
|
|
// Deal with a class definition
|
|
//
|
|
//************************************************************************************************
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassDefinitionWrapper::CWbemClassDefinitionWrapper( CWbemClassParameters * p,BOOL bGetClass ): CWbemClassWrapper(p)
|
|
{ m_bSchema = FALSE;
|
|
if(bGetClass)
|
|
{
|
|
GetClass();
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassDefinitionWrapper::~CWbemClassDefinitionWrapper( )
|
|
{
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::GetEmptyWbemClass( )
|
|
{
|
|
HRESULT hr;
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
hr = m_pParms->GetServicesPtr()->GetObject( NULL, 0, NULL, &m_pClass, NULL);
|
|
if( hr == S_OK ){
|
|
m_pClass->AddRef();
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::DeleteClass()
|
|
{
|
|
HRESULT hr = m_pParms->GetServicesPtr()->DeleteClass(m_pParms->m_pwcsClassName, WBEM_FLAG_RETURN_IMMEDIATELY,NULL,NULL);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::GetClass( )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
|
|
if(m_pParms->m_pwcsClassName != NULL)
|
|
{
|
|
CBSTR bstrClassName(m_pParms->m_pwcsClassName);
|
|
hr = m_pParms->GetServicesPtr()->GetObject(bstrClassName, 0, NULL, &m_pClass, NULL);
|
|
if( hr == S_OK ){
|
|
m_pClass->AddRef();
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::CreateClass()
|
|
{
|
|
HRESULT hr;
|
|
|
|
CBSTR bstrName(L"__Class");
|
|
CBSTR bstrClassName,bstrSuperClassName;
|
|
CVARIANT NameVal;
|
|
IWbemClassObject *pNewClass = NULL;
|
|
|
|
// Parse the class name if it contains the parent class name from which
|
|
// it is to be derived from
|
|
//NTRaid:111763 & NTRaid:111764
|
|
// 06/07/00
|
|
if( S_OK == (hr = m_pParms->ParseClassName()))
|
|
{
|
|
bstrClassName.SetStr(m_pParms->GetClassName());
|
|
bstrSuperClassName.SetStr( m_pParms->GetSuperClassName());
|
|
NameVal.SetStr(bstrClassName);
|
|
|
|
if( S_OK == (hr = m_pParms->GetServicesPtr()->GetObject(bstrSuperClassName, 0, NULL, &pNewClass, NULL)))
|
|
{
|
|
if(m_pParms->GetSuperClassName() != NULL)
|
|
hr = pNewClass->SpawnDerivedClass(0, &m_pClass);
|
|
else
|
|
hr = pNewClass->QueryInterface(IID_IWbemClassObject, (void **)&m_pClass);
|
|
|
|
SAFE_RELEASE_PTR(pNewClass);
|
|
|
|
// Set the name of the class
|
|
hr = m_pClass->Put((BSTR)bstrName, 0, &NameVal, CIM_STRING);
|
|
}
|
|
|
|
if( hr == WBEM_E_NOT_FOUND)
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::DeleteClassQualifier(BSTR Qualifier)
|
|
{
|
|
|
|
HRESULT hr;
|
|
//==============================================================
|
|
// call this function to get the qualifer set if not obtained
|
|
//==============================================================
|
|
hr = IsValidClassQualifier();
|
|
if ( SUCCEEDED(hr) ){
|
|
hr = m_pIWbemClassQualifierSet->Delete(Qualifier);
|
|
}
|
|
|
|
if( hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
hr = WBEMERROR_QUALIFIER_NOT_FOUND;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method to change the class name to which the classdefination class points to
|
|
// NOTE:This method is to be called before fetching any instance
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::SetClass( WCHAR *pClassName)
|
|
{
|
|
if(m_pParms->m_pwcsClassName != NULL)
|
|
delete [] m_pParms->m_pwcsClassName;
|
|
|
|
m_pParms->m_pwcsClassName = new WCHAR[wcslen(pClassName)+2];
|
|
wcscpy(m_pParms->m_pwcsClassName,pClassName);
|
|
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
|
|
HRESULT hr = S_OK;
|
|
CBSTR bstrClassName(m_pParms->m_pwcsClassName);
|
|
|
|
hr = m_pParms->GetServicesPtr()->GetObject(bstrClassName, 0, NULL, &m_pClass, NULL);
|
|
if( hr == S_OK ){
|
|
m_pClass->AddRef();
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method to save the the class defination into WMI
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::SaveClass(BOOL bNewClass)
|
|
{
|
|
LONG lFlag = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
if(bNewClass == TRUE)
|
|
lFlag = WBEM_FLAG_CREATE_ONLY;
|
|
else
|
|
lFlag = WBEM_FLAG_UPDATE_ONLY;
|
|
|
|
hr = m_pParms->GetServicesPtr()->PutClass(m_pClass,lFlag,NULL,NULL);
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Method to get the number of instances of a class
|
|
// This function executes a query "select __path from class" , so that time is reduced in
|
|
// getting the count
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassDefinitionWrapper::GetInstanceCount(ULONG_PTR &cInstance)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
cInstance = -1;
|
|
IEnumWbemClassObject *pEnum = NULL;
|
|
LONG_PTR lObjectsReturned = 0;
|
|
LONG_PTR lInstance = 0;
|
|
BSTR strWQL,strQry;
|
|
int nBuffSize = 0;
|
|
|
|
|
|
if(ValidClass() == S_OK)
|
|
{
|
|
nBuffSize = wcslen(szSelectCountQry) + wcslen(GetClassName()) + 1;
|
|
// If the query is not deep then add the where clause for the query
|
|
// to get just the instances of the class
|
|
if(WBEM_FLAG_DEEP != m_pParms->m_dwQueryFlags)
|
|
{
|
|
nBuffSize = nBuffSize + wcslen(szWhereClause) + wcslen(GetClassName()) + wcslen(szDoubleQuotes);
|
|
}
|
|
|
|
WCHAR *szCountQry = new WCHAR[nBuffSize];
|
|
//NTRaid:111773
|
|
// 06/07/00
|
|
if(szCountQry)
|
|
{
|
|
strWQL = Wmioledb_SysAllocString(szWQL);
|
|
|
|
// frame the query
|
|
wcscpy(szCountQry , szSelectCountQry);
|
|
wcscat(szCountQry , GetClassName());
|
|
// If the query is not deep then add the where clause for the query
|
|
// to get just the instances of the class
|
|
if(WBEM_FLAG_DEEP != m_pParms->m_dwQueryFlags)
|
|
{
|
|
wcscat(szCountQry,szWhereClause);
|
|
wcscat(szCountQry,GetClassName());
|
|
wcscat(szCountQry,szDoubleQuotes);
|
|
}
|
|
|
|
strQry = Wmioledb_SysAllocString(szCountQry);
|
|
// free the memory
|
|
delete [] szCountQry;
|
|
|
|
// Execute the query just to get the __Path property of the instances
|
|
hr = m_pParms->GetServicesPtr()->ExecQuery(strWQL, strQry,WBEM_FLAG_FORWARD_ONLY , m_pParms->GetContext(),&pEnum);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
lInstance = 0;
|
|
do
|
|
{
|
|
// get NUMBEROFINSTANCESTOBEFETCHED at once and increment the count accordingly
|
|
CCOMPointer<IWbemClassObject > pObjects[NUMBEROFINSTANCESTOBEFETCHED];
|
|
hr = pEnum->Next(WBEM_INFINITE ,NUMBEROFINSTANCESTOBEFETCHED,(IWbemClassObject **)pObjects,(ULONG *)&lObjectsReturned);
|
|
|
|
if(!FAILED(hr))
|
|
{
|
|
lInstance += lObjectsReturned;
|
|
}
|
|
|
|
if(lObjectsReturned < NUMBEROFINSTANCESTOBEFETCHED)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
while(hr != WBEM_S_FALSE || !FAILED(hr));
|
|
|
|
hr = hr == WBEM_S_FALSE ? S_OK : hr;
|
|
|
|
// Release interfaces and free the string
|
|
pEnum->Release();
|
|
SysFreeString(strWQL);
|
|
SysFreeString(strQry);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_INVALID_CLASS;
|
|
}
|
|
|
|
if( hr == S_OK)
|
|
cInstance = lInstance;
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//************************************************************************************************
|
|
//
|
|
// Deal with a class instance
|
|
//
|
|
//************************************************************************************************
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassInstanceWrapper::CWbemClassInstanceWrapper( CWbemClassParameters * p ): CWbemClassWrapper(p)
|
|
{
|
|
m_lPos = 0;
|
|
m_dwStatus = DBSTATUS_S_OK;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassInstanceWrapper::~CWbemClassInstanceWrapper( )
|
|
{
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassInstanceWrapper::GetKey(CBSTR & Key)
|
|
{
|
|
CVARIANT var;
|
|
HRESULT hr = S_OK;
|
|
|
|
if(FAILED(hr = GetProperty(L"__URL",var )))
|
|
{
|
|
hr = GetProperty(L"__PATH",var );
|
|
}
|
|
|
|
if( hr == S_OK ){
|
|
Key.SetStr(var.GetStr());
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemClassInstanceWrapper::ResetInstanceFromKey(CBSTR Key)
|
|
{
|
|
HRESULT hr;
|
|
SAFE_RELEASE_PTR(m_pClass);
|
|
hr = m_pParms->GetServicesPtr()->GetObject(Key, 0, NULL, &m_pClass, NULL);
|
|
if( hr == S_OK ){
|
|
m_pClass->AddRef();
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
// Refresh the internal pointer of the instance
|
|
// Object is refreshed by getting object by __PATH for WMI object
|
|
// and __URL property for WMI objects returned by UMI Providers
|
|
HRESULT CWbemClassInstanceWrapper::RefreshInstance()
|
|
{
|
|
CBSTR strPath;
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = GetKey(strPath);
|
|
|
|
if( hr == S_OK){
|
|
m_pClass->Release();
|
|
m_pClass = NULL;
|
|
|
|
hr = (m_pParms->GetServicesPtr())->GetObject(strPath,0,m_pParms->GetContext(),&m_pClass ,NULL);
|
|
}
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
m_dwStatus = DBSTATUS_S_OK;
|
|
}
|
|
else
|
|
{
|
|
m_dwStatus = DBSTATUS_E_UNAVAILABLE;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the name of the class to which the instance belongs
|
|
// THe returned pointer is to be cleaned by the callee
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWbemClassInstanceWrapper::GetClassName()
|
|
{
|
|
WCHAR *pClass = NULL;
|
|
BSTR strPropName;
|
|
HRESULT hr = 0;
|
|
|
|
strPropName = Wmioledb_SysAllocString(L"__Class");
|
|
|
|
VARIANT varClassName;
|
|
VariantInit(&varClassName);
|
|
|
|
// Get the class name
|
|
hr = m_pClass->Get(strPropName,0, &varClassName , NULL , NULL);
|
|
|
|
SysFreeString(strPropName);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
AllocateAndCopy(pClass,varClassName.bstrVal);
|
|
VariantClear(&varClassName);
|
|
}
|
|
return pClass;
|
|
}
|
|
|
|
|
|
HRESULT CWbemClassInstanceWrapper::CloneInstance(IWbemClassObject *& pInstance)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
pInstance = NULL;
|
|
|
|
hr = m_pClass->Clone(&pInstance);
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
// function which get the RElative path
|
|
// Gets __RELURL property for objects of UMI
|
|
// gets the __RELPATH for normal WMI objects ( as __RELURL property fetching fails)
|
|
HRESULT CWbemClassInstanceWrapper::GetRelativePath(WCHAR *& pstrRelPath)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
VARIANT varRelPath;
|
|
VariantInit(&varRelPath);
|
|
LONG nStringLen = 0;
|
|
|
|
if(FAILED(hr = m_pClass->Get(L"__RELURL",0,&varRelPath,NULL,NULL)))
|
|
{
|
|
hr = m_pClass->Get(L"__RELPATH",0,&varRelPath,NULL,NULL);
|
|
}
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
if(varRelPath.vt == VT_BSTR && varRelPath.bstrVal != NULL)
|
|
{
|
|
nStringLen = (SysStringLen(varRelPath.bstrVal) +1) * sizeof(WCHAR);
|
|
pstrRelPath = NULL;
|
|
pstrRelPath = new WCHAR[nStringLen];
|
|
if(pstrRelPath)
|
|
{
|
|
memset(pstrRelPath,0, nStringLen);
|
|
memcpy(pstrRelPath,varRelPath.bstrVal,nStringLen-sizeof(WCHAR));
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
E_FAIL;
|
|
}
|
|
VariantClear(&varRelPath);
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//************************************************************************************************
|
|
//
|
|
// Manage class instance list
|
|
//
|
|
//************************************************************************************************
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemInstanceList::CWbemInstanceList(CWbemClassParameters * pParms)
|
|
{
|
|
m_pParms = pParms;
|
|
m_ppEnum = NULL;
|
|
m_lCurrentPos = 0;
|
|
m_FetchDir = FETCHDIRNONE;
|
|
m_nBaseType = FALSE;
|
|
|
|
m_cTotalInstancesInEnum = 0;
|
|
InitializeCriticalSection(&m_InstanceCs);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemInstanceList::~CWbemInstanceList()
|
|
{
|
|
ReleaseAllInstances();
|
|
DeleteCriticalSection(&m_InstanceCs);
|
|
SAFE_RELEASE_PTR(m_ppEnum);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::ReleaseAllInstances()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
//==========================================================================
|
|
// Enter the critical section
|
|
//==========================================================================
|
|
Enter();
|
|
|
|
//==========================================================================
|
|
// Go through the instances one at a time and close them, then delete them
|
|
//==========================================================================
|
|
int nSize = m_List.Size();
|
|
|
|
if( nSize > 0 ){
|
|
|
|
for(int i = 0; i < nSize; i++){
|
|
|
|
CWbemClassInstanceWrapper * pClass = (CWbemClassInstanceWrapper*) m_List[i];
|
|
SAFE_DELETE_PTR(pClass);
|
|
}
|
|
m_List.Empty();
|
|
}
|
|
|
|
m_lCurrentPos = 0;
|
|
//==========================================================================
|
|
// Leave Critical Section
|
|
//==========================================================================
|
|
Leave();
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CWbemInstanceList::DeleteInstance( CWbemClassInstanceWrapper *& pClass )
|
|
{
|
|
HRESULT hr;
|
|
CBSTR strPath;
|
|
pClass->GetKey(strPath);
|
|
|
|
//=======================================================================
|
|
// Delete the instance from CIMOM
|
|
//=======================================================================
|
|
hr = (m_pParms->GetServicesPtr())->DeleteInstance((BSTR)strPath,0,m_pParms->GetContext(),NULL);
|
|
if( hr == S_OK ){
|
|
// hr = ReleaseInstance(pClass);
|
|
pClass->SetStatus(DBROWSTATUS_E_DELETED);
|
|
|
|
if(m_cTotalInstancesInEnum)
|
|
m_cTotalInstancesInEnum--;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::AddInstance( CWbemClassInstanceWrapper * pClass )
|
|
{
|
|
//==========================================================================
|
|
// Enter Critical Section
|
|
//==========================================================================
|
|
Enter();
|
|
//==========================================================================
|
|
// Add it to the list
|
|
//==========================================================================
|
|
m_List.Add(pClass);
|
|
//==========================================================================
|
|
// Leave Critical Section
|
|
//==========================================================================
|
|
Leave();
|
|
return MapWbemErrorToOLEDBError(S_OK);
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::ReleaseInstance(CWbemClassInstanceWrapper *& pClass)
|
|
{
|
|
//========================================================================
|
|
// Enter the critical section
|
|
//========================================================================
|
|
Enter();
|
|
|
|
//========================================================================
|
|
// Look for it in the list
|
|
//========================================================================
|
|
HRESULT hr = DB_E_NOTFOUND;
|
|
int n = 0;
|
|
|
|
for(int i = 0; i < m_List.Size(); i++){
|
|
|
|
CWbemClassInstanceWrapper * pClassInList = (CWbemClassInstanceWrapper * ) m_List[i];
|
|
if(pClass == pClassInList){
|
|
n = i;
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//========================================================================
|
|
// If we found it, then delete it from the list.
|
|
// The deconstructor will release the wbem class object
|
|
//========================================================================
|
|
if( S_OK == hr ){
|
|
m_List.RemoveAt(n);
|
|
delete pClass;
|
|
pClass = NULL;
|
|
}
|
|
//========================================================================
|
|
// Leave critical section
|
|
//========================================================================
|
|
Leave();
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::NextInstance( CBSTR & Key, CWbemClassInstanceWrapper ** pInst)
|
|
{
|
|
LONG lRelativePos = 1;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
//============================================================
|
|
// Now, enumerate all of the instances
|
|
//============================================================
|
|
if( m_ppEnum ){
|
|
|
|
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_FetchDir == FETCHDIRBACKWARD)
|
|
lRelativePos = 0;
|
|
|
|
// Check if the instance is already fetched
|
|
*pInst = GetInstance(m_lCurrentPos +lRelativePos);
|
|
if( *pInst == NULL){
|
|
unsigned long u;
|
|
IWbemClassObject * pClass = NULL;
|
|
|
|
hr = m_ppEnum->Next(0,1,&pClass,&u);
|
|
if( hr == S_OK ){
|
|
|
|
switch( m_nBaseType )
|
|
{
|
|
case COMMAND_ROWSET:
|
|
*pInst = new CWbemCommandInstanceWrapper(m_pParms,((CWbemCommandParameters*)m_pParms)->GetCommandManagerPtr());
|
|
break;
|
|
|
|
case SOURCES_ROWSET:
|
|
*pInst = (CWbemSchemaSourcesInstanceWrapper *) new CWbemSchemaSourcesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case PROVIDER_TYPES_ROWSET:
|
|
*pInst = (CWbemSchemaProviderTypesInstanceWrapper *) new CWbemSchemaProviderTypesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case CATALOGS_ROWSET:
|
|
*pInst = (CWbemSchemaCatalogsInstanceWrapper *) new CWbemSchemaCatalogsInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case COLUMNS_ROWSET:
|
|
*pInst = (CWbemSchemaColumnsInstanceWrapper *) new CWbemSchemaColumnsInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case TABLES_ROWSET:
|
|
*pInst = (CWbemSchemaTablesInstanceWrapper *) new CWbemSchemaTablesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case PRIMARY_KEYS_ROWSET:
|
|
*pInst = (CWbemSchemaPrimaryKeysInstanceWrapper *) new CWbemSchemaPrimaryKeysInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case TABLES_INFO_ROWSET:
|
|
*pInst = (CWbemSchemaTablesInfoInstanceWrapper *) new CWbemSchemaTablesInfoInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
default:
|
|
*pInst = new CWbemClassInstanceWrapper(m_pParms);
|
|
|
|
}
|
|
//NTRaid:111798 & 111799
|
|
// 06/07/00
|
|
if(*pInst)
|
|
{
|
|
(*pInst)->SetClass(pClass);
|
|
(*pInst)->SetPos(++m_lCurrentPos);
|
|
AddInstance(*pInst);
|
|
(*pInst)->GetKey(Key);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pClass);
|
|
}
|
|
else
|
|
{
|
|
// Adjust the enumerator to position to the current positon
|
|
if(( m_lCurrentPos +lRelativePos) > m_lCurrentPos)
|
|
hr = m_ppEnum->Skip(WBEM_INFINITE ,(LONG)lRelativePos);
|
|
|
|
m_lCurrentPos += lRelativePos;
|
|
m_FetchDir = FETCHDIRFORWARD;
|
|
(*pInst)->GetKey(Key);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::UpdateInstance(CWbemClassInstanceWrapper * pInstance, BOOL bNewInst)
|
|
{
|
|
HRESULT hr;
|
|
LONG lFlag = 0;
|
|
|
|
if(bNewInst == TRUE)
|
|
lFlag = WBEM_FLAG_CREATE_ONLY;
|
|
else
|
|
lFlag = WBEM_FLAG_UPDATE_ONLY;
|
|
|
|
hr = (m_pParms->GetServicesPtr())->PutInstance(pInstance->GetClassObject(),lFlag,m_pParms->GetContext(),NULL);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::Reset()
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
BOOL bGetInstanceEnum = TRUE;
|
|
//============================================================
|
|
// If we already got an enumeration, reset it, otherwise
|
|
// don't
|
|
//============================================================
|
|
if( m_ppEnum ){
|
|
if(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags)
|
|
{
|
|
ReleaseAllInstances();
|
|
m_ppEnum->Release();
|
|
m_ppEnum = NULL;
|
|
}
|
|
else
|
|
{
|
|
hr = m_ppEnum->Reset();
|
|
//ReleaseAllInstances();
|
|
bGetInstanceEnum = FALSE;
|
|
}
|
|
}
|
|
|
|
if(bGetInstanceEnum == TRUE)
|
|
{
|
|
CBSTR bstrClassName(m_pParms->m_pwcsClassName);
|
|
hr = (m_pParms->GetServicesPtr())->CreateInstanceEnum(bstrClassName,
|
|
m_pParms->m_dwNavFlags | m_pParms->m_dwQueryFlags,
|
|
m_pParms->GetContext(),
|
|
&m_ppEnum);
|
|
if( hr == S_OK)
|
|
m_cTotalInstancesInEnum = 0;
|
|
}
|
|
if(hr == S_OK)
|
|
{
|
|
m_lCurrentPos = 0;
|
|
// m_FetchDir = FETCHDIRFORWARD;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::AddNewInstance(CWbemClassWrapper *pClassWrappper, CWbemClassInstanceWrapper ** ppNewClass )
|
|
{
|
|
IWbemClassObject *pInstClassObject = NULL;
|
|
CWbemClassInstanceWrapper * pInst = NULL;
|
|
HRESULT hr = S_OK;
|
|
//==========================================================================
|
|
// Enter Critical Section
|
|
//==========================================================================
|
|
Enter();
|
|
//==========================================================================
|
|
// create a new instance
|
|
//==========================================================================
|
|
hr = pClassWrappper->GetClass()->SpawnInstance(0, &pInstClassObject);
|
|
|
|
if( hr == S_OK ){
|
|
*ppNewClass = new CWbemClassInstanceWrapper(m_pParms);
|
|
//NTRaid:111776 & NTRaid:111777
|
|
// 06/07/00
|
|
if(*ppNewClass)
|
|
{
|
|
(*ppNewClass)->SetClass(pInstClassObject);
|
|
(*ppNewClass)->SetPos(++m_lCurrentPos);
|
|
AddInstance(*ppNewClass);
|
|
|
|
if(m_cTotalInstancesInEnum)
|
|
m_cTotalInstancesInEnum++;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
SAFE_RELEASE_PTR(pInstClassObject);
|
|
|
|
}
|
|
|
|
//==========================================================================
|
|
// Leave Critical Section
|
|
//==========================================================================
|
|
Leave();
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
/*/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function called for instances embededed in another instance.
|
|
// This function adds the instance pointed by dispatch to the CWbemInstanceList
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassInstanceWrapper * CWbemInstanceList::AddInstanceToList( IUnknown *pDisp,CBSTR & Key)
|
|
{
|
|
|
|
IWbemClassObject * pClassObj = NULL;
|
|
HRESULT hr = S_OK;
|
|
CWbemClassInstanceWrapper * pInst = NULL;
|
|
|
|
hr = pDisp->QueryInterface(IID_IWbemClassObject , (void **) &pClassObj);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
|
|
pInst = new CWbemClassInstanceWrapper(m_pParms);
|
|
//NTRaid:111774 & NTRaid:111775
|
|
// 06/07/00
|
|
if(pInst)
|
|
{
|
|
pInst->SetClass(pClassObj);
|
|
pInst->SetPos(++m_lCurrentPos);
|
|
AddInstance(pInst);
|
|
pInst->GetKey(Key);
|
|
}
|
|
SAFE_RELEASE_PTR(pClassObj);;
|
|
|
|
}
|
|
|
|
return pInst;
|
|
}
|
|
*/
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get a previous instance in the enumerator
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::PrevInstance( CBSTR & Key,CWbemClassInstanceWrapper *& pInst )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBROWOFFSET lRelativePos = -1;
|
|
IWbemClassObject * pClass = NULL;
|
|
ULONG u = 0;
|
|
pInst = NULL;
|
|
BOOL bResetDone = FALSE;
|
|
|
|
// if the first call after initialization / restartPositon of rowset is getting
|
|
// instance in reverse direction then
|
|
if( !(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags) && m_lCurrentPos == 0 && m_FetchDir == FETCHDIRFORWARD)
|
|
{
|
|
if(!m_cTotalInstancesInEnum)
|
|
if(S_OK != (hr = GetNumberOfInstanceInEnumerator()))
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
|
|
|
|
if((LONG)(m_cTotalInstancesInEnum - lRelativePos) > 0)
|
|
{
|
|
m_lCurrentPos = m_cTotalInstancesInEnum;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
if( (m_lCurrentPos + lRelativePos) == 0 && m_FetchDir == FETCHDIRBACKWARD)
|
|
return E_FAIL;
|
|
else
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_FetchDir == FETCHDIRFORWARD)
|
|
lRelativePos = 0;
|
|
|
|
// Reset the position to the so that
|
|
// NextInstance function gives the instance required
|
|
|
|
hr = ResetRelPosition(lRelativePos);
|
|
}
|
|
|
|
pInst = GetInstance(m_lCurrentPos);
|
|
if(pInst == NULL)
|
|
{
|
|
bResetDone = TRUE;
|
|
// restore the original position
|
|
if(!(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags))
|
|
{
|
|
m_ppEnum->Reset();
|
|
m_ppEnum->Skip(WBEM_INFINITE,(LONG)(m_lCurrentPos - 1));
|
|
hr = m_ppEnum->Next(0,1,&pClass,&u);
|
|
if( hr == S_OK )
|
|
{
|
|
switch( m_nBaseType ){
|
|
|
|
case COMMAND_ROWSET:
|
|
pInst = (CWbemClassInstanceWrapper *) new CWbemCommandInstanceWrapper(m_pParms,((CWbemCommandParameters*)m_pParms)->GetCommandManagerPtr());
|
|
break;
|
|
|
|
case SOURCES_ROWSET:
|
|
pInst = (CWbemClassInstanceWrapper *) new CWbemSchemaSourcesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case PROVIDER_TYPES_ROWSET:
|
|
pInst = (CWbemClassInstanceWrapper *) new CWbemSchemaProviderTypesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case CATALOGS_ROWSET:
|
|
pInst = (CWbemSchemaCatalogsInstanceWrapper *) new CWbemSchemaCatalogsInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case COLUMNS_ROWSET:
|
|
pInst = (CWbemSchemaColumnsInstanceWrapper *) new CWbemSchemaColumnsInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case TABLES_ROWSET:
|
|
pInst = (CWbemSchemaTablesInstanceWrapper *) new CWbemSchemaTablesInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case PRIMARY_KEYS_ROWSET:
|
|
pInst = (CWbemSchemaPrimaryKeysInstanceWrapper *) new CWbemSchemaPrimaryKeysInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
case TABLES_INFO_ROWSET:
|
|
pInst = (CWbemSchemaTablesInfoInstanceWrapper *) new CWbemSchemaTablesInfoInstanceWrapper(m_pParms);
|
|
break;
|
|
|
|
default:
|
|
pInst = new CWbemClassInstanceWrapper(m_pParms);
|
|
|
|
}
|
|
//NTRaid:111796-111797
|
|
// 06/07/00
|
|
if(pInst)
|
|
{
|
|
(pInst)->SetClass(pClass);
|
|
(pInst)->SetPos(m_lCurrentPos);
|
|
AddInstance(pInst);
|
|
// (pInst)->GetKey(Key);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pClass);
|
|
}
|
|
|
|
}
|
|
if(pInst != NULL)
|
|
{
|
|
pInst->GetKey(Key);
|
|
m_FetchDir = FETCHDIRBACKWARD; // setting that the last fetch was backwards
|
|
// m_lCurrentPos = m_lCurrentPos + lRelativePos;
|
|
}
|
|
else
|
|
{
|
|
if(bResetDone)
|
|
hr = ResetRelPosition(lRelativePos * (-1));
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function which returns the instance pointer given the position if already retrieved
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemClassInstanceWrapper * CWbemInstanceList::GetInstance( ULONG_PTR lPos )
|
|
{
|
|
CWbemClassInstanceWrapper * pInst = NULL ;
|
|
|
|
for(int i = 0; i < m_List.Size(); i++)
|
|
{
|
|
|
|
CWbemClassInstanceWrapper *pTempInst = (CWbemClassInstanceWrapper * ) m_List[i];
|
|
if(pTempInst->GetPos() == lPos)
|
|
{
|
|
pInst = pTempInst;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return pInst;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to reset the positon by the number of instance specified
|
|
// so that the NextInstance function gives the instance required
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::ResetRelPosition( DBROWOFFSET lPos )
|
|
{
|
|
DBROWOFFSET lPosRequired = 0;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
CWbemClassInstanceWrapper * pInst = NULL;
|
|
|
|
// Get the position at which the enumerator to be pointed to
|
|
lPosRequired = m_lCurrentPos + lPos;
|
|
if( lPosRequired > 0)
|
|
{
|
|
// If skipping is forward then skip by the number of positions
|
|
if(lPos > 0)
|
|
{
|
|
if(S_OK == (hr = m_ppEnum->Skip(WBEM_INFINITE ,(LONG)lPos)))
|
|
m_lCurrentPos = lPosRequired;
|
|
else
|
|
// restore the original position
|
|
if(!(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags))
|
|
{
|
|
m_ppEnum->Reset();
|
|
hr = m_ppEnum->Skip(WBEM_INFINITE,(LONG)m_lCurrentPos);
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
// Else if skipping is negative , then
|
|
else
|
|
if( lPos < 0)
|
|
{
|
|
// If enumerator is not forward only then skip Reset
|
|
// the begining and spip to the position required
|
|
if(!(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags))
|
|
{
|
|
if(S_OK == (hr = m_ppEnum->Reset()))
|
|
{
|
|
if(S_OK == (hr = m_ppEnum->Skip(WBEM_INFINITE ,(LONG)lPosRequired)))
|
|
m_lCurrentPos = lPosRequired;
|
|
else
|
|
{
|
|
m_ppEnum->Reset();
|
|
hr = m_ppEnum->Skip(WBEM_INFINITE,(LONG)m_lCurrentPos);
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
// other wise if the enumerator is forward only return
|
|
// error
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
if(lPosRequired == 0 && !(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags))
|
|
{
|
|
hr = m_ppEnum->Reset();
|
|
m_lCurrentPos = lPosRequired;
|
|
}
|
|
else
|
|
// if the initial position is negative when the enumerator is at the begining then
|
|
if(lPosRequired < 0 && !(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags) && m_lCurrentPos == 0)
|
|
{
|
|
if(!m_cTotalInstancesInEnum)
|
|
if(S_OK != (hr = GetNumberOfInstanceInEnumerator()))
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
|
|
|
|
if((LONG)(m_cTotalInstancesInEnum + lPos) > 0)
|
|
{
|
|
hr = m_ppEnum->Reset();
|
|
if(S_OK == (hr = m_ppEnum->Skip(WBEM_INFINITE,(LONG)(m_cTotalInstancesInEnum + lPos))))
|
|
m_lCurrentPos = m_cTotalInstancesInEnum + lPos;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get the number of instances in a enumerator
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemInstanceList::GetNumberOfInstanceInEnumerator(ULONG_PTR *pcInstance)
|
|
{
|
|
ULONG ulObj = 0;
|
|
HRESULT hr = S_OK;
|
|
m_cTotalInstancesInEnum = 0;
|
|
int i = 0;
|
|
|
|
if(S_OK == (hr = m_ppEnum->Reset()))
|
|
{
|
|
// Calculate the number of instance in the enumerator
|
|
while(S_OK == hr)
|
|
{
|
|
{
|
|
CCOMPointer<IWbemClassObject > pObjects[NUMBEROFINSTANCESTOBEFETCHED];
|
|
hr = m_ppEnum->Next(0,NUMBEROFINSTANCESTOBEFETCHED,(IWbemClassObject **)pObjects , &ulObj);
|
|
|
|
}
|
|
if( hr == S_OK || hr == WBEM_S_FALSE)
|
|
m_cTotalInstancesInEnum += ulObj;
|
|
}
|
|
|
|
// Bring back to the original position
|
|
if((S_OK == (hr = m_ppEnum->Reset())) && m_lCurrentPos != 0)
|
|
hr = m_ppEnum->Skip(WBEM_INFINITE ,(LONG)m_lCurrentPos);
|
|
|
|
}
|
|
if(SUCCEEDED(hr) && &pcInstance)
|
|
{
|
|
*pcInstance = m_cTotalInstancesInEnum;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/***********************************************************************************************************
|
|
Class CWbemPropertyQualifierList implementation
|
|
/***********************************************************************************************************/
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemPropertyQualifierList::~CWbemPropertyQualifierList()
|
|
{
|
|
RemoveAll();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Remove all elements from the list
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemPropertyQualifierList::RemoveAll()
|
|
{
|
|
CWbemPropertyQualifierWrapper *pQualifWrap = NULL;
|
|
int nSize = m_QualifierList.Size();
|
|
|
|
if(m_QualifierList.Size() > 0)
|
|
for( int nIndex = nSize-1 ; nIndex >= 0 ; nIndex--)
|
|
{
|
|
pQualifWrap = (CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex];
|
|
m_QualifierList.RemoveAt(nIndex);
|
|
pQualifWrap->m_pIWbemPropertyQualifierSet->EndEnumeration();
|
|
SAFE_DELETE_PTR(pQualifWrap);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// add a Element to the list
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemPropertyQualifierList::Add(IWbemQualifierSet* pQualifierSet,WCHAR *pwstrPropertyName)
|
|
{
|
|
CWbemPropertyQualifierWrapper *pNewQualifWrap = NULL;
|
|
pNewQualifWrap = new CWbemPropertyQualifierWrapper;
|
|
HRESULT hr = S_OK;
|
|
|
|
// NTRaid:111779 & NTRaid:111780
|
|
// 06/07/00
|
|
if(pNewQualifWrap)
|
|
{
|
|
pNewQualifWrap->m_pIWbemPropertyQualifierSet = pQualifierSet;
|
|
pNewQualifWrap->m_pwstrPropertyName = new WCHAR[wcslen(pwstrPropertyName) + 1];
|
|
if(pNewQualifWrap->m_pwstrPropertyName)
|
|
{
|
|
wcscpy(pNewQualifWrap->m_pwstrPropertyName,pwstrPropertyName);
|
|
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
if(SUCCEEDED(hr = m_QualifierList.Add(pNewQualifWrap)))
|
|
{
|
|
hr = pQualifierSet->BeginEnumeration(0);
|
|
}
|
|
else
|
|
{
|
|
SAFE_DELETE_ARRAY(pNewQualifWrap->m_pwstrPropertyName)
|
|
SAFE_DELETE_PTR(pNewQualifWrap)
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SAFE_DELETE_PTR(pNewQualifWrap);
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Remove a Element from the list
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemPropertyQualifierList::Remove(WCHAR *pwstrPropertyName)
|
|
{
|
|
CWbemPropertyQualifierWrapper *pQualifWrap = NULL;
|
|
|
|
for( int nIndex = 0 ; nIndex < m_QualifierList.Size(); nIndex++)
|
|
{
|
|
if(0 == wbem_wcsicmp(((CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex])->m_pwstrPropertyName,pwstrPropertyName))
|
|
{
|
|
pQualifWrap = (CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex];
|
|
m_QualifierList.RemoveAt(nIndex);
|
|
pQualifWrap->m_pIWbemPropertyQualifierSet->EndEnumeration();
|
|
SAFE_DELETE_PTR(pQualifWrap);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the IWbemQualifierSet pointer to the required property
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
IWbemQualifierSet* CWbemPropertyQualifierList::GetPropertyQualifierSet(WCHAR *pwstrPropertyName)
|
|
{
|
|
for( int nIndex = 0 ; nIndex < m_QualifierList.Size(); nIndex++)
|
|
{
|
|
if(0 == wbem_wcsicmp(((CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex])->m_pwstrPropertyName,pwstrPropertyName))
|
|
return ((CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex])->m_pIWbemPropertyQualifierSet;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the CQualiferPos pointer for a property
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CQualiferPos *CWbemPropertyQualifierList::GetQualiferPosObject(WCHAR *pwcsProperty)
|
|
{
|
|
for( int nIndex = 0 ; nIndex < m_QualifierList.Size(); nIndex++)
|
|
{
|
|
if(0 == wbem_wcsicmp(((CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex])->m_pwstrPropertyName,pwcsProperty))
|
|
return &(((CWbemPropertyQualifierWrapper *)m_QualifierList[nIndex])->m_QualifierPos);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************************
|
|
Class CQualifier implementation
|
|
/***********************************************************************************************************/
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CQualiferPos::CQualiferPos()
|
|
{
|
|
m_lPos = -1;
|
|
m_FetchDir = FETCHDIRNONE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CQualiferPos::~CQualiferPos()
|
|
{
|
|
RemoveAll();
|
|
m_lPos = -1;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Remove all the elements from the list
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CQualiferPos::RemoveAll()
|
|
{
|
|
WCHAR *pChar = NULL;
|
|
int nSize = m_QualifierPos.Size();
|
|
|
|
if(m_QualifierPos.Size() > 0)
|
|
for( int nIndex = nSize-1 ; nIndex >= 0 ; nIndex--)
|
|
{
|
|
if ( NULL != (pChar = (WCHAR *)m_QualifierPos[nIndex]))
|
|
{
|
|
delete [] pChar;
|
|
pChar = NULL;
|
|
}
|
|
m_QualifierPos.RemoveAt(nIndex);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Remove a qualifier from the list
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CQualiferPos::Remove(WCHAR *pwcsQualifier)
|
|
{
|
|
int nSize = m_QualifierPos.Size();
|
|
|
|
if(m_QualifierPos.Size() > 0)
|
|
for( int nIndex = nSize-1 ; nIndex >= 0 ; nIndex--)
|
|
{
|
|
if(wbem_wcsicmp((WCHAR *)m_QualifierPos[nIndex],pwcsQualifier) == 0)
|
|
{
|
|
m_QualifierPos.RemoveAt(nIndex);
|
|
m_lPos--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get qualifier at a particula position
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CQualiferPos::operator [] (DBORDINAL nIndex)
|
|
{
|
|
if( nIndex <= (ULONG_PTR)m_QualifierPos.Size())
|
|
return (WCHAR *)m_QualifierPos[(int)nIndex];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get the qualifier at a relation positon from the current position
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CQualiferPos::GetRelative (DBROWOFFSET lRelPos, WCHAR *&pwcsQualifier)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LONG lSize = m_QualifierPos.Size();
|
|
|
|
if( lSize > 0)
|
|
{
|
|
if( (m_lPos + lRelPos) >= lSize)
|
|
{
|
|
hr = WBEMERROR_QUALIFER_TOBE_FETCHED;
|
|
}
|
|
else
|
|
if( (m_lPos + lRelPos) < 0)
|
|
{
|
|
hr = DB_E_BADSTARTPOSITION;
|
|
}
|
|
else
|
|
{
|
|
pwcsQualifier = (WCHAR *)m_QualifierPos[(int)(m_lPos + lRelPos)];
|
|
}
|
|
}
|
|
else
|
|
hr = lRelPos > 0 ? WBEMERROR_QUALIFER_TOBE_FETCHED :DB_E_BADSTARTPOSITION;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Add qualifier to the list
|
|
//NTRaid:111779
|
|
// 06/13/00
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CQualiferPos::Add(WCHAR *pwcsQualifier)
|
|
{
|
|
WCHAR *pstrTemp = NULL;
|
|
HRESULT hr = S_OK;
|
|
pstrTemp = new WCHAR[wcslen(pwcsQualifier) +1];
|
|
|
|
if(pstrTemp)
|
|
{
|
|
wcscpy(pstrTemp,pwcsQualifier);
|
|
if(SUCCEEDED(hr = m_QualifierPos.Add(pstrTemp)))
|
|
{
|
|
m_lPos++;
|
|
}
|
|
else
|
|
{
|
|
SAFE_DELETE_ARRAY(pstrTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Set relation position
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CQualiferPos::SetRelPos(DBROWOFFSET lRelPos)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if( m_QualifierPos.Size() > 0)
|
|
{
|
|
if( (m_lPos + lRelPos) >= m_QualifierPos.Size())
|
|
{
|
|
hr = WBEMERROR_QUALIFER_TOBE_FETCHED;
|
|
}
|
|
else
|
|
if( (m_lPos + lRelPos) < -1)
|
|
{
|
|
hr = DB_E_BADSTARTPOSITION;
|
|
}
|
|
else
|
|
{
|
|
m_lPos = m_lPos + lRelPos;
|
|
}
|
|
}
|
|
else
|
|
hr = lRelPos > 0 ? WBEMERROR_QUALIFER_TOBE_FETCHED :DB_E_BADSTARTPOSITION;
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*****************************************************************************************************
|
|
//
|
|
//
|
|
// The COMMAND classes
|
|
//
|
|
//
|
|
//*****************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Command Manager, manages all the command interfaces
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandManager::CWbemCommandManager(CQuery * p)
|
|
{
|
|
m_pClassDefinition = NULL;
|
|
m_pInstanceList = NULL;
|
|
m_pInstance = NULL;
|
|
m_pParms = NULL;
|
|
m_pQuery = p;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandManager::~CWbemCommandManager()
|
|
{
|
|
|
|
// These pointers are all deleted elsewhere, so do not delete, this class is simply a pass-through class
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemCommandManager::Init(CWbemCommandInstanceList * InstanceList, CWbemCommandParameters * pParms,
|
|
CWbemCommandClassDefinitionWrapper* pDef)
|
|
{
|
|
m_pInstanceList = InstanceList;
|
|
m_pParms = pParms;
|
|
m_pClassDefinition = pDef;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL CWbemCommandManager::ValidQuery()
|
|
{
|
|
if( m_pQuery ){
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandManager::ValidQueryResults()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if( ValidQuery() ){
|
|
m_pQuery->m_pcsQuery->Enter();
|
|
|
|
if ( !(m_pQuery->GetStatus() & CMD_EXECUTED_ONCE)){
|
|
|
|
if ( m_pQuery->GetStatus() & CMD_READY){
|
|
|
|
if( m_pInstanceList ){
|
|
|
|
if(SUCCEEDED(hr = m_pInstanceList->SetQuery(m_pQuery->GetQuery(),m_pQuery->GetDialectGuid(),m_pQuery->GetQueryLang())) &&
|
|
SUCCEEDED(hr = m_pClassDefinition->SetQueryType(m_pQuery->GetQuery(),m_pQuery->GetDialectGuid(),m_pQuery->GetQueryLang())) )
|
|
// if( hr == S_OK )
|
|
{
|
|
hr = m_pInstanceList->Reset();
|
|
if( hr == S_OK ){
|
|
m_pQuery->ClearStatus(CMD_READY);
|
|
m_pQuery->SetStatus(CMD_EXECUTED_ONCE);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_pQuery->m_pcsQuery->Leave();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandManager::GetClassDefinitionForQueryResults()
|
|
{
|
|
CWbemClassInstanceWrapper *pInst = NULL;
|
|
CBSTR strKey;
|
|
HRESULT hr = S_OK;
|
|
CBSTR stQryLanguage(m_pInstanceList->GetQueryLanguage());
|
|
CBSTR strQuery(m_pInstanceList->GetQuery());
|
|
IEnumWbemClassObject *pEnum = NULL;
|
|
IWbemClassObject *p = NULL;
|
|
ULONG cElem = 0;
|
|
|
|
if(NORMAL == GetObjListType())
|
|
{
|
|
// Execute the query just to get the class defination
|
|
if(SUCCEEDED(hr = (m_pParms->GetServicesPtr())->ExecQuery(stQryLanguage, strQuery, WBEM_FLAG_PROTOTYPE,m_pParms->GetContext(),&pEnum)))
|
|
{
|
|
if(SUCCEEDED(hr = pEnum->Next(0,1,&p,&cElem)) && cElem > 0)
|
|
{
|
|
pEnum->Release();
|
|
|
|
((CWbemClassWrapper*)(m_pClassDefinition))->SetClass(p);
|
|
}
|
|
SAFE_RELEASE_PTR(p);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
INSTANCELISTTYPE CWbemCommandManager::GetObjListType()
|
|
{
|
|
return m_pClassDefinition->GetObjListType();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Command parameters
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandParameters::CWbemCommandParameters(DWORD dwFlags,CWbemConnectionWrapper * Connect,CWbemCommandManager * p) :
|
|
CWbemClassParameters(dwFlags,(WCHAR*)NULL,Connect)
|
|
{
|
|
m_pwcsClassName = new WCHAR [wcslen(szInstance) + 1];
|
|
wcscpy(m_pwcsClassName,szInstance);
|
|
m_pCmdManager = p;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandParameters::~CWbemCommandParameters()
|
|
{
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Command class definition
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandClassDefinitionWrapper::CWbemCommandClassDefinitionWrapper( CWbemClassParameters * p,CWbemCommandManager * pCmd )
|
|
: CWbemClassDefinitionWrapper(p)
|
|
{
|
|
m_nMaxColumns = 0;
|
|
m_pCmdManager = pCmd;
|
|
m_objListType = NORMAL;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandClassDefinitionWrapper::~CWbemCommandClassDefinitionWrapper()
|
|
{
|
|
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::ValidClass()
|
|
{
|
|
if( ! m_pCmdManager->ValidQuery() ) {
|
|
return E_FAIL;
|
|
}
|
|
return S_OK;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get the total number of columns for a resultset on executing a command
|
|
// NTRaid:142133
|
|
// 07/11/2000
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::TotalPropertiesInClass(ULONG & ulPropCount, ULONG &ulSysPropCount)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
hr = m_pCmdManager->ValidQueryResults();
|
|
|
|
if( hr == S_OK ){
|
|
hr = m_pCmdManager->GetClassDefinitionForQueryResults();
|
|
|
|
if(hr == S_OK){
|
|
switch(m_pCmdManager->GetObjListType())
|
|
{
|
|
case NORMAL:
|
|
{
|
|
hr = CWbemClassWrapper::TotalPropertiesInClass(ulPropCount,ulSysPropCount);
|
|
}
|
|
break;
|
|
|
|
case MIXED:
|
|
{
|
|
// if it is a heterogenous objects then just have column for
|
|
// only the __PATH
|
|
ulPropCount = 0;
|
|
ulSysPropCount = 1;
|
|
hr = S_OK;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
// this means that the query was unable to get return any object or unable
|
|
// to get the prototype of the resultant object for query execution
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
ulPropCount = 0;
|
|
ulSysPropCount = 0;
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to set the query type after looking for "ASSOCIATORS OF" and "REFERENCES OF" in the query
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::SetQueryType(LPCWSTR strQry,GUID QryDialect,LPCWSTR strQryLang)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bLDAPQry = FALSE;
|
|
|
|
if((strQryLang != NULL && _wcsicmp(strQryLang,szWQL) == 0) &&
|
|
(!wbem_wcsincmp(strQry,szReferenceOfQry,wcslen(szReferenceOfQry)) ||
|
|
!wbem_wcsincmp(strQry,szAssociatersQry,wcslen(szAssociatersQry))) )
|
|
{
|
|
m_objListType = MIXED;
|
|
}
|
|
else
|
|
if((QryDialect == DBGUID_DEFAULT || QryDialect == DBGUID_WQL) &&
|
|
(!wbem_wcsincmp(strQry,szReferenceOfQry,wcslen(szReferenceOfQry)) ||
|
|
!wbem_wcsincmp(strQry,szAssociatersQry,wcslen(szAssociatersQry))) )
|
|
{
|
|
m_objListType = MIXED;
|
|
}
|
|
else
|
|
if((strQryLang != NULL && _wcsicmp(strQryLang,szWQL)) ||
|
|
(QryDialect != DBGUID_DEFAULT && QryDialect != DBGUID_WQL) )
|
|
{
|
|
hr = E_FAIL;
|
|
if(strQryLang != NULL)
|
|
{
|
|
if(_wcsicmp(strQryLang,szLDAP) == 0)
|
|
{
|
|
bLDAPQry = TRUE;
|
|
m_objListType = MIXED;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
if(_wcsicmp(strQryLang,szLDAPSQL) == 0)
|
|
{
|
|
bLDAPQry = FALSE;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
if(QryDialect == DBGUID_LDAP)
|
|
{
|
|
bLDAPQry = TRUE;
|
|
m_objListType = MIXED;
|
|
hr = S_OK;
|
|
}
|
|
if(QryDialect == DBGUID_LDAPSQL)
|
|
{
|
|
bLDAPQry = FALSE;
|
|
m_objListType = MIXED;
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
if(SUCCEEDED(hr) && bLDAPQry == FALSE)
|
|
{
|
|
// check if the query is "SELECT * FROM" type of query
|
|
// if so then set the query type to MIXED
|
|
WCHAR *pStrQry = NULL;
|
|
WCHAR *strToken = NULL;
|
|
WCHAR strSeparator[] = L" ";
|
|
|
|
pStrQry = new WCHAR[wcslen(strQry) + 1];
|
|
|
|
if(pStrQry)
|
|
{
|
|
// by default query is MIXED for LDAP and SQL Queries
|
|
// except that if it is select col1,col2 from ...
|
|
m_objListType = MIXED;
|
|
memset(pStrQry,0,sizeof(WCHAR) * wcslen(strQry) + 1);
|
|
wcscpy(pStrQry,strQry);
|
|
strToken = wcstok( pStrQry, strSeparator );
|
|
|
|
if(strToken && _wcsicmp(L"Select",strToken) == 0)
|
|
{
|
|
m_objListType = NORMAL;
|
|
strToken = wcstok( NULL, strSeparator );
|
|
if(strToken && _wcsicmp(L"*",strToken) == 0)
|
|
{
|
|
strToken = wcstok( NULL, strSeparator );
|
|
if(strToken && _wcsicmp(L"FROM",strToken) == 0)
|
|
{
|
|
m_objListType = MIXED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
SAFE_DELETE_ARRAY(pStrQry);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::BeginPropertyEnumeration()
|
|
{
|
|
return CWbemClassWrapper::BeginPropertyEnumeration();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::EndPropertyEnumeration()
|
|
{
|
|
return CWbemClassWrapper::EndPropertyEnumeration();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
return CWbemClassWrapper::GetNextProperty(pProperty,vValue,pType,plFlavor);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandClassDefinitionWrapper::BeginPropertyQualifierEnumeration(BSTR strPropName)
|
|
{
|
|
return CWbemClassWrapper::BeginPropertyQualifierEnumeration(strPropName);
|
|
}*/
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Command instance list
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandInstanceList::CWbemCommandInstanceList(CWbemClassParameters * p,CWbemCommandManager * pCmd): CWbemInstanceList(p)
|
|
{
|
|
m_pCmdManager = pCmd;
|
|
m_pParms = p;
|
|
m_nBaseType = COMMAND_ROWSET;
|
|
m_pwstrQueryLanguage = NULL;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandInstanceList::~CWbemCommandInstanceList()
|
|
{
|
|
SAFE_DELETE_ARRAY(m_pwstrQueryLanguage);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandInstanceList::Reset()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
CBSTR strQryLanguage(m_pwstrQueryLanguage);
|
|
CBSTR strQuery(m_pwstrQuery);
|
|
BOOL bExecQuery = TRUE;
|
|
LONG lFlags = m_pParms->m_dwNavFlags | m_pParms->m_dwQueryFlags | WBEM_FLAG_ENSURE_LOCATABLE;
|
|
|
|
if(m_ppEnum != NULL)
|
|
{
|
|
if(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags)
|
|
{
|
|
ReleaseAllInstances();
|
|
m_ppEnum->Release();
|
|
m_ppEnum = NULL;
|
|
}
|
|
else
|
|
{
|
|
hr = m_ppEnum->Reset();
|
|
bExecQuery = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
if( bExecQuery)
|
|
{
|
|
hr = (m_pParms->GetServicesPtr())->ExecQuery(strQryLanguage,
|
|
strQuery,
|
|
lFlags,
|
|
m_pParms->GetContext(),
|
|
&m_ppEnum);
|
|
m_lCurrentPos = 0;
|
|
}
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
m_lCurrentPos = 0;
|
|
// m_FetchDir = FETCHDIRFORWARD;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWbemCommandInstanceList::SetQuery( LPWSTR p,GUID QryDialect,LPCWSTR strQryLang)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
m_pwstrQuery = p;
|
|
SAFE_DELETE_ARRAY(m_pwstrQueryLanguage);
|
|
|
|
if(strQryLang == NULL)
|
|
{
|
|
if(QryDialect == DBGUID_WQL || QryDialect == DBGUID_DEFAULT)
|
|
{
|
|
m_pwstrQueryLanguage = new WCHAR[wcslen(szWQL) + 1];
|
|
if(m_pwstrQueryLanguage)
|
|
{
|
|
wcscpy(m_pwstrQueryLanguage,szWQL);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
if(QryDialect == DBGUID_LDAP)
|
|
{
|
|
// MOdify the string here to be passed for executing
|
|
// LDAP queries
|
|
m_pwstrQueryLanguage = new WCHAR[wcslen(szLDAP) + 1];
|
|
if(m_pwstrQueryLanguage)
|
|
{
|
|
wcscpy(m_pwstrQueryLanguage,szLDAP);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
if(QryDialect == DBGUID_LDAPSQL)
|
|
{
|
|
// MOdify the string here to be passed for executing
|
|
// LDAP queries
|
|
m_pwstrQueryLanguage = new WCHAR[wcslen(szLDAPSQL) + 1];
|
|
if(m_pwstrQueryLanguage)
|
|
{
|
|
wcscpy(m_pwstrQueryLanguage,szLDAPSQL);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
if(QryDialect == DBGUID_WMI_METHOD)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pwstrQueryLanguage = new WCHAR[wcslen(strQryLang) + 1];
|
|
if(m_pwstrQueryLanguage)
|
|
{
|
|
wcscpy(m_pwstrQueryLanguage,strQryLang);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Command instance wrapper list
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandInstanceWrapper::CWbemCommandInstanceWrapper(CWbemClassParameters * p, CWbemCommandManager * pCmd ): CWbemClassInstanceWrapper(p)
|
|
{
|
|
m_pCmdManager = pCmd;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCommandInstanceWrapper::~CWbemCommandInstanceWrapper()
|
|
{
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWbemCommandInstanceWrapper::GetClassName()
|
|
{
|
|
WCHAR *pClass = NULL;
|
|
BSTR strPropName;
|
|
HRESULT hr = 0;
|
|
|
|
// Get the class name only if query is mixed
|
|
// meaning heteregenous objects are requested
|
|
if(MIXED == m_pCmdManager->GetObjListType())
|
|
{
|
|
strPropName = Wmioledb_SysAllocString(L"__Class");
|
|
|
|
VARIANT varClassName;
|
|
VariantInit(&varClassName);
|
|
|
|
// Get the class name
|
|
hr = m_pClass->Get(strPropName,0, &varClassName , NULL , NULL);
|
|
|
|
SysFreeString(strPropName);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
AllocateAndCopy(pClass,varClassName.bstrVal);
|
|
VariantClear(&varClassName);
|
|
}
|
|
}
|
|
|
|
return pClass;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function to get __PATH of the instance
|
|
// __PATH property makes sense only when REFERENCES OF or ASSOCIATERS OF query is run
|
|
// otherwise __PATH property will be NULL string
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandInstanceWrapper::GetKey(CBSTR & Key)
|
|
{
|
|
CVARIANT var;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// NTRaid: 130047
|
|
// Get the Key name only if query is mixed
|
|
// meaning heteregenous objects are requested
|
|
// if(MIXED == m_pCmdManager->GetObjListType())
|
|
{
|
|
if(FAILED(hr = GetProperty(L"__URL",var)))
|
|
{
|
|
hr = GetProperty(L"__PATH",var );
|
|
}
|
|
if( hr == S_OK )
|
|
{
|
|
Key.SetStr(var.GetStr());
|
|
}
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// This method applies only for instances obtained from REFERENCES OF or ASSOCIATERS OF query
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCommandInstanceWrapper::RefreshInstance()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Get the Key name only if query is mixed
|
|
// meaning heteregenous objects are requested
|
|
if(MIXED == m_pCmdManager->GetObjListType())
|
|
{
|
|
hr = CWbemClassInstanceWrapper::RefreshInstance();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Method class definition
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// The Method parameters
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodParameters::CWbemMethodParameters(CQuery * p, DWORD dwFlags,CWbemConnectionWrapper * Connect) :
|
|
CWbemClassParameters(dwFlags,(WCHAR*)NULL,Connect)
|
|
{
|
|
m_pwcsClassName = new WCHAR [wcslen(szInstance) + 1];
|
|
wcscpy(m_pwcsClassName,szInstance);
|
|
|
|
m_pQuery = p;
|
|
m_pwcsInstance=NULL;
|
|
m_pwcsMethod=NULL;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodParameters::~CWbemMethodParameters()
|
|
{
|
|
SAFE_DELETE_PTR(m_pwcsInstance);
|
|
SAFE_DELETE_PTR(m_pwcsMethod);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodParameters::ExtractNamesFromQuery()
|
|
{
|
|
HRESULT hr = DB_E_ERRORSINCOMMAND;
|
|
WCHAR * wcsQuery = m_pQuery->GetQuery();
|
|
|
|
//=======================================================================
|
|
// The purpose of this function is to extract the class name and
|
|
// method name from the query string. This query is in the format of:
|
|
// Win32_Process.Handle="20".GetOwner
|
|
//=======================================================================
|
|
DeleteClassName();
|
|
SAFE_DELETE_PTR(m_pwcsInstance);
|
|
SAFE_DELETE_PTR(m_pwcsMethod);
|
|
|
|
int nMax = wcslen(wcsQuery);
|
|
|
|
// NTRaid: 136429
|
|
// 07/05/00
|
|
WCHAR *pTmp1 = NULL;
|
|
WCHAR *pTmp2 = NULL;
|
|
WCHAR *pTmp3 = NULL;
|
|
WCHAR *pTmp4 = NULL;
|
|
|
|
pTmp1 = new WCHAR[nMax];
|
|
pTmp2 = new WCHAR[nMax];
|
|
pTmp3 = new WCHAR[nMax];
|
|
pTmp4 = new WCHAR[nMax];
|
|
|
|
|
|
if( pTmp1 && pTmp2 && pTmp3 && pTmp4 ){
|
|
|
|
memset(pTmp1,0,nMax * sizeof(WCHAR));
|
|
memset(pTmp2,0,nMax * sizeof(WCHAR));
|
|
memset(pTmp3,0,nMax * sizeof(WCHAR));
|
|
memset(pTmp4,0,nMax * sizeof(WCHAR));
|
|
|
|
swscanf(wcsQuery,L"%[^.].%[^=]=%[^.].%s",pTmp1,pTmp2,pTmp3,pTmp4);
|
|
//============================================================
|
|
// Win32_Process.Handle="20" .GetOwner
|
|
//============================================================
|
|
if(wcslen(pTmp4) == 0 || wcslen(pTmp3) == 0)
|
|
{
|
|
swscanf(wcsQuery,L"%[^=].%s",pTmp1,pTmp2);
|
|
}
|
|
else
|
|
{
|
|
swscanf(wcsQuery,L"%[^.].%s",pTmp1,pTmp2);
|
|
}
|
|
_wcsrev(wcsQuery);
|
|
swscanf(wcsQuery,L"%[^.].%s",pTmp4,pTmp2);
|
|
_wcsrev(wcsQuery);
|
|
if(wcslen(pTmp4) > 0 && wcslen(pTmp2) > 0 && wcslen(pTmp1) &&
|
|
wcscmp(pTmp1,pTmp4) != 0)
|
|
{
|
|
_wcsrev(pTmp4);
|
|
_wcsrev(pTmp2);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = DB_E_ERRORSINCOMMAND;
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
|
|
|
|
// swscanf(wcsQuery,L"%[^.].%[^=]=\"%[^\"]\".%s",pTmp1,pTmp2,pTmp3,pTmp4);
|
|
|
|
if( pTmp1 && pTmp2 && pTmp4)
|
|
{
|
|
SetClassName(pTmp1);
|
|
AllocateAndCopy(m_pwcsMethod,pTmp4);
|
|
AllocateAndCopy(m_pwcsInstance,pTmp2);
|
|
hr = S_OK;
|
|
}
|
|
/*
|
|
swscanf(wcsQuery,L"%[^.].%[^=]=\"%[^\"]\".%s",pTmp1,pTmp2,pTmp3,pTmp4);
|
|
if( pTmp1 && pTmp2 && pTmp3 && pTmp4){
|
|
SetClassName(pTmp1);
|
|
AllocateAndCopy(m_pwcsMethod,pTmp4);
|
|
AllocateAndCopy(m_pwcsInstance,wcsQuery);
|
|
|
|
m_pwcsInstance = new WCHAR[nMax];
|
|
if( m_pwcsInstance ){
|
|
swprintf(m_pwcsInstance,L"%s.%s=\"%s\"",pTmp1,pTmp2,pTmp3);
|
|
hr = S_OK;
|
|
}
|
|
|
|
}
|
|
*/ }
|
|
}
|
|
else{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
SAFE_DELETE_PTR(pTmp1);
|
|
SAFE_DELETE_PTR(pTmp2);
|
|
SAFE_DELETE_PTR(pTmp3);
|
|
SAFE_DELETE_PTR(pTmp4);
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodParameters::ValidMethod()
|
|
{
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if( GetClassName() && m_pwcsInstance && m_pwcsMethod ){
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// The class definition for method
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodClassDefinitionWrapper::CWbemMethodClassDefinitionWrapper(CWbemMethodParameters * parm )
|
|
: CWbemClassDefinitionWrapper(parm)
|
|
{
|
|
m_nMaxColumns = 0;
|
|
m_nCount = 0;
|
|
m_pInClass = NULL;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodClassDefinitionWrapper::~CWbemMethodClassDefinitionWrapper()
|
|
{
|
|
SAFE_RELEASE_PTR( m_pInClass );
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::Init()
|
|
{
|
|
HRESULT hr = DB_E_ERRORSINCOMMAND;
|
|
|
|
//=======================================================================
|
|
// The purpose of this function is to extract the class name and
|
|
// method name from the query string. This query is in the format of:
|
|
// Win32_ProcessHandle="20".GetOwner
|
|
//=======================================================================
|
|
|
|
hr = ((CWbemMethodParameters*) m_pParms)->ExtractNamesFromQuery();
|
|
|
|
//=======================================================================
|
|
// Any other initialization?
|
|
//=======================================================================
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::ValidClass()
|
|
{
|
|
return ((CWbemMethodParameters*) m_pParms)->ValidMethod();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::TotalPropertiesInClass(ULONG & ulPropCount, ULONG &ulSysPropCount)
|
|
{
|
|
//=======================================================================
|
|
// Since we are return the output parameters are the rowset, we are
|
|
// intereseted in the properties of the output parameter class
|
|
//=======================================================================
|
|
HRESULT hr = E_FAIL;
|
|
IWbemClassObject * pClass = NULL;
|
|
|
|
CBSTR bstrClass(((CWbemMethodParameters*) m_pParms)->GetClassName());
|
|
CBSTR bstrMethod(((CWbemMethodParameters*) m_pParms)->GetMethodName());
|
|
CBSTR bstrInstance(((CWbemMethodParameters*) m_pParms)->GetInstanceName());
|
|
|
|
|
|
hr = (m_pParms->GetServicesPtr())->GetObject(bstrClass, 0,m_pParms->GetContext(), &pClass, NULL);
|
|
if( hr == S_OK ){
|
|
|
|
//==========================================================
|
|
// Now, get the list of Input and Output parameters
|
|
//==========================================================
|
|
hr = pClass->GetMethod(bstrMethod, 0, &m_pInClass, &m_pClass);
|
|
if( hr == S_OK ){
|
|
hr = CWbemClassWrapper::TotalPropertiesInClass(ulPropCount,ulSysPropCount);
|
|
}
|
|
|
|
}
|
|
|
|
SAFE_RELEASE_PTR(pClass);
|
|
return hr;
|
|
}
|
|
/*///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::BeginPropertyEnumeration()
|
|
{
|
|
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::EndPropertyEnumeration()
|
|
{
|
|
m_nCount = 0;
|
|
return S_OK;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::GetNextProperty(BSTR * pProperty, VARIANT * vValue, CIMTYPE * pType ,LONG * plFlavor )
|
|
{
|
|
HRESULT hr = WBEM_S_NO_MORE_DATA;
|
|
|
|
if( m_nCount == 1 ){
|
|
*plFlavor = 0l;
|
|
*pType = CIM_BOOLEAN;
|
|
*pProperty = Wmioledb_SysAllocString(L"SUCCESS");
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodClassDefinitionWrapper::BeginPropertyQualifierEnumeration(BSTR strPropName)
|
|
{
|
|
return S_OK;
|
|
}*/
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Method instance list
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodInstanceList::CWbemMethodInstanceList(CWbemMethodParameters * p,CWbemMethodClassDefinitionWrapper * pDef): CWbemInstanceList(p)
|
|
{
|
|
m_pParms = p;
|
|
m_pClassDefinition = pDef;
|
|
m_nBaseType = METHOD_ROWSET;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodInstanceList::~CWbemMethodInstanceList()
|
|
{
|
|
}
|
|
|
|
|
|
HRESULT CWbemMethodInstanceList::GetInputParameterName(IWbemClassObject *pObject,DBORDINAL iOrdinal , BSTR &strPropName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if(SUCCEEDED(hr = pObject->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY)))
|
|
{
|
|
for(DBORDINAL i = 0 ; i < iOrdinal && SUCCEEDED(hr); i++)
|
|
{
|
|
hr = pObject->Next(0,&strPropName,NULL,NULL,NULL);
|
|
if(i != iOrdinal && SUCCEEDED(hr))
|
|
{
|
|
SysFreeString(strPropName);
|
|
}
|
|
}
|
|
pObject->EndEnumeration();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Function gets the input parameter values and puts it to a input parameters object which it returns
|
|
HRESULT CWbemMethodInstanceList::ProcessInputParameters(IWbemClassObject **ppParamInput)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IWbemClassObject *pParamInput = NULL;
|
|
LONG lType = 0;
|
|
CDataMap map;
|
|
VARIANT varParamValue;
|
|
VariantInit(&varParamValue);
|
|
|
|
//===========================================================
|
|
// Enumerate the properties, read them from the parameter
|
|
// list and put them in the input class
|
|
//===========================================================
|
|
if( m_pClassDefinition->GetInputClassPtr() ){
|
|
|
|
((CWbemMethodParameters*)m_pParms)->m_pQuery->m_pcsQuery->Enter();
|
|
|
|
PPARAMINFO pParamInfo;
|
|
ULONG iParam;
|
|
ULONG uCount = ((CWbemMethodParameters*)m_pParms)->m_pQuery->GetParamCount();
|
|
// Spawn an instance of input paramter object
|
|
hr = m_pClassDefinition->GetInputClassPtr()->SpawnInstance(0,&pParamInput);
|
|
|
|
for (iParam = 0; iParam <uCount; iParam++){
|
|
|
|
VariantClear(&varParamValue);
|
|
pParamInfo = (PPARAMINFO)((CWbemMethodParameters*)m_pParms)->m_pQuery->GetParam(iParam);
|
|
if (pParamInfo && (pParamInfo->dwFlags & DBPARAMFLAGS_ISINPUT)){
|
|
|
|
CBSTR bstrProperty(pParamInfo->pwszParamName);
|
|
|
|
if(pParamInfo->pwszParamName == NULL)
|
|
{
|
|
GetInputParameterName(pParamInput,pParamInfo->iOrdinal,(BSTR&)bstrProperty);
|
|
}
|
|
|
|
if(S_OK == (hr = pParamInput->Get(bstrProperty,0,NULL,&lType,NULL)))
|
|
{
|
|
// Call this function to convert the OLEDB bound type to CIMTYPE of the parameter
|
|
hr = map.ConvertToCIMType(pParamInfo->pbData,pParamInfo->wOLEDBType,pParamInfo->cbColLength,lType,varParamValue);
|
|
|
|
// if the value is not empty put the value of the parameter
|
|
if( varParamValue.vt != VT_EMPTY && varParamValue.vt != VT_NULL)
|
|
hr = pParamInput->Put(bstrProperty,0,&varParamValue,0);
|
|
|
|
if( S_OK != hr ){
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
*ppParamInput = NULL;
|
|
hr = pParamInput->QueryInterface(IID_IWbemClassObject , (void **)ppParamInput);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
VariantClear(&varParamValue);
|
|
SAFE_RELEASE_PTR(pParamInput);
|
|
((CWbemMethodParameters*)m_pParms)->m_pQuery->m_pcsQuery->Leave();
|
|
}
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceList::ProcessOutputParameters()
|
|
{
|
|
HRESULT hr = WBEM_E_NOT_FOUND;
|
|
IWbemClassObject * pClass = ((CWbemClassWrapper*) m_pClassDefinition)->GetClass();
|
|
VARIANT varValue;
|
|
VariantInit(&varValue);
|
|
//===========================================================
|
|
// Enumerate the properties, read them and update the values
|
|
// in the parameter list
|
|
//===========================================================
|
|
|
|
if( pClass ){
|
|
hr = S_OK;
|
|
((CWbemMethodParameters*)m_pParms)->m_pQuery->m_pcsQuery->Enter();
|
|
|
|
PPARAMINFO pParamInfo;
|
|
ULONG iParam;
|
|
ULONG uCount = ((CWbemMethodParameters*)m_pParms)->m_pQuery->GetParamCount();
|
|
|
|
for (iParam = 0; iParam <uCount; iParam++){
|
|
|
|
pParamInfo = (PPARAMINFO)((CWbemMethodParameters*)m_pParms)->m_pQuery->GetParam(iParam);
|
|
|
|
if (pParamInfo && (pParamInfo->dwFlags & DBPARAMFLAGS_ISOUTPUT))
|
|
{
|
|
|
|
CBSTR bstrProperty(pParamInfo->pwszParamName);
|
|
|
|
hr = pClass->Get(bstrProperty,0,&varValue,&(pParamInfo)->CIMType,&(pParamInfo)->Flavor);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
CDataMap map;
|
|
DWORD dwStatus = 0;
|
|
// set the size to the maximum available
|
|
pParamInfo->cbColLength = pParamInfo->ulParamSize;
|
|
hr = map.AllocateAndConvertToOLEDBType(varValue,pParamInfo->CIMType , pParamInfo->wOLEDBType ,
|
|
pParamInfo->pbData , pParamInfo->cbColLength , pParamInfo->dwStatus);
|
|
|
|
|
|
}
|
|
if( S_OK != hr ){
|
|
break;
|
|
}
|
|
VariantClear(&varValue);
|
|
}
|
|
}
|
|
|
|
((CWbemMethodParameters*)m_pParms)->m_pQuery->m_pcsQuery->Leave();
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceList::Reset()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
CBSTR bstrMethod(((CWbemMethodParameters*) m_pParms)->GetMethodName());
|
|
CBSTR bstrInstance(((CWbemMethodParameters*) m_pParms)->GetInstanceName());
|
|
IWbemClassObject ** ppClass = ((CWbemClassWrapper*) m_pClassDefinition)->GetClassPtr();
|
|
|
|
IWbemClassObject *pParamInput = NULL;
|
|
|
|
hr = ProcessInputParameters(&pParamInput);
|
|
|
|
if( S_OK == hr ){
|
|
|
|
hr = (m_pParms->GetServicesPtr())->ExecMethod( bstrInstance,bstrMethod, 0,
|
|
m_pParms->GetContext(),
|
|
m_pClassDefinition->GetInputClassPtr(),
|
|
ppClass, NULL);
|
|
|
|
//====================================================================
|
|
// We should update the DBPARAMS array as well as put these results
|
|
// in a rowset
|
|
//====================================================================
|
|
if( S_OK == hr ){
|
|
hr = ProcessOutputParameters();
|
|
}
|
|
}
|
|
SAFE_RELEASE_PTR(pParamInput);
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceList::NextInstance(CBSTR & Key, CWbemClassInstanceWrapper ** pInst)
|
|
{
|
|
LONG lRelativePos = 1;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
//============================================================
|
|
// Now, we only have one instance of output parameters
|
|
//============================================================
|
|
|
|
|
|
if( m_lCurrentPos == 0 )
|
|
{
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_FetchDir == FETCHDIRBACKWARD)
|
|
lRelativePos = 0;
|
|
|
|
// Check if the instance is already fetched
|
|
*pInst = GetInstance(m_lCurrentPos +lRelativePos);
|
|
if( *pInst == NULL)
|
|
{
|
|
|
|
*pInst = new CWbemMethodInstanceWrapper((CWbemMethodParameters*)m_pParms);
|
|
|
|
if( *pInst ){
|
|
IWbemClassObject * pClass = ((CWbemClassWrapper*) m_pClassDefinition)->GetClass();
|
|
|
|
(*pInst)->SetClass(pClass);
|
|
(*pInst)->SetPos(++m_lCurrentPos);
|
|
AddInstance(*pInst);
|
|
(*pInst)->GetKey(Key);
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_lCurrentPos += lRelativePos;
|
|
m_FetchDir = FETCHDIRFORWARD;
|
|
(*pInst)->GetKey(Key);
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_S_NO_MORE_DATA;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceList::PrevInstance( CBSTR & Key, CWbemClassInstanceWrapper *& pInst)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBROWOFFSET lRelativePos = -1;
|
|
|
|
// IF the direction has changed compared to the previous fetch then
|
|
// the first fetch will be the last one fetched
|
|
if( m_FetchDir == FETCHDIRFORWARD)
|
|
lRelativePos = 0;
|
|
|
|
// Reset the position to the so that
|
|
// NextInstance function gives the instance required
|
|
|
|
hr = ResetRelPosition(lRelativePos);
|
|
pInst = GetInstance(m_lCurrentPos);
|
|
if(pInst != NULL)
|
|
pInst->GetKey(Key);
|
|
|
|
m_FetchDir = FETCHDIRBACKWARD;
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//*************************************************************************************************
|
|
// The Method instance wrapper list
|
|
//*************************************************************************************************
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodInstanceWrapper::CWbemMethodInstanceWrapper(CWbemMethodParameters * p): CWbemClassInstanceWrapper(p)
|
|
{
|
|
|
|
// m_nBaseType = METHOD_ROWSET; // METHOD_ROWSET
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemMethodInstanceWrapper::~CWbemMethodInstanceWrapper()
|
|
{
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceWrapper::ResetInstanceFromKey(CBSTR Key)
|
|
{
|
|
// This doesn't really apply to methods
|
|
return S_OK;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceWrapper::RefreshInstance()
|
|
{
|
|
// This doesn't really apply to methods
|
|
return S_OK;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWbemMethodInstanceWrapper::GetClassName()
|
|
{
|
|
return m_pParms->GetClassName();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemMethodInstanceWrapper::GetKey(CBSTR & Key)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
Key.SetStr(L"OutputParameters");
|
|
return hr;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemCollectionClassDefinitionWrapper class implementation
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionClassDefinitionWrapper::CWbemCollectionClassDefinitionWrapper(CWbemClassParameters * p,
|
|
WCHAR * pstrPath,
|
|
INSTANCELISTTYPE objListType)
|
|
:CWbemClassDefinitionWrapper(p,
|
|
((pstrPath == NULL) || (pstrPath != NULL && wcscmp(pstrPath,OPENCOLLECTION) == 0)) ? FALSE : TRUE)
|
|
{
|
|
m_pstrPath = NULL;
|
|
if((pstrPath == NULL) || (pstrPath != NULL && wcscmp(pstrPath,OPENCOLLECTION) == 0))
|
|
{
|
|
m_objListType = objListType;
|
|
}
|
|
else
|
|
{
|
|
m_objListType = NORMAL;
|
|
}
|
|
}
|
|
|
|
HRESULT CWbemCollectionClassDefinitionWrapper::Initialize(WCHAR * pstrPath)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR *pStrTemp = (WCHAR *)OPENCOLLECTION;
|
|
|
|
if(pstrPath != NULL)
|
|
{
|
|
pStrTemp = pstrPath;
|
|
}
|
|
|
|
m_pstrPath = new WCHAR[wcslen(pStrTemp) + 1];
|
|
if(m_pstrPath)
|
|
{
|
|
wcscpy(m_pstrPath,pStrTemp);
|
|
// function to get the class defination object if required
|
|
hr = Init(m_objListType == NORMAL);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
CWbemCollectionClassDefinitionWrapper::~CWbemCollectionClassDefinitionWrapper()
|
|
{
|
|
SAFE_DELETE_ARRAY(m_pstrPath);
|
|
}
|
|
|
|
HRESULT CWbemCollectionClassDefinitionWrapper::ValidClass()
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWbemCollectionClassDefinitionWrapper::TotalPropertiesInClass(ULONG & ulPropCount, ULONG &ulSysPropCount)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
// if the rowset refers to a mixed rowset then
|
|
// there is only one column in the row
|
|
if(m_objListType != NORMAL)
|
|
{
|
|
ulPropCount = 0;
|
|
ulSysPropCount = 1;
|
|
}
|
|
else
|
|
{
|
|
hr = CWbemClassDefinitionWrapper::TotalPropertiesInClass(ulPropCount,ulSysPropCount);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemCollectionInstanceList class implementation
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CWbemCollectionInstanceList::CWbemCollectionInstanceList(CWbemClassParameters * p,CWbemCollectionManager * pCollectionMgr)
|
|
:CWbemInstanceList(p)
|
|
{
|
|
m_pColMgr = pCollectionMgr;
|
|
}
|
|
|
|
CWbemCollectionInstanceList::~CWbemCollectionInstanceList()
|
|
{
|
|
}
|
|
|
|
HRESULT CWbemCollectionInstanceList::Reset()
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
BOOL bGetInstanceEnum = TRUE;
|
|
//============================================================
|
|
// If we already got an enumeration, reset it, otherwise
|
|
// don't
|
|
//============================================================
|
|
if( m_ppEnum ){
|
|
if(WBEM_FLAG_FORWARD_ONLY & m_pParms->m_dwNavFlags)
|
|
{
|
|
ReleaseAllInstances();
|
|
m_ppEnum->Release();
|
|
m_ppEnum = NULL;
|
|
}
|
|
else
|
|
{
|
|
hr = m_ppEnum->Reset();
|
|
bGetInstanceEnum = FALSE;
|
|
}
|
|
}
|
|
|
|
if(bGetInstanceEnum == TRUE)
|
|
{
|
|
IWbemServicesEx *pServicesEx = NULL;
|
|
|
|
if(SUCCEEDED(hr = m_pParms->GetServicesPtr()->QueryInterface(IID_IWbemServicesEx,(void **)&pServicesEx)))
|
|
{
|
|
long lFlags = 0;
|
|
CBSTR strPath;
|
|
strPath.SetStr(m_pColMgr->GetObjectPath());
|
|
INSTANCELISTTYPE colType = m_pColMgr->GetObjListType();
|
|
|
|
hr = pServicesEx->CreateInstanceEnum(strPath,
|
|
m_pParms->m_dwNavFlags | m_pParms->m_dwQueryFlags,
|
|
m_pParms->GetContext(),
|
|
&m_ppEnum);
|
|
|
|
SAFE_RELEASE_PTR(pServicesEx);
|
|
}
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
m_cTotalInstancesInEnum = 0;
|
|
}
|
|
}
|
|
if(hr == S_OK)
|
|
{
|
|
m_lCurrentPos = 0;
|
|
}
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemCollectionParameters class implementation
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionParameters::CWbemCollectionParameters(DWORD dwFlags,CWbemConnectionWrapper * pWrap ,WCHAR *pClassName)
|
|
: CWbemClassParameters(dwFlags,NULL,pWrap)
|
|
{
|
|
m_pServices = NULL;
|
|
m_pwcsClassName = NULL;
|
|
}
|
|
|
|
CWbemCollectionParameters::~CWbemCollectionParameters()
|
|
{
|
|
SAFE_RELEASE_PTR(m_pServices);
|
|
}
|
|
|
|
HRESULT CWbemCollectionParameters::Init(BSTR strPath,CWbemConnectionWrapper * pWrap)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR * pStrTemp = NULL;
|
|
|
|
if(strPath == NULL || (strPath != NULL && wcscmp(strPath,OPENCOLLECTION) == 0))
|
|
{
|
|
pStrTemp = (WCHAR *)szInstance;
|
|
}
|
|
else
|
|
{
|
|
pStrTemp = strPath;
|
|
}
|
|
|
|
m_pwcsClassName = new WCHAR [wcslen(pStrTemp) + 1];
|
|
if(m_pwcsClassName)
|
|
{
|
|
wcscpy(m_pwcsClassName,pStrTemp);
|
|
hr = pWrap->GetServicesPtr()->QueryInterface(IID_IWbemServices,(void **)&m_pServices);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemCollectionInstanceList class implementation
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionManager::CWbemCollectionManager()
|
|
{
|
|
m_pClassDefinition = NULL;
|
|
m_pInstanceList = NULL;
|
|
m_pInstance = NULL;
|
|
m_pParms = NULL;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionManager::~CWbemCollectionManager()
|
|
{
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Initialization function
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CWbemCollectionManager::Init(CWbemCollectionInstanceList * InstanceList, CWbemCollectionParameters * pParms,CWbemCollectionClassDefinitionWrapper* pDef)
|
|
{
|
|
m_pClassDefinition = pDef;
|
|
m_pInstanceList = InstanceList;
|
|
m_pInstance = NULL;
|
|
m_pParms = pParms;
|
|
|
|
CBSTR strPath;
|
|
strPath.SetStr(GetObjectPath());
|
|
INSTANCELISTTYPE colType = GetObjListType();
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemCollectionInstanceWrapper class implementation
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Consturctor
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionInstanceWrapper::CWbemCollectionInstanceWrapper(CWbemClassParameters * p,CWbemCollectionManager * pWbemColMgr)
|
|
:CWbemClassInstanceWrapper(p)
|
|
{
|
|
m_pColMgr = pWbemColMgr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemCollectionInstanceWrapper::~CWbemCollectionInstanceWrapper()
|
|
{
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Get classname of the object
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
WCHAR * CWbemCollectionInstanceWrapper::GetClassName()
|
|
{
|
|
WCHAR *pClass = NULL;
|
|
BSTR strPropName;
|
|
HRESULT hr = 0;
|
|
|
|
strPropName = Wmioledb_SysAllocString(L"__Class");
|
|
|
|
VARIANT varClassName;
|
|
VariantInit(&varClassName);
|
|
|
|
// Get the class name
|
|
hr = m_pClass->Get(strPropName,0, &varClassName , NULL , NULL);
|
|
|
|
SysFreeString(strPropName);
|
|
|
|
if( hr == S_OK)
|
|
{
|
|
AllocateAndCopy(pClass,varClassName.bstrVal);
|
|
VariantClear(&varClassName);
|
|
}
|
|
|
|
return pClass;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Refreshing the instance
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCollectionInstanceWrapper::GetKey(CBSTR & Key)
|
|
{
|
|
CVARIANT var;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(FAILED(hr = GetProperty(L"__URL",&var)))
|
|
{
|
|
hr = GetProperty(L"__PATH",var );
|
|
}
|
|
if( hr == S_OK )
|
|
{
|
|
Key.SetStr(var.GetStr());
|
|
}
|
|
return MapWbemErrorToOLEDBError(hr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Refreshing the instance
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CWbemCollectionInstanceWrapper::RefreshInstance()
|
|
{
|
|
return CWbemClassInstanceWrapper::RefreshInstance();
|
|
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CWbemSecurityDescriptor class implementaion
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CWbemSecurityDescriptor::CWbemSecurityDescriptor()
|
|
{
|
|
m_strPath = NULL;
|
|
m_pISerEx = NULL;
|
|
m_lSdSize = 0;
|
|
m_pAccessor = NULL;
|
|
m_pIContext = NULL;
|
|
|
|
InitializeSecurityDescriptor(&m_sd,SECURITY_DESCRIPTOR_REVISION);
|
|
|
|
}
|
|
|
|
HRESULT CWbemSecurityDescriptor::Init(IWbemServices *pSer,BSTR strPath,IWbemContext *pContext)
|
|
{
|
|
ULONG lSDSize = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
if(SUCCEEDED(hr = pSer->QueryInterface(IID_IWbemServicesEx , (void**)&m_pISerEx)))
|
|
{
|
|
if(SUCCEEDED(hr = m_pISerEx->GetObject(strPath,0,m_pIContext,&m_pAccessor,NULL)))
|
|
{
|
|
CIMTYPE lType = 0;
|
|
hr = m_pAccessor->Get(CBSTR(L"__SD"),0,&m_sd,&lType,NULL);
|
|
}
|
|
}
|
|
|
|
m_pIContext = pContext;
|
|
if(m_pIContext)
|
|
{
|
|
m_pIContext->AddRef();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
CWbemSecurityDescriptor::~CWbemSecurityDescriptor()
|
|
{
|
|
SAFE_RELEASE_PTR(m_pISerEx);
|
|
SAFE_RELEASE_PTR(m_pAccessor);
|
|
SAFE_RELEASE_PTR(m_pIContext);
|
|
|
|
SAFE_FREE_SYSSTRING(m_strPath);
|
|
}
|
|
|
|
HRESULT CWbemSecurityDescriptor::PutSD()
|
|
{
|
|
HRESULT hr;
|
|
|
|
if(SUCCEEDED(hr = m_pAccessor->Put(CBSTR(L"__SD"),0,&m_sd,VT_ARRAY|VT_UI1)))
|
|
{
|
|
hr = m_pISerEx->PutInstance(m_pAccessor,0,m_pIContext,NULL);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL CWbemSecurityDescriptor::GetSID(TRUSTEE_W *pTrustee, PSID & psid)
|
|
{
|
|
WCHAR *pName = NULL;
|
|
BOOL bLookUp = FALSE;
|
|
PSID psidTemp = NULL;
|
|
ULONG lSID = 0;
|
|
BOOL bRet = TRUE;
|
|
BYTE *pMem = NULL;
|
|
|
|
switch(GetTrusteeFormW(pTrustee))
|
|
{
|
|
case TRUSTEE_IS_NAME:
|
|
pName = GetTrusteeNameW(pTrustee);
|
|
bLookUp = TRUE;
|
|
break;
|
|
|
|
// THis is only in windows 2000
|
|
case TRUSTEE_IS_OBJECTS_AND_NAME:
|
|
pName = ((OBJECTS_AND_NAME_W *)GetTrusteeNameW(pTrustee))->ptstrName;
|
|
bLookUp = TRUE;
|
|
break;
|
|
|
|
case TRUSTEE_IS_OBJECTS_AND_SID:
|
|
psidTemp = ((OBJECTS_AND_SID *)GetTrusteeNameW(pTrustee))->pSid;
|
|
break;
|
|
|
|
case TRUSTEE_IS_SID :
|
|
psidTemp = (PSID)GetTrusteeNameW(pTrustee);
|
|
break;
|
|
}
|
|
|
|
if(bLookUp)
|
|
{
|
|
SID_NAME_USE sidNameUseTemp;
|
|
ULONG lDomainName = NULL;
|
|
// Get the length of SID to be allocated
|
|
if(LookupAccountNameW(NULL,pName,NULL,(LPDWORD)&lSID,NULL,(LPDWORD)&lDomainName,&sidNameUseTemp))
|
|
{
|
|
try
|
|
{
|
|
pMem = new BYTE[lSID];
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_ARRAY(pMem);
|
|
throw;;
|
|
}
|
|
psid = (PSID)pMem;
|
|
bRet = LookupAccountNameW(NULL,pName,psid,(LPDWORD)&lSID,NULL,(LPDWORD)&lDomainName,&sidNameUseTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lSID = (ULONG)GetLengthSid(psidTemp);
|
|
try
|
|
{
|
|
pMem = new BYTE[lSID];
|
|
}
|
|
catch(...)
|
|
{
|
|
SAFE_DELETE_ARRAY(pMem);
|
|
throw;;
|
|
}
|
|
psid = (PSID)pMem;
|
|
bRet = CopySid(lSID,psid,psidTemp);
|
|
}
|
|
|
|
if(!bRet)
|
|
{
|
|
SAFE_DELETE_ARRAY(pMem);
|
|
psid = NULL;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|