//---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1996
//
//  File:      cenumgrp.cxx
//
//  Contents:  LDAP GroupCollection Enumeration Code
//
//              CLDAPGroupCollectionEnum::
//              CLDAPGroupCollectionEnum::
//              CLDAPGroupCollectionEnum::
//              CLDAPGroupCollectionEnum::
//
//  History:
//----------------------------------------------------------------------------
#include "ldap.hxx"
#pragma hdrstop

HRESULT
BuildADsPathFromLDAPPath(
    LPWSTR szNamespace,
    LPWSTR szLdapDN,
    LPWSTR * ppszADsPathName
    );


//+---------------------------------------------------------------------------
//
//  Function:   LDAPEnumVariant::Create
//
//  Synopsis:
//
//  Arguments:  [pCollection]
//              [ppEnumVariant]
//
//  Returns:    HRESULT
//
//  Modifies:
//
//  History:    01-30-95   krishnag     Created.
//
//----------------------------------------------------------------------------
HRESULT
CLDAPGroupCollectionEnum::Create(
    CLDAPGroupCollectionEnum FAR* FAR* ppenumvariant,
    BSTR Parent,
    BSTR ADsPath,
    BSTR GroupName,
    VARIANT vMembers,
    VARIANT vFilter,
    CCredentials& Credentials,
    IDirectoryObject * pIDirObj,
    BOOL fRangeRetrieval
    )
{
    HRESULT hr = NOERROR;
    CLDAPGroupCollectionEnum FAR* penumvariant = NULL;
    long lLBound = 0;
    long lUBound = 0;

    *ppenumvariant = NULL;

    penumvariant = new CLDAPGroupCollectionEnum();
    if (!penumvariant) {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    penumvariant->_fRangeRetrieval = fRangeRetrieval;

    hr = ADsAllocString( Parent , &penumvariant->_Parent);
    BAIL_ON_FAILURE(hr);

    hr = ADsAllocString(GroupName, &penumvariant->_GroupName);
    BAIL_ON_FAILURE(hr);

    hr = ADsAllocString(ADsPath, &penumvariant->_ADsPath);
    BAIL_ON_FAILURE(hr);

    hr = VariantCopy( &penumvariant->_vMembers, &vMembers );
    BAIL_ON_FAILURE(hr);

    if ( vMembers.vt == VT_BSTR )  // 1 member only
    {
        penumvariant->_lMembersCount = 1;
    }
    else
    {
        hr = SafeArrayGetLBound(V_ARRAY(&penumvariant->_vMembers),
                                1,
                                (long FAR *)&lLBound
                                );
        BAIL_ON_FAILURE(hr);

        hr = SafeArrayGetUBound(V_ARRAY(&penumvariant->_vMembers),
                                1,
                                (long FAR *)&lUBound
                                );
        BAIL_ON_FAILURE(hr);

        penumvariant->_lMembersCount = lUBound - lLBound + 1;
   }

   hr = ObjectTypeList::CreateObjectTypeList(
                    vFilter,
                    &penumvariant->_pObjList
                    );
    BAIL_ON_FAILURE(hr);

    penumvariant->_Credentials = Credentials;

    pIDirObj->QueryInterface(
                  IID_IDirectoryObject,
                  (void **) &(penumvariant->_pIDirObj)
                  );
    BAIL_ON_FAILURE(hr);

    *ppenumvariant = penumvariant;

    RRETURN(hr);

error:
    delete penumvariant;

    RRETURN_EXP_IF_ERR(hr);
}

//----------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//----------------------------------------------------------------------------
CLDAPGroupCollectionEnum::CLDAPGroupCollectionEnum()
    :   _Parent(NULL),
        _ADsPath(NULL),
        _GroupName(NULL),
        _lCurrentIndex(0),
        _lMembersCount(0),
        _pIDirObj(NULL),
        _fRangeRetrieval(FALSE),
        _fAllRetrieved(FALSE),
        _pszRangeToFetch(NULL),
        _pAttributeEntries(NULL),
        _pCurrentEntry(NULL),
        _dwCurRangeIndex(0),
        _dwCurRangeMax(0),
        _dwNumEntries(0),
        _fLastSet(FALSE)
{
    VariantInit( &_vMembers );
    _pObjList = NULL;

}

//----------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//----------------------------------------------------------------------------
CLDAPGroupCollectionEnum::CLDAPGroupCollectionEnum( ObjectTypeList ObjList )
    :   _Parent(NULL),
        _ADsPath(NULL),
        _GroupName(NULL),
        _lCurrentIndex(0),
        _lMembersCount(0)
{
    VariantInit( &_vMembers );
    _pObjList = NULL;
}

//----------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//----------------------------------------------------------------------------
CLDAPGroupCollectionEnum::~CLDAPGroupCollectionEnum()
{
    VariantClear( &_vMembers );
    delete _pObjList;

    if ( _Parent )
        ADsFreeString( _Parent );

    if ( _GroupName )
        ADsFreeString( _GroupName );

    if ( _ADsPath )
        ADsFreeString( _ADsPath );

    if (_pIDirObj) {
        _pIDirObj->Release();
    }

    if (_pszRangeToFetch) {
        FreeADsStr(_pszRangeToFetch);
    }

    if (_pAttributeEntries) {
        FreeADsMem(_pAttributeEntries);
    }

}

//----------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CLDAPGroupCollectionEnum::EnumGroupMembers(
    ULONG cElements,
    VARIANT FAR* pvar,
    ULONG FAR* pcElementFetched
    )
{
    HRESULT hr = S_FALSE;
    IDispatch *pDispatch = NULL;
    DWORD i = 0;

    IADs * pIADs = NULL;
    BSTR pszClass = NULL;
    DWORD dwClassID;
    BSTR pszFilterName = NULL;
    BOOL fFound = FALSE;
    BOOL fEmpty = TRUE;

    while (i < cElements) {

        hr = GetUserMemberObject(&pDispatch);
        if (FAILED(hr)) {
            //
            // Set hr to S_FALSE as all our enumerators are not
            // built to handle a failure hr but only S_OK and S_FALSE.
            //
            hr = S_FALSE;
        }

        if (hr == S_FALSE) {
            break;
        }


        //
        // Apply the IADsMembers::put_Filter filter.
        // If the enumerated object is not one of the types to be returned,
        // go on to the next member of the group.
        //
        
        hr = pDispatch->QueryInterface(IID_IADs, (void **)&pIADs);
        BAIL_ON_FAILURE(hr);

        //
        // To check whether use specifies filter
        //
        fEmpty = _pObjList->IsEmpty();

        //
        // User specifies the filter
        //
        if (!fEmpty) {

            //
            // Determine the object class of the enumerated object and the corresponding
            // object class ID number (as specified in the Filters global array).
            //
            hr = pIADs->get_Class(&pszClass);
            BAIL_ON_FAILURE(hr);
            

            //
            // Enumerate through the object classes listed in the user-specified filter
            // until we either find a match (fFound = TRUE) or we reach the end of the
            // list.
            //
            hr = _pObjList->Reset();

            //
            // compare with the user defined filter
            //
            while (SUCCEEDED(hr)) {
                hr = _pObjList->GetCurrentObject(&pszFilterName);

                if (SUCCEEDED(hr)
                    && (!_wcsicmp(pszClass, pszFilterName))
                    ) {

                    fFound = TRUE;
                    
                    if(pszFilterName) {
                	    SysFreeString(pszFilterName);
                	    pszFilterName = NULL;
                    }
                    break;
                }

                if(pszFilterName) {
                	SysFreeString(pszFilterName);
                	pszFilterName = NULL;
                }

                hr = _pObjList->Next();
            }

            if (!fFound) {
                // 
                // not on the list of objects to return, try again
                // with the next member of the group
                //
                pDispatch->Release();

                pIADs->Release();
                
                if (pszClass) {
                    ADsFreeString(pszClass);
                    pszClass = NULL;
                }
                
                continue;
            }

            pIADs->Release();
        
            if (pszClass) {
                ADsFreeString(pszClass);
                pszClass = NULL;
            }

        }

        //
        // Return it.
        // 
        VariantInit(&pvar[i]);
        pvar[i].vt = VT_DISPATCH;
        pvar[i].pdispVal = pDispatch;
        (*pcElementFetched)++;
        i++;      
        
        
    }
    RRETURN_EXP_IF_ERR(hr);

error:

    if (pDispatch) {
        pDispatch->Release();
    }

    if (pIADs) {
        pIADs->Release();
    }

    if (pszClass) {
        ADsFreeString(pszClass);
    }

    RRETURN_EXP_IF_ERR(hr);    
}

//----------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CLDAPGroupCollectionEnum::GetUserMemberObject(
    IDispatch ** ppDispatch
    )
{
    HRESULT hr = S_OK;
    VARIANT v;
    IUnknown *pObject = NULL;
    TCHAR *pszADsPath = NULL;
    LPWSTR pszUserName = NULL;
    LPWSTR pszPassword = NULL;
    DWORD dwAuthFlags = 0;
    BOOL fRangeUsed = FALSE;

    hr = _Credentials.GetUserName(&pszUserName);
    BAIL_ON_FAILURE(hr);

    hr = _Credentials.GetPassword(&pszPassword);
    BAIL_ON_FAILURE(hr);

    dwAuthFlags = _Credentials.GetAuthFlags();

    while ( TRUE )
    {
        VariantInit(&v);

        if ( _lCurrentIndex >= _lMembersCount ) {
            hr = S_FALSE;
            //
            // See if we need to fetch members using Rangeretrieval.
            //
            if (_fRangeRetrieval && !_fAllRetrieved) {
                hr = GetNextMemberRange(&v);
                BAIL_ON_FAILURE(hr);

                if (hr == S_FALSE) {
                    goto error;
                }

                fRangeUsed = TRUE;
            }
            else
                goto error;
        }

        //
        // Variant v will have correct value already if range
        // retrieval was used.
        //
        if (!fRangeUsed) {

            if ( _vMembers.vt == VT_BSTR )
            {
                hr = VariantCopy( &v, &_vMembers );
            }
            else
            {
                hr = SafeArrayGetElement( V_ARRAY(&_vMembers), &_lCurrentIndex, &v);
            }

            BAIL_ON_FAILURE(hr);

        }

        _lCurrentIndex++;

        LPTSTR pszMember = V_BSTR(&v);
        LPTSTR pszTemp = NULL;

        hr = BuildADsPathFromLDAPPath( _Parent, pszMember, &pszADsPath );
        BAIL_ON_FAILURE(hr);

        hr = ADsOpenObject(
                    pszADsPath,
                    pszUserName,
                    pszPassword,
                    dwAuthFlags,
                    IID_IUnknown,
                    (LPVOID *)&pObject
                    );


        if ( pszADsPath )
        {
            FreeADsStr( pszADsPath );
            pszADsPath = NULL;
        }

        if (pszPassword) {
            FreeADsStr(pszPassword);
            pszPassword = NULL;
        }

        if (pszUserName) {
            FreeADsStr(pszUserName);
            pszUserName = NULL;
        }

        VariantClear(&v);

        //
        // If we failed to get the current object, continue with the next one
        //
        if ( FAILED(hr))
            continue;

        hr = pObject->QueryInterface(
                          IID_IDispatch,
                          (LPVOID *) ppDispatch );
        BAIL_ON_FAILURE(hr);

        pObject->Release();

        RRETURN(S_OK);
    }

error:

    if ( pObject )
        pObject->Release();

    if ( pszADsPath )
        FreeADsStr( pszADsPath );

    if (pszPassword) {
        FreeADsStr(pszPassword);
    }

    if (pszUserName) {
        FreeADsStr(pszUserName);
    }

    VariantClear(&v);

    *ppDispatch = NULL;

    RRETURN(hr);

}

//+---------------------------------------------------------------------------
//
//  Function:   CLDAPGroupCollectionEnum::Next
//
//  Synopsis:   Returns cElements number of requested NetOle objects in the
//              array supplied in pvar.
//
//  Arguments:  [cElements] -- The number of elements requested by client
//              [pvar] -- ptr to array of VARIANTs to for return objects
//              [pcElementFetched] -- if non-NULL, then number of elements
//                                 -- actually returned is placed here
//
//  Returns:    HRESULT -- S_OK if number of elements requested are returned
//                      -- S_FALSE if number of elements is < requested
//
//  Modifies:
//
//  History:    11-3-95   krishnag     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CLDAPGroupCollectionEnum::Next(
    ULONG cElements,
    VARIANT FAR* pvar,
    ULONG FAR* pcElementFetched
    )
{
    ULONG cElementFetched = 0;
    HRESULT hr = S_OK;

    hr = EnumGroupMembers(
            cElements,
            pvar,
            &cElementFetched
            );

    if (pcElementFetched) {
        *pcElementFetched = cElementFetched;
    }
    RRETURN_EXP_IF_ERR(hr);
}



HRESULT
CLDAPGroupCollectionEnum::UpdateRangeToFetch()
{
    HRESULT hr = S_OK;
    WCHAR szPath[512];

    //
    // szPath should be big enough to handle any range we
    // can reasonably expect and will be used to build the
    // member string.
    //

    if (_pszRangeToFetch == NULL) {
        //
        // Rather than ask for the first n elements again,
        // we can use the count we have in the variant array
        // to decide where we need to start.
        //

        wsprintf(szPath, L"member;range=%d-*", _lMembersCount);

        _pszRangeToFetch = AllocADsStr(szPath);
        if (!_pszRangeToFetch) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
    }
    else {
        //
        // In this case the call to GetObjectAttr has been made
        // and we need to get the info out of the name.
        //
        BOOL fUpdated = FALSE;
        for (DWORD i = 0; (i < _dwNumEntries) && !fUpdated; i++) {
            LPWSTR pszTemp = NULL;
            LPWSTR pszAttrName = _pAttributeEntries[i].pszAttrName;
            LPWSTR pszStar = NULL;

            if (wcslen(pszAttrName) > wcslen(L"member;range=")) {
                //
                // See if we have our string
                //
                if (!_wcsnicmp(
                         pszAttrName,
                         L"member;range=",
                         wcslen(L"member;range")
                         )
                    ) {

                    _pCurrentEntry = &(_pAttributeEntries[i]);
                    _dwCurRangeMax = _pCurrentEntry->dwNumValues;
                    _dwCurRangeIndex = 0;
                    pszTemp = wcschr(pszAttrName, L'=');

                    if (!pszTemp) {
                        //
                        // No chance of recovery from this.
                        //
                        BAIL_ON_FAILURE(hr = E_FAIL);
                    }

                    //
                    // Move the lower part of range.
                    //
                    *pszTemp++;
                    if (!*pszTemp) {
                        BAIL_ON_FAILURE(hr = E_FAIL);
                    }

                    pszStar = wcschr(pszTemp, L'*');
                    if (pszStar) {
                        //
                        // Do not bother with any udpate of the range,
                        // we have all the entries.
                        //
                        _fLastSet = TRUE;
                        goto error;
                    }

                    DWORD dwLower = 0;
                    DWORD dwHigher = 0;

                    if (!swscanf(pszTemp, L"%d-%d", &dwLower, &dwHigher)) {
                        BAIL_ON_FAILURE(hr = E_FAIL);
                    }

                    dwHigher++;
                    wsprintf(szPath, L"member;range=%d-*", dwHigher);

                    FreeADsStr(_pszRangeToFetch);
                    _pszRangeToFetch = AllocADsStr(szPath);
                    if (!_pszRangeToFetch) {
                        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
                    }

                    //
                    // Set flag so we can get out of the loop.
                    //
                    fUpdated = TRUE;

                } // this was not member;

            } // is the length greater than that of member;

        } // for each entry in attribute entries.

        if (!fUpdated) {
            //
            // Failed cause there was no members or a range.
            //
            BAIL_ON_FAILURE(hr = E_FAIL);
        }
    } // _pszRangeToFetch was non NULL


error:

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function:   CLDAPGroupCollectionEnum::GetNextMemberRange
//
//  Synopsis:   Returns a variant bstr with the dn of the next member in
//              the group or FALSE if there are no more. This routine will
//              will use IDirectoryObject to fetch more members if applicable.
//
//
//  Arguments:  [pVarMemberBstr] -- ptr to VARIANT for return bstr.
//
//  Returns:    HRESULT -- S_OK if number of elements requested are returned
//                      -- S_FALSE if number of elements is < requested
//                      -- Other failure hr's.
//  Modifies:
//
//  History:    9-12-99   AjayR    Created.
//
//----------------------------------------------------------------------------
HRESULT
CLDAPGroupCollectionEnum::GetNextMemberRange(
    VARIANT FAR* pVarMemberBstr
    )
{
    HRESULT hr = S_FALSE;

    if (_fAllRetrieved) {
        RRETURN(S_FALSE);
    }

    //
    // Initialize the range to fetch if applicable.
    //
    if (_pszRangeToFetch == NULL) {
        hr = UpdateRangeToFetch();
        BAIL_ON_FAILURE(hr);
    }

    if (_dwCurRangeIndex == _dwCurRangeMax) {
        //
        // Call into wrapper for GetObjectAttributes.
        //
        if (_fLastSet) {
            _fAllRetrieved = TRUE;
            hr = S_FALSE;
        }
        else {
            hr = UpdateAttributeEntries();
            BAIL_ON_FAILURE(hr);
        }

        if (hr == S_FALSE) {
            goto error;
        }
    }

    //
    // At this point we should have the entries in our current
    // return set.
    //
    if (!_pCurrentEntry) {
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    if (_dwCurRangeIndex < _dwCurRangeMax) {

        hr = ADsAllocString(
                 _pCurrentEntry->pADsValues[_dwCurRangeIndex].DNString,
                 &V_BSTR(pVarMemberBstr)
                );
        BAIL_ON_FAILURE(hr);
    }

    _dwCurRangeIndex++;

error:

    RRETURN(hr);
}

HRESULT
CLDAPGroupCollectionEnum::UpdateAttributeEntries()
{
    HRESULT hr = S_OK;
    LPWSTR aStrings[2];

    ADsAssert(_pszRangeToFetch || !"Range is NULL internal error");

    if (_pAttributeEntries) {
        FreeADsMem(_pAttributeEntries);
        _pAttributeEntries = NULL;
    }

    aStrings[0] = _pszRangeToFetch;
    aStrings[1] = NULL;


    hr = _pIDirObj->GetObjectAttributes(
                        aStrings,
                        1,
                        &_pAttributeEntries,
                        &_dwNumEntries
                        );

    BAIL_ON_FAILURE(hr);

    if (_dwNumEntries == 0) {
        hr = S_FALSE;
    }
    else {
        //
        // Will return error if member was not there.
        //
        hr = UpdateRangeToFetch();
        BAIL_ON_FAILURE(hr);
    }

error:

    RRETURN(hr);
}