You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
812 lines
21 KiB
812 lines
21 KiB
//----------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: cumicurs.cxx
|
|
//
|
|
// Contents: Contains the UMI cursor object implementation. There are 2
|
|
// ways to use this object. One is to initialize with an
|
|
// IADsContainer pointer and the other is to use an IUmiQuery obj.
|
|
//
|
|
// History: 03-16-00 SivaramR Created (in WinNT)
|
|
// 03-28-00 AjayR modified for LDAP.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "ldap.hxx"
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::CUmiCursor
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: N/A
|
|
//
|
|
// Modifies: N/A
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CUmiCursor::CUmiCursor():
|
|
_pPropMgr(NULL),
|
|
_ulErrorStatus(0),
|
|
_pIID(NULL),
|
|
_pContainer(NULL),
|
|
_pEnum(NULL),
|
|
_pSearchHelper(NULL),
|
|
_fQuery(FALSE)
|
|
{
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::~CUmiCursor
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: N/A
|
|
//
|
|
// Modifies: N/A
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CUmiCursor::~CUmiCursor()
|
|
{
|
|
if (_pPropMgr) {
|
|
delete _pPropMgr;
|
|
}
|
|
|
|
if (_pContainer) {
|
|
_pContainer->Release();
|
|
}
|
|
|
|
if (_pIID){
|
|
FreeADsMem(_pIID);
|
|
}
|
|
|
|
if (_pEnum) {
|
|
_pEnum->Release();
|
|
}
|
|
|
|
if (_pSearchHelper) {
|
|
delete _pSearchHelper;
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::CreateCursor (static constructor overloaded)
|
|
//
|
|
// Synopsis: Creats a UmiCursor object in the container mode.
|
|
//
|
|
// Arguments: *pCont - Pointer to container we are enumerating.
|
|
// iid - IID requested on returned object.
|
|
// ppInterface - Ptr to return value.
|
|
//
|
|
// Returns: HRESULT - S_OK or any failure error code.
|
|
//
|
|
// Modifies: ppInterface to point to new cursor object.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CUmiCursor::CreateCursor(
|
|
IUnknown *pCont,
|
|
REFIID iid,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
CUmiCursor *pCursor = NULL;
|
|
CPropertyManager *pPropMgr = NULL;
|
|
IADsContainer *pContainer = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
ADsAssert(ppInterface);
|
|
ADsAssert(pCont);
|
|
|
|
pCursor = new CUmiCursor();
|
|
if (!pCursor) {
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
}
|
|
|
|
//
|
|
// Initialize the various params on this object.
|
|
//
|
|
hr = CPropertyManager::CreatePropertyManager(
|
|
(IUnknown *) pCursor,
|
|
NULL, // IADs ptr
|
|
NULL, // pCreds
|
|
IntfPropsCursor,
|
|
&pPropMgr
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pCont->QueryInterface(
|
|
IID_IADsContainer,
|
|
(void **) &pContainer
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pCursor->QueryInterface(iid, ppInterface);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// Ref on this object is now 2, release the additional ref.
|
|
//
|
|
pCursor->Release();
|
|
|
|
pCursor->_pContainer = pContainer;
|
|
pCursor->_pPropMgr = pPropMgr;
|
|
pCursor->_pIID = NULL;
|
|
pCursor->_ulErrorStatus = 0;
|
|
|
|
|
|
RRETURN(S_OK);
|
|
|
|
error:
|
|
|
|
if (pCursor) {
|
|
delete pCursor;
|
|
}
|
|
|
|
if (pPropMgr) {
|
|
delete pPropMgr;
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::CreateCursor (static constructor overloaded).
|
|
//
|
|
// Synopsis: Creats a UmiCursor object in the query mode. Most of the
|
|
// params are needed for creating the search helper object.
|
|
//
|
|
// Arguments: pQuery - Query being executed.
|
|
// pConnection - Connection being used for query.
|
|
// pUnk - ???.
|
|
// pszADsPath - Path of object query is being executed on.
|
|
// pszLdapServer - Server of object being queried.
|
|
// pszLdapDn - Dn of the object being searched.
|
|
// cCredentials - Credentials to use for query.
|
|
// dwPort - Port being used for connection.
|
|
// iid - Cursor iid requested
|
|
//
|
|
// Returns: HRESULT - S_OK or any failure error code.
|
|
//
|
|
// Modifies: ppInterface to point to new cursor object.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CUmiCursor::CreateCursor(
|
|
IUmiQuery *pQuery,
|
|
IUmiConnection *pConnection,
|
|
IUnknown *pUnk,
|
|
LPCWSTR pszADsPath,
|
|
LPCWSTR pszLdapServer,
|
|
LPCWSTR pszLdapDn,
|
|
CCredentials cCredentials,
|
|
DWORD dwPort,
|
|
REFIID iid,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
CUmiCursor *pCursor = NULL;
|
|
CPropertyManager *pPropMgr = NULL;
|
|
HRESULT hr = S_OK;
|
|
CUmiSearchHelper *pSearchHelper = NULL;
|
|
|
|
ADsAssert(ppInterface);
|
|
|
|
hr = CUmiSearchHelper::CreateSearchHelper(
|
|
pQuery,
|
|
pConnection,
|
|
pUnk,
|
|
pszADsPath,
|
|
pszLdapServer,
|
|
pszLdapDn,
|
|
cCredentials,
|
|
dwPort,
|
|
&pSearchHelper
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pCursor = new CUmiCursor();
|
|
if (!pCursor) {
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
}
|
|
|
|
//
|
|
// Initialize the various params on this object.
|
|
//
|
|
hr = CPropertyManager::CreatePropertyManager(
|
|
(IUnknown *) pCursor,
|
|
NULL, // pIADs
|
|
NULL, // pCreds
|
|
IntfPropsCursor,
|
|
&pPropMgr
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pCursor->QueryInterface(iid, ppInterface);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// Ref on this object is now 2, release the additional ref.
|
|
//
|
|
pCursor->Release();
|
|
|
|
pCursor->_pSearchHelper = pSearchHelper;
|
|
pCursor->_pPropMgr = pPropMgr;
|
|
pCursor->_pIID = NULL;
|
|
pCursor->_ulErrorStatus = 0;
|
|
pCursor->_fQuery = TRUE;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
error:
|
|
|
|
if (pCursor) {
|
|
delete pCursor;
|
|
}
|
|
|
|
if (pSearchHelper) {
|
|
delete pSearchHelper;
|
|
}
|
|
|
|
if (pPropMgr) {
|
|
delete pPropMgr;
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::QueryInterface (IUnknown interface).
|
|
//
|
|
// Synopsis: Standard QueryInterface function.
|
|
//
|
|
// Arguments: Self explanatory.
|
|
//
|
|
// Returns: S_OK on success or any suitable error code.
|
|
//
|
|
// Modifies: *ppInterface to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::QueryInterface(
|
|
REFIID iid,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
if (!ppInterface)
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
if (IsEqualIID(iid, IID_IUnknown)) {
|
|
*ppInterface = (IUmiCursor *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IUmiBaseObject)) {
|
|
*ppInterface = (IUmiCursor *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IUmiPropList)) {
|
|
*ppInterface = (IUmiCursor *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IUmiCursor)) {
|
|
*ppInterface = (IUmiCursor *) this;
|
|
}
|
|
else {
|
|
*ppInterface = NULL;
|
|
RRETURN(E_NOINTERFACE);
|
|
}
|
|
|
|
AddRef();
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::GetLastStatus (IUmiBaseObject method).
|
|
//
|
|
// Synopsis: Returns only numeric status code from the last operation.
|
|
//
|
|
// Arguments: uFlags - Only 0 is supported for now.
|
|
// puSpecificStatus - Returns status/error code.
|
|
// riid - Not used.
|
|
// pStatusObj - NULL, not used currently.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *puSpecificStatus to return appropriate status code.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::GetLastStatus(
|
|
ULONG uFlags,
|
|
ULONG *puSpecificStatus,
|
|
REFIID riid,
|
|
LPVOID *pStatusObj
|
|
)
|
|
{
|
|
if (uFlags != 0) {
|
|
RRETURN(UMI_E_INVALID_FLAGS);
|
|
}
|
|
|
|
if (!puSpecificStatus) {
|
|
RRETURN(E_INVALIDARG);
|
|
}
|
|
|
|
if (pStatusObj) {
|
|
//
|
|
// Should we error out ?
|
|
//
|
|
*pStatusObj = NULL;
|
|
}
|
|
|
|
*puSpecificStatus = _ulErrorStatus;
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::GetInterfacePropList (IUmiBaseObject method).
|
|
//
|
|
// Synopsis: Returns a pointer to the interface property list for
|
|
// cursor object.
|
|
//
|
|
// Arguments: uFlags - Flags, only 0 is supported.
|
|
// ppPropList - Return value.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pPropList changed to IUmiPropList pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::GetInterfacePropList(
|
|
ULONG uFlags,
|
|
IUmiPropList **ppPropList
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if (uFlags != 0) {
|
|
RRETURN(UMI_E_INVALID_FLAGS);
|
|
}
|
|
|
|
if (!ppPropList) {
|
|
RRETURN(E_INVALIDARG);
|
|
}
|
|
|
|
hr = _pPropMgr->QueryInterface(IID_IUmiPropList, (void **)ppPropList);
|
|
|
|
if (FAILED(hr)) {
|
|
SetLastStatus(hr);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::SetLastStatus (internal private helper routine).
|
|
//
|
|
// Synopsis: Sets the status of the last operation. If the status is one
|
|
// of the pre-defined error codes, then the status is just set to
|
|
// 0 since we are not adding any value by returning the same
|
|
// status as the error code.
|
|
//
|
|
// Arguments: ulStatus - Status to be set.
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// Modifies: Internal member status variable.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CUmiCursor::SetLastStatus(ULONG ulStatus)
|
|
{
|
|
this->_ulErrorStatus = ulStatus;
|
|
|
|
return;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::SetIID (IUmiCursor method).
|
|
//
|
|
// Synopsis: Sets the interface to be requested off each item returned by
|
|
// the enumerator. Default is IID_IUmiObject.
|
|
//
|
|
// Arguments: riid - IID of interface to request.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::SetIID(
|
|
REFIID riid
|
|
)
|
|
{
|
|
SetLastStatus(0);
|
|
|
|
if (_fQuery) {
|
|
RRETURN(this->_pSearchHelper->SetIID(riid));
|
|
}
|
|
else {
|
|
if (!_pIID){
|
|
|
|
_pIID = (IID *) AllocADsMem(sizeof(IID));
|
|
if (!_pIID){
|
|
RRETURN(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
|
|
memcpy(_pIID, &riid, sizeof(IID));
|
|
}
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::Reset (IUmiCursor method).
|
|
//
|
|
// Synopsis: Resets the enumerator to restart from begining (this is for
|
|
// likely to return an error for the IADsContainer case).
|
|
//
|
|
// Arguments: N/A.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: N/A.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::Reset(void)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
RRETURN(hr);
|
|
|
|
//
|
|
// Rest of the code can be invoked when we have proper support.
|
|
//
|
|
SetLastStatus(0);
|
|
|
|
if (!_fQuery) {
|
|
|
|
//
|
|
// it is possible that _pEnum may be NULL here if the user
|
|
// called Reset before calling Next()
|
|
//
|
|
if (!_pEnum) {
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
hr = _pEnum->Reset();
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = S_OK;
|
|
}
|
|
else {
|
|
hr = _pSearchHelper->Reset();
|
|
}
|
|
|
|
error:
|
|
|
|
if (FAILED(hr)) {
|
|
SetLastStatus(hr);
|
|
hr = MapHrToUmiError(hr);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::GetFilter (internal private helper routine).
|
|
//
|
|
// Synopsis: Gets the filter from the interface property cache. If the
|
|
// interface property was not set, an emty variant is returned.
|
|
//
|
|
// Arguments: pvFilter - ptr to variant for return value.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pvFilter to return the filter.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CUmiCursor::GetFilter(VARIANT *pvFilter)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
UMI_PROPERTY_VALUES *pUmiProp = NULL;
|
|
LPWSTR *ppszFilters = NULL;
|
|
DWORD dwNumFilters = 0;
|
|
|
|
ADsAssert(pvFilter);
|
|
|
|
VariantInit(pvFilter);
|
|
|
|
hr = _pPropMgr->Get(
|
|
L"__FILTER",
|
|
0,
|
|
&pUmiProp
|
|
);
|
|
|
|
if (hr == UMI_E_NOT_FOUND) {
|
|
//
|
|
// interface property was not set. Return empty variant.
|
|
//
|
|
RRETURN(hr);
|
|
}
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
ADsAssert(pUmiProp->pPropArray->uType == UMI_TYPE_LPWSTR);
|
|
//
|
|
// Make sure we have data back and that it is not just NULL.
|
|
// We will not get back a NULL string but instead an array with
|
|
// one element that is NULL. That is as good as no filter.
|
|
//
|
|
if (pUmiProp->pPropArray->uCount
|
|
&& pUmiProp->pPropArray->pUmiValue
|
|
&& pUmiProp->pPropArray->pUmiValue->pszStrValue[0]
|
|
) {
|
|
//
|
|
// Valid filter is present.
|
|
//
|
|
ppszFilters = pUmiProp->pPropArray->pUmiValue->pszStrValue;
|
|
dwNumFilters = pUmiProp->pPropArray->uCount;
|
|
|
|
hr = ADsBuildVarArrayStr(ppszFilters, dwNumFilters, pvFilter);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else {
|
|
hr = UMI_E_NOT_FOUND;
|
|
}
|
|
|
|
error:
|
|
|
|
if (pUmiProp) {
|
|
_pPropMgr->FreeMemory(0, pUmiProp);
|
|
}
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CUmiCursor::Next (IUmiCursor method).
|
|
//
|
|
// Synopsis: Returns the next "n" item(s) in the enumeration sequence.
|
|
//
|
|
// Arguments: uNumRequested - Number of items requested.
|
|
// pNumReturned - Returns actual number of objects returned.
|
|
// ppObjects - Array of interface pointers of size
|
|
// *pNumReturned.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pNumReturned to return the number of objects returned
|
|
// *ppObjects to return the interface pointers
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CUmiCursor::Next(
|
|
ULONG uNumRequested,
|
|
ULONG *puNumReturned,
|
|
LPVOID *ppObjects
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;;
|
|
VARIANT vFilter, *pvResults = NULL;
|
|
ULONG ulIndex = 0, uNumReturned = 0, uNumResults = 0;
|
|
IDispatch *pDisp = NULL;
|
|
IUnknown **pUnkArr = NULL, *pTmpUnk = NULL;
|
|
VARIANT vOldFilter;
|
|
BOOL fReplaceFilter = FALSE;
|
|
|
|
SetLastStatus(0);
|
|
VariantInit(&vOldFilter);
|
|
|
|
if ( (!puNumReturned) || (!ppObjects) ){
|
|
RRETURN(E_INVALIDARG);
|
|
}
|
|
|
|
*puNumReturned = 0;
|
|
*ppObjects = NULL;
|
|
|
|
//
|
|
// If this is a query then we need to get the results from the
|
|
// query object.
|
|
//
|
|
if (_fQuery) {
|
|
hr = _pSearchHelper->Next(
|
|
uNumRequested,
|
|
puNumReturned,
|
|
ppObjects
|
|
);
|
|
//
|
|
// MapHrToUmiError
|
|
//
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//
|
|
// If we get here this is a container enumerate.
|
|
//
|
|
VariantInit(&vFilter);
|
|
|
|
if (!_pEnum) {
|
|
//
|
|
// first call to Next()
|
|
//
|
|
ADsAssert(_pContainer);
|
|
|
|
//
|
|
// check if the user set a filter on the cursor
|
|
//
|
|
hr = GetFilter(&vFilter);
|
|
if (SUCCEEDED(hr)) {
|
|
//
|
|
// We need to get the old filter to restore it.
|
|
//
|
|
hr = _pContainer->get_Filter(&vOldFilter);
|
|
if (SUCCEEDED(hr)) {
|
|
fReplaceFilter = TRUE;
|
|
}
|
|
//
|
|
// We have a valid filter that we need to set.
|
|
//
|
|
hr = _pContainer->put_Filter(vFilter);
|
|
}
|
|
else if (hr == UMI_E_NOT_FOUND) {
|
|
//
|
|
// Reset error as this one is expected, anything else we bail.
|
|
//
|
|
hr = S_OK;
|
|
}
|
|
//
|
|
// Catch either GetFilter failure or put_Filter failure.
|
|
//
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = _pContainer->get__NewEnum((IUnknown **) &_pEnum);
|
|
//
|
|
// Restore old filter irrespective of ECODE.
|
|
//
|
|
if (fReplaceFilter) {
|
|
_pContainer->put_Filter(vOldFilter);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
//
|
|
// allocate memory for variants to return objects
|
|
//
|
|
pvResults = (VARIANT *) AllocADsMem(uNumRequested * sizeof(VARIANT));
|
|
if (!pvResults) {
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
}
|
|
|
|
hr = _pEnum->Next(
|
|
uNumRequested,
|
|
pvResults,
|
|
&uNumReturned
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (!uNumReturned) {
|
|
//
|
|
// This will handle the S_FALSE case.
|
|
//
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// allocate memory for array of interface pointers to return
|
|
//
|
|
pUnkArr = (IUnknown **) AllocADsMem(uNumReturned * sizeof(IUnknown *));
|
|
if (!pUnkArr) {
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
}
|
|
|
|
//
|
|
// convert the V_DISPATCH variants to the requested interface properties
|
|
//
|
|
for(ulIndex = 0; ulIndex < uNumReturned; ulIndex++) {
|
|
|
|
pDisp = V_DISPATCH(&pvResults[ulIndex]);
|
|
|
|
if (_pIID) {
|
|
hr = pDisp->QueryInterface(*_pIID, (void **) &pTmpUnk);
|
|
}
|
|
else {
|
|
hr = pDisp->QueryInterface(IID_IUmiObject, (void **) &pTmpUnk);
|
|
}
|
|
|
|
//
|
|
// Is this really correct ?
|
|
//
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
pUnkArr[uNumResults] = pTmpUnk;
|
|
uNumResults++;
|
|
}
|
|
|
|
*puNumReturned = uNumResults;
|
|
|
|
if (uNumResults > 0) {
|
|
*ppObjects = pUnkArr;
|
|
}
|
|
else {
|
|
FreeADsMem(pUnkArr);
|
|
}
|
|
|
|
error:
|
|
|
|
VariantClear(&vFilter);
|
|
VariantClear(&vOldFilter);
|
|
|
|
if (pvResults) {
|
|
for(ulIndex = 0; ulIndex < uNumReturned; ulIndex++) {
|
|
VariantClear(&pvResults[ulIndex]);
|
|
}
|
|
|
|
FreeADsMem(pvResults);
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
SetLastStatus(hr);
|
|
hr = MapHrToUmiError(hr);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: Count
|
|
//
|
|
// Synopsis: Counts the number of results returned by the enumerator.
|
|
// Not implemented currently.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// None
|
|
//
|
|
// Returns: E_NOTIMPL for now.
|
|
//
|
|
// Modifies: Nothing.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiCursor::Count(
|
|
ULONG *puNumObjects
|
|
)
|
|
{
|
|
SetLastStatus(0);
|
|
|
|
RRETURN(E_NOTIMPL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: Previous
|
|
//
|
|
// Synopsis: Returnss the previous object returned by the enumerator.
|
|
// Not implemented currently.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// None
|
|
//
|
|
// Returns: E_NOTIMPL for now.
|
|
//
|
|
// Modifies: Nothing.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiCursor::Previous(
|
|
ULONG uFlags,
|
|
LPVOID *pObj
|
|
)
|
|
{
|
|
SetLastStatus(0);
|
|
|
|
RRETURN(E_NOTIMPL);
|
|
}
|