windows-xp/Source/XPSP1/NT/admin/wmi/wbem/adapters/oledb/cwbemwrap.cpp

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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;
}