windows-xp/Source/XPSP1/NT/ds/adsi/nwnds/cdssrch.cxx

//---------------------------------------------------------------------------
//
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995
//
//  File:  cdssrch.cxx
//
//  Contents:  Microsoft ADs NDS Provider Generic Object
//
//
//  History:   03-02-97     ShankSh    Created.
//
//----------------------------------------------------------------------------
#include "nds.hxx"
#pragma hdrstop

const int NO_NDS_RESULT_HANDLES = 32;
const int NO_UNCACHED_RESULTS_TO_KEEP = 3;

static 
HRESULT
NdsValueToADsColumn(
    LPWSTR      pszColumnName,
    DWORD       dwSyntaxId,
    DWORD       dwValues,
    LPBYTE      lpValue,
    ADS_SEARCH_COLUMN * pColumn
    );

static
HRESULT
NdsValueToADsColumnAppend(
    DWORD       dwSyntaxId,
    DWORD       dwValues,
    LPBYTE      lpObject,
    ADS_SEARCH_COLUMN * pColumn
    );

//
// Sets the appropriate search preferences. 
//
HRESULT 
CNDSGenObject::SetSearchPreference(
    IN PADS_SEARCHPREF_INFO pSearchPrefs,
    IN DWORD   dwNumPrefs
    ) 
{   
    HRESULT hr = S_OK;
    BOOL fWarning = FALSE;
    DWORD i;

    if (!pSearchPrefs && dwNumPrefs > 0) {
        RRETURN (E_ADS_BAD_PARAMETER);
    }

    for (i=0; i<dwNumPrefs; i++) {

        pSearchPrefs[i].dwStatus = ADS_STATUS_S_OK;

        switch(pSearchPrefs[i].dwSearchPref) {
        case ADS_SEARCHPREF_ASYNCHRONOUS:
        case ADS_SEARCHPREF_SIZE_LIMIT:
        case ADS_SEARCHPREF_TIME_LIMIT:
        case ADS_SEARCHPREF_TIMEOUT:
        case ADS_SEARCHPREF_PAGESIZE:
        case ADS_SEARCHPREF_PAGED_TIME_LIMIT:
        case ADS_SEARCHPREF_CHASE_REFERRALS:
            //
            // Can't be set
            //
            pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREF;
            fWarning = TRUE;
            continue;
        
        case ADS_SEARCHPREF_DEREF_ALIASES:
            if (pSearchPrefs[i].vValue.dwType != ADSTYPE_INTEGER) {
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
        
            switch (pSearchPrefs[i].vValue.Integer) {
            case ADS_DEREF_NEVER:
                _SearchPref._fDerefAliases = FALSE;
                break;
        
            case ADS_DEREF_ALWAYS:
                _SearchPref._fDerefAliases = TRUE;
                break;
        
            default:
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
            break;
    
        case ADS_SEARCHPREF_ATTRIBTYPES_ONLY:
            if (pSearchPrefs[i].vValue.dwType != ADSTYPE_BOOLEAN) {
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
            _SearchPref._fAttrsOnly = pSearchPrefs[i].vValue.Boolean;
            break;
    
        case ADS_SEARCHPREF_CACHE_RESULTS:
            if (pSearchPrefs[i].vValue.dwType != ADSTYPE_BOOLEAN) {
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
            _SearchPref._fCacheResults = pSearchPrefs[i].vValue.Boolean;
            break;

        case ADS_SEARCHPREF_SEARCH_SCOPE: 
            if (pSearchPrefs[i].vValue.dwType != ADSTYPE_INTEGER) {
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
        
            switch (pSearchPrefs[i].vValue.Integer) {
            case ADS_SCOPE_BASE:
                _SearchPref._dwSearchScope = DS_SEARCH_ENTRY;
                break;
        
            case ADS_SCOPE_ONELEVEL:
                _SearchPref._dwSearchScope = DS_SEARCH_SUBORDINATES;
                break;
        
            case ADS_SCOPE_SUBTREE:
                _SearchPref._dwSearchScope = DS_SEARCH_SUBTREE;
                break;
        
            default:
                pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
                fWarning = TRUE;
                continue;
            }
            break;

        default:
            pSearchPrefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREF;
            fWarning = TRUE;
            continue;

        }
    }

    RRETURN (fWarning ? S_ADS_ERRORSOCCURRED : S_OK);

}


HRESULT
CNDSGenObject::ExecuteSearch(
    IN LPWSTR pszSearchFilter,
    IN LPWSTR * pAttributeNames,
    IN DWORD dwNumberAttributes,
    OUT PADS_SEARCH_HANDLE phSearchHandle
    )
{
    PNDS_SEARCHINFO phSearchInfo = NULL;
    LPWSTR szCurrAttr = NULL;
    DWORD dwAttrNamesLen = 0;
    HRESULT hr = S_OK;
    ULONG i, j;
    LPWSTR pszAttrNameBuffer = NULL, *ppszAttrs = NULL;

    if (!phSearchHandle) {
        RRETURN (E_ADS_BAD_PARAMETER);
    }

    //
    // Allocate search handle
    //
    phSearchInfo = (PNDS_SEARCHINFO) AllocADsMem(sizeof(NDS_SEARCHINFO));
    if(!phSearchInfo) 
        BAIL_ON_FAILURE (hr = E_OUTOFMEMORY);

    hr = AdsNdsGenerateFilterBuffer( 
             _hADsContext,
             pszSearchFilter,
             &phSearchInfo->_pFilterBuf 
             );
    BAIL_ON_FAILURE(hr);

    phSearchInfo->_fADsPathPresent = FALSE;
    phSearchInfo->_fADsPathReturned = FALSE;

    if (dwNumberAttributes == -1) {
        //
        // Specifies returning all attributes
        //

        phSearchInfo->_ppszAttrs = NULL;
        phSearchInfo->_pszAttrNameBuffer = NULL;
        phSearchInfo->_fADsPathPresent = TRUE;
        phSearchInfo->_nAttrs = (DWORD) -1;

    }
    else {
        ppszAttrs = (LPWSTR *) AllocADsMem(
                                  sizeof(LPWSTR) * 
                                  (dwNumberAttributes)
                                  );
        if (!ppszAttrs) 
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

        for (i = 0; i < dwNumberAttributes; i++) 
            dwAttrNamesLen+= (wcslen(pAttributeNames[i]) + 1) * sizeof(WCHAR);

        pszAttrNameBuffer = (LPWSTR) AllocADsMem(
                                         dwAttrNamesLen
                                         );
        if (!pszAttrNameBuffer) 
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

        szCurrAttr = pszAttrNameBuffer;
        for (i = 0, j = 0; i < dwNumberAttributes; i++) {
            wcscpy(szCurrAttr, pAttributeNames[i]);
            ppszAttrs[j] = szCurrAttr;
            szCurrAttr += wcslen(ppszAttrs[j]) + 1;

            if(_wcsicmp(ppszAttrs[j], L"ADsPath") == 0) {
                //
                // ADsPath need not be sent
                // 

                phSearchInfo->_fADsPathPresent = TRUE;
            }
            else  {

                j++;
            }

        }

        phSearchInfo->_ppszAttrs = ppszAttrs;
        phSearchInfo->_nAttrs = j;
        phSearchInfo->_pszAttrNameBuffer = pszAttrNameBuffer;
    }

    phSearchInfo->_lIterationHandle = NO_MORE_ITERATIONS;
    phSearchInfo->_pSearchResults = NULL;
    phSearchInfo->_cSearchResults = 0;
    phSearchInfo->_dwCurrResult = 0;
    phSearchInfo->_cResultPrefetched = 0;
    phSearchInfo->_fCheckForDuplicates = TRUE;
    phSearchInfo->_dwCurrAttr = 0;
    phSearchInfo->_SearchPref = _SearchPref;

    *phSearchHandle = phSearchInfo;

    RRETURN(S_OK);

error:

    if(phSearchInfo) {

        if(phSearchInfo->_ppszAttrs) 
            FreeADsMem(phSearchInfo->_ppszAttrs);

        if(phSearchInfo->_pszAttrNameBuffer) 
            FreeADsMem(phSearchInfo->_pszAttrNameBuffer);

        FreeADsMem(phSearchInfo);
    }

    RRETURN (hr);

}


HRESULT
CNDSGenObject::AbandonSearch(
    IN ADS_SEARCH_HANDLE hSearchHandle
    )
{
    RRETURN(E_NOTIMPL);
}

HRESULT
CNDSGenObject::CloseSearchHandle (
    IN ADS_SEARCH_HANDLE hSearchHandle
    )
{
    HRESULT hr = S_OK;
    PNDS_SEARCHINFO phSearchInfo = (PNDS_SEARCHINFO) hSearchHandle;

    if (!phSearchInfo)
        RRETURN (E_ADS_BAD_PARAMETER);

    if (phSearchInfo->_pFilterBuf) {
        ADsNdsFreeBuffer(phSearchInfo->_pFilterBuf);
    }

    if(phSearchInfo->_ppszAttrs) 
        FreeADsMem(phSearchInfo->_ppszAttrs);

    if(phSearchInfo->_pszAttrNameBuffer) 
        FreeADsMem(phSearchInfo->_pszAttrNameBuffer);

    if (phSearchInfo->_pSearchResults) {

        for (DWORD i=0; i < phSearchInfo->_cSearchResults; i++) {

            // If we're not caching all results, these may already have been freed
            // and set to NULL, but this is okay --- ADsNdsFreeBuffer and 
            // ADsNdsFreeNdsObjInfoList will catch this.

            ADsNdsFreeBuffer(phSearchInfo->_pSearchResults[i]._hSearchResult);
            
            ADsNdsFreeNdsObjInfoList(phSearchInfo->_pSearchResults[i]._pObjects,
                phSearchInfo->_pSearchResults[i]._dwObjects);
            
        }
        FreeADsMem(phSearchInfo->_pSearchResults);
    }

    FreeADsMem(phSearchInfo);
    RRETURN (hr);
}


HRESULT
CNDSGenObject::GetFirstRow(
    IN ADS_SEARCH_HANDLE hSearchHandle
    )
{
    RRETURN(E_NOTIMPL);
}

HRESULT
CNDSGenObject::GetNextRow(
    IN ADS_SEARCH_HANDLE hSearchHandle
    )
{
    HRESULT hr;
    DWORD dwStatus = NO_ERROR;
    PNDS_SEARCH_RESULT pResult, pNextResult, pEvictedResult;
    PADSNDS_OBJECT_INFO   pObject, pNextObject;
    PNDS_SEARCHINFO phSearchInfo = (PNDS_SEARCHINFO) hSearchHandle;
    DWORD dwType;
    DWORD nObjectsSearched;
    DWORD i;

    if (!phSearchInfo) {
        RRETURN(E_ADS_BAD_PARAMETER);
    }                                
    
    if (phSearchInfo->_fCheckForDuplicates) {
        phSearchInfo->_dwCurrAttr = 0;
    }

    //
    // dwCurrResult indexes the location of the array where we have already got
    // information from. If it is < 0, it indicates that there is no information
    // in this searchinfo at all
    //
    if (phSearchInfo->_dwCurrResult < 0)
        RRETURN(S_ADS_NOMORE_ROWS);

    if (phSearchInfo->_pSearchResults) {
        pResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);

        // 
        // If next object is available in current result
        //
        if (pResult->_pObjects &&
            ((pResult->_dwObjectCurrent+1) < pResult->_dwObjects)) {
            pResult->_dwObjectCurrent++;
            RRETURN(S_OK);
        }
        if (pResult->_dwObjectCurrent+1 == pResult->_dwObjects &&
            (phSearchInfo->_cResultPrefetched > 0)) {
            pNextResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult+1]);
            pNextResult->_dwObjectCurrent = 0;
            phSearchInfo->_cResultPrefetched--;

            //
            // If next object points to NULL, it means we have no objects in
            // the next row
            //
            if (!pNextResult->_pObjects)
                RRETURN(S_ADS_NOMORE_ROWS);

            if(phSearchInfo->_fCheckForDuplicates) {
                pObject = pResult->_pObjects + pResult->_dwObjectCurrent;
                pNextObject = pNextResult->_pObjects + pNextResult->_dwObjectCurrent;
                if (!_wcsicmp(pObject->szObjectName, pNextObject->szObjectName)) {
                    //
                    // Duplicates; Skip one more result
                    //
                    //if (pNextResult->_dwObjectCurrent+1 < pNextResult->_dwObjects)
                        pNextResult->_dwObjectCurrent++;
                    //else
                    //    RRETURN(S_ADS_NOMORE_ROWS);
                }
            }
            if( pNextResult->_dwObjectCurrent >= pNextResult->_dwObjects &&
                 phSearchInfo->_lIterationHandle == NO_MORE_ITERATIONS) {
                RRETURN(S_ADS_NOMORE_ROWS);
            }
            else {
                //
                // We have successfully moved onto the next value in the array
                //
                phSearchInfo->_dwCurrResult++;

                if ( (phSearchInfo->_dwCurrResult >= NO_UNCACHED_RESULTS_TO_KEEP) &&
                     !phSearchInfo->_SearchPref._fCacheResults ) {
                    // Not caching --- evict the old result
                    pEvictedResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult-NO_UNCACHED_RESULTS_TO_KEEP]);

                    ADsNdsFreeBuffer(pEvictedResult->_hSearchResult);
                    ADsNdsFreeNdsObjInfoList(pEvictedResult->_pObjects, pEvictedResult->_dwObjects);

                    pEvictedResult->_hSearchResult = NULL;
                    pEvictedResult->_pObjects = NULL;
                    pEvictedResult->_dwObjects = 0;
                    pEvictedResult->_fInUse = FALSE;
                }

                if ( pNextResult->_dwObjectCurrent >= pNextResult->_dwObjects) {
                    // phSearchInfo->_lIterationHandle != NO_MORE_ITERATIONS

                    // We have incremented pNextResult->_dwObjectCurrent past the number
                    // of objects in pNextResult, but there are more iterations left to go.
                    // This can occur if there was exactly one object in pNextResult, that
                    // object is a duplicate of the last object in pResult, and there are
                    // more objects left to retrieve.  (This same case can also occur later
                    // in this function, after calling AdsNdsSearch to get a new result set,
                    // and code was added there as well to handle it.)
                    //
                    // We make it look like we've exhausted the results in pNextResult (which
                    // we have) and recursively get the next row to get the next
                    // result set (which may either be prefetched or retrieved from the server
                    // via AdsNdsSearch).  Since _dwCurrResult has already been
                    // incremented, our pNextResult will be the recursive call's pResult,
                    // it will look like we've exhausted the objects in the result,
                    // and it will fetch the next result.
                    //
                    // We do this here, after the cache eviction code, so that we evict the
                    // _dwCurrentResult-NO_UNCACHED_RESULTS_TO_KEEP result before going on
                    // to _dwCurrentResult+1

                    pNextResult->_dwObjectCurrent = pNextResult->_dwObjects-1;
                    RRETURN(GetNextRow(hSearchHandle));
                }
                else {
                    // We haven't exhausted pNextResult, so we're done
                    RRETURN(S_OK);
                }
            }
        }
        else if( pResult->_dwObjectCurrent+1 == pResult->_dwObjects &&
                 phSearchInfo->_lIterationHandle == NO_MORE_ITERATIONS)
            RRETURN(S_ADS_NOMORE_ROWS);
    }

    if (!phSearchInfo->_pFilterBuf) {
        //
        // querynode not setup yet
        //
        RRETURN (E_FAIL);
    }

    if(!phSearchInfo->_pSearchResults) {
        //
        // Allocate an array of handles to Search Handles
        //
        phSearchInfo->_pSearchResults = (PNDS_SEARCH_RESULT) AllocADsMem(
                                             sizeof(NDS_SEARCH_RESULT) *
                                             NO_NDS_RESULT_HANDLES);
        if(!phSearchInfo->_pSearchResults) {
            hr = E_OUTOFMEMORY;
            goto error;
        }
        phSearchInfo->_dwCurrResult = 0;
        phSearchInfo->_cSearchResults = NO_NDS_RESULT_HANDLES;

        for (i=0; i < phSearchInfo->_cSearchResults; i++) {
            phSearchInfo->_pSearchResults[i]._fInUse = 0;
            phSearchInfo->_pSearchResults[i]._hSearchResult = NULL;
            phSearchInfo->_pSearchResults[i]._pObjects = NULL;
            phSearchInfo->_pSearchResults[i]._dwObjects = 0;
        }

    }
    else {
        phSearchInfo->_dwCurrResult++;
        if (phSearchInfo->_dwCurrResult >= (LONG) phSearchInfo->_cSearchResults) {
            //
            // Need to allocate more memory for handles
            //

            phSearchInfo->_pSearchResults = (PNDS_SEARCH_RESULT) ReallocADsMem(
                                                 (void *) phSearchInfo->_pSearchResults,
                                                 sizeof(NDS_SEARCH_RESULT) *
                                                 phSearchInfo->_cSearchResults,
                                                 sizeof(NDS_SEARCH_RESULT) *
                                                 (phSearchInfo->_cSearchResults +
                                                  NO_NDS_RESULT_HANDLES)
                                                 );
            if(!phSearchInfo->_pSearchResults) {
                hr = E_OUTOFMEMORY;
                goto error;
            }

            for (i=phSearchInfo->_cSearchResults; i < phSearchInfo->_cSearchResults + NO_NDS_RESULT_HANDLES; i++) {
                phSearchInfo->_pSearchResults[i]._fInUse = 0;
                phSearchInfo->_pSearchResults[i]._hSearchResult = NULL;
                phSearchInfo->_pSearchResults[i]._pObjects = NULL;
                phSearchInfo->_pSearchResults[i]._dwObjects = 0;
            }


            phSearchInfo->_cSearchResults += NO_NDS_RESULT_HANDLES;

        }
    }

    pNextResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);
    ADsNdsFreeNdsObjInfoList(pNextResult->_pObjects, pNextResult->_dwObjects);
    pNextResult->_dwObjects = 0;
    pNextResult->_pObjects = NULL;
    pNextResult->_dwObjectCurrent = 0;
    pNextResult->_hSearchResult = NULL;
    pNextResult->_fInUse = TRUE;

    hr = ADsNdsSearch(
             _hADsContext,
             _pszNDSDn,
             _SearchPref._dwSearchScope,
             _SearchPref._fDerefAliases,
             phSearchInfo->_pFilterBuf,
             0,
             _SearchPref._fAttrsOnly ? 
                 DS_ATTRIBUTE_NAMES : DS_ATTRIBUTE_VALUES,
             phSearchInfo->_ppszAttrs,
             phSearchInfo->_nAttrs,
             0,
             &nObjectsSearched,
             &pNextResult->_hSearchResult,
             &phSearchInfo->_lIterationHandle
             );
    BAIL_ON_FAILURE(hr);

   hr = ADsNdsGetObjectListFromBuffer(
                   _hADsContext,
                   pNextResult->_hSearchResult,
                   (PDWORD)&pNextResult->_dwObjects,
                   &pNextResult->_pObjects
                   );
   BAIL_ON_FAILURE(hr);

    if (pNextResult->_dwObjects > 0) {
        pNextResult->_dwObjectCurrent = 0;
        if(phSearchInfo->_fCheckForDuplicates && phSearchInfo->_dwCurrResult > 0) {
            pResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult-1]);
            pObject = pResult->_pObjects + pResult->_dwObjectCurrent;
            pNextObject = pNextResult->_pObjects + pNextResult->_dwObjectCurrent;
            if (!_wcsicmp(pObject->szObjectName, pNextObject->szObjectName)) {
                //
                // Duplicates; Skip one more result
                //
                pNextResult->_dwObjectCurrent++;
            }
        }
        if( pNextResult->_dwObjectCurrent >= pNextResult->_dwObjects &&
             phSearchInfo->_lIterationHandle == NO_MORE_ITERATIONS) {
            phSearchInfo->_dwCurrResult--;
            RRETURN(S_ADS_NOMORE_ROWS);
        }

        if ( !phSearchInfo->_SearchPref._fCacheResults &&
             (phSearchInfo->_dwCurrResult >= NO_UNCACHED_RESULTS_TO_KEEP) ) {
            // Not caching --- evict the old result
            pEvictedResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult-NO_UNCACHED_RESULTS_TO_KEEP]);

            ADsNdsFreeBuffer(pEvictedResult->_hSearchResult);
            ADsNdsFreeNdsObjInfoList(pEvictedResult->_pObjects, pEvictedResult->_dwObjects);

            pEvictedResult->_hSearchResult = NULL;
            pEvictedResult->_pObjects = NULL;
            pEvictedResult->_dwObjects = 0;
            pEvictedResult->_fInUse = FALSE;
        }

        // Above, we test if we have incremented _dwObjectCurrent past the last
        // object in the result AND there are no more iterations.  This would happen
        // if there is exactly one object in this result, and that object is a duplicate
        // of the last object in the previous result (i.e., the _wcsicmp above is executed
        // and returns 0), and there are no more results (no more iterations to go).
        //
        // But, suppose the above conditions are true, EXCEPT that there are still more
        // iterations to go.  Then the above test wouldn't succeed, and we'd return with
        // _dwObjectCurrent == _dwObjects, an invalid condition.
        //
        // In this case, we've exhausted the result and must fetch the next one.
        // We do this by calling GetNextRow again.  Since _dwCurrResult has already been
        // incremented, our pNextResult will be the recursive call's pResult, it will look
        // like we've exhausted the objects in the result, and it will fetch the next result.
        //
        // Note that we do this recursive call after the caching code so that we evict the
        // _dwCurrResult-NO_UNCACHED_RESULTS_TO_KEEP entry before going on to _dwCurrResult+1.
        if( pNextResult->_dwObjectCurrent >= pNextResult->_dwObjects) {
            // phSearchInfo->_lIterationHandle != NO_MORE_ITERATIONS
            pNextResult->_dwObjectCurrent = pNextResult->_dwObjects-1;
            RRETURN(GetNextRow(hSearchHandle));
        }
    

        RRETURN(S_OK);
    }
    else {
        phSearchInfo->_dwCurrResult--;
        RRETURN(S_ADS_NOMORE_ROWS);
    }

error:
    RRETURN(hr);
}

HRESULT
CNDSGenObject::GetPreviousRow(
    IN ADS_SEARCH_HANDLE hSearchHandle
    )
{
    PNDS_SEARCH_RESULT pResult, pPrevResult;
    PNDS_SEARCHINFO phSearchInfo = (PNDS_SEARCHINFO) hSearchHandle;

    if(!phSearchInfo || !phSearchInfo->_pSearchResults)
        RRETURN(E_FAIL);

    if (phSearchInfo->_fCheckForDuplicates) {
        phSearchInfo->_dwCurrAttr = 0;
    }

    if (phSearchInfo->_dwCurrResult < 0)
        RRETURN(S_ADS_NOMORE_ROWS);

    pResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);

    if (pResult->_dwObjectCurrent > 0)
        pResult->_dwObjectCurrent--;
    else if (phSearchInfo->_dwCurrResult > 0) {
        pPrevResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult-1]);

        // Make sure the previous result hasn't been evicted from the cache
        if (!pPrevResult->_fInUse)
            RRETURN(S_ADS_NOMORE_ROWS);

        pPrevResult->_dwObjectCurrent = pPrevResult->_dwObjects-1;
        phSearchInfo->_cResultPrefetched++;
        phSearchInfo->_dwCurrResult--;


        // Check for duplicates
        if (phSearchInfo->_fCheckForDuplicates) {

            PADSNDS_OBJECT_INFO pObject, pPrevObject;

            pPrevObject = pPrevResult->_pObjects + pPrevResult->_dwObjectCurrent;
            pObject = pResult->_pObjects + pResult->_dwObjectCurrent;

            if (!_wcsicmp(pPrevObject->szObjectName, pObject->szObjectName)) {
                // dupe
                RRETURN(GetPreviousRow(hSearchHandle));
            }
        
        }

        
    }
    else if(0 == pResult->_dwObjectCurrent)
    // we are at the very beginning of the result set
        pResult->_dwObjectCurrent--;
    else
        RRETURN(S_ADS_NOMORE_ROWS);

    RRETURN(S_OK);

}


HRESULT
CNDSGenObject::GetColumn(
    IN ADS_SEARCH_HANDLE hSearchHandle,
    IN LPWSTR pszColumnName,
    OUT PADS_SEARCH_COLUMN pColumn
    )
{
    HRESULT hr = S_OK;
    DWORD dwStatus;
    DWORD dwSyntaxId = 0;
    DWORD dwNumValues = 0;
    LPNDS_ATTR_INFO pAttribute;
    PNDS_SEARCH_RESULT pResult, pNextResult;
    PADSNDS_OBJECT_INFO   pObject, pNextObject;
    DWORD cAttr;
    BOOL fRowAdvanced = FALSE;
    PNDS_SEARCHINFO phSearchInfo = (PNDS_SEARCHINFO) hSearchHandle;

    LPWSTR pszNDSDn = NULL;
    LPWSTR pszNDSTreeName = NULL;
    LPWSTR szADsPath = NULL;


    if( !pColumn ||
        !phSearchInfo ||
        !phSearchInfo->_pSearchResults )
        RRETURN (E_ADS_BAD_PARAMETER);

    pColumn->pszAttrName = NULL;
    pColumn->dwADsType = ADSTYPE_INVALID;
    pColumn->pADsValues = NULL;
    pColumn->dwNumValues = 0;
    pColumn->hReserved = NULL;

    if (phSearchInfo->_dwCurrResult < 0)
        RRETURN(S_ADS_NOMORE_ROWS);

    pResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);

    if( pResult->_dwObjectCurrent < 0 )
        RRETURN (E_ADS_BAD_PARAMETER);

    if ((pResult->_dwObjects == 0) || (!pResult->_pObjects))
        RRETURN (S_ADS_NOMORE_COLUMNS);

    pObject = pResult->_pObjects + pResult->_dwObjectCurrent;

    pColumn->pszAttrName = AllocADsStr(pszColumnName);
    if (!pColumn->pszAttrName) 
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

    if(!_wcsicmp (pszColumnName, L"ADsPath")) {

        //
        // Build the ADsPathName
        //

        hr = BuildNDSPathFromADsPath2(
                    _ADsPath,
                    &pszNDSTreeName,
                    &pszNDSDn
                    );
        BAIL_ON_FAILURE(hr);

        hr = BuildADsPathFromNDSPath(
                 pszNDSTreeName,
                 pObject->szObjectName,
                 &szADsPath
                 );
        BAIL_ON_FAILURE(hr);

        if(*szADsPath) {
            pColumn->pADsValues = (PADSVALUE) AllocADsMem(sizeof(ADSVALUE));
            if (!pColumn->pADsValues) 
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

            pColumn->dwADsType = ADSTYPE_CASE_IGNORE_STRING;
            pColumn->dwNumValues = 1;
            pColumn->pADsValues[0].dwType = ADSTYPE_CASE_IGNORE_STRING;

            pColumn->pADsValues[0].CaseIgnoreString = AllocADsStr(szADsPath);
            if (!pColumn->pADsValues[0].CaseIgnoreString)
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

            pColumn->hReserved = pColumn->pADsValues[0].CaseIgnoreString;
        }

        if (szADsPath) {
            FreeADsMem(szADsPath);
        }
        
        if (pszNDSDn) {
            FreeADsMem(pszNDSDn);
        }
        
        if (pszNDSTreeName) {
            FreeADsMem(pszNDSTreeName);
        }

        RRETURN(S_OK);
    }

    if (phSearchInfo->_SearchPref._fAttrsOnly) {
        //
        // Only Names got. So, don't return any values
        //
        RRETURN (S_OK);
    }

    pAttribute = (LPNDS_ATTR_INFO)pObject->lpAttribute;

    for (cAttr=0;cAttr<pObject->dwNumAttributes;cAttr++,pAttribute++) {
        if (_wcsicmp(
                pAttribute->szAttributeName,
                pszColumnName
                ) == 0)
            break;
    }
    if (cAttr == pObject->dwNumAttributes) {
        if(pResult->_dwObjectCurrent+1 != pResult->_dwObjects ||
           (phSearchInfo->_lIterationHandle == NO_MORE_ITERATIONS &&
            (phSearchInfo->_cResultPrefetched == 0))) {
            //
            // No need to look in the next result set;             
            //
            BAIL_ON_FAILURE(hr = E_ADS_COLUMN_NOT_SET);
        }
        else {
            //
            // There is a chance that the column may come in the next
            // result set. So, fetch the next set of results.
            //
            // Since this isn't actually the user causing the row to be advanced,
            // we don't want to do any cache evictions
            phSearchInfo->_fCheckForDuplicates = FALSE;
            BOOL fCurrentCachingStatus = phSearchInfo->_SearchPref._fCacheResults;
            phSearchInfo->_SearchPref._fCacheResults = TRUE;
            hr = GetNextRow(
                     phSearchInfo
                     );
            phSearchInfo->_fCheckForDuplicates = TRUE;
            phSearchInfo->_SearchPref._fCacheResults = fCurrentCachingStatus;
            BAIL_ON_FAILURE(hr);

            if (hr == S_ADS_NOMORE_ROWS) {
                BAIL_ON_FAILURE(hr = E_ADS_COLUMN_NOT_SET);
            }

            fRowAdvanced = TRUE;

            pNextResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);
            pNextObject = pNextResult->_pObjects + pNextResult->_dwObjectCurrent;
            if (_wcsicmp(pObject->szObjectName, pNextObject->szObjectName)) {
                //
                // No need to look in the next object; 
                //
                BAIL_ON_FAILURE(hr = E_ADS_COLUMN_NOT_SET);
            }
            else {
                //
                // Look in the next object
                //
                pAttribute = (LPNDS_ATTR_INFO)pNextObject->lpAttribute;
                for (cAttr=0;cAttr<pNextObject->dwNumAttributes;cAttr++,pAttribute++) {
                    if (_wcsicmp(
                            pAttribute->szAttributeName,
                            pszColumnName
                            ) == 0)
                        break;
                }
                if (cAttr == pNextObject->dwNumAttributes) {
                    //
                    // Didn't find in the next result set containing the row too
                    //
                    BAIL_ON_FAILURE(hr = E_ADS_COLUMN_NOT_SET);
                }
            }
        }
    }

    hr = NdsValueToADsColumn(
             pszColumnName,
             pAttribute->dwSyntaxId,
             pAttribute->dwNumberOfValues,
             (LPBYTE) pAttribute->lpValue,
             pColumn
             );
    BAIL_ON_FAILURE(hr);

    //
    // Added in to support the case when one multivalue attribute is split into 2 packets. The 
    // following case checks 
    // 1) if we haven't advanced the row, if we have advanced already, the whole
    //    Attribute will already be completely residing in the second packet
    // 2) the attribute was the last attribute from the last packet, thus 
    //    the next attribute, (the first attribute of the next row) might be
    //    the same.
    //
    if ((!fRowAdvanced) &&
            (cAttr == (pObject->dwNumAttributes - 1))) {

        //
        // If there is indeed a need to try out an extra packet
        //
        if(pResult->_dwObjectCurrent+1 != pResult->_dwObjects ||
           (phSearchInfo->_lIterationHandle  == NDS_NO_MORE_ITERATIONS &&
            (phSearchInfo->_cResultPrefetched == 0))) {
            //
            // No need to look in the next result set;
            //
            hr = S_OK;
            goto done;
        }
        else {
            //
            // There is a chance that the column may come in the next
            // result set. So, fetch the next set of results.
            //
            // Since this isn't actually the user causing the row to be advanced,
            // we don't want to do any cache evictions
            phSearchInfo->_fCheckForDuplicates = FALSE;
            BOOL fCurrentCachingStatus = phSearchInfo->_SearchPref._fCacheResults;
            phSearchInfo->_SearchPref._fCacheResults = TRUE;
            hr = GetNextRow(
                     phSearchInfo
                     );
            phSearchInfo->_fCheckForDuplicates = TRUE;
            phSearchInfo->_SearchPref._fCacheResults = fCurrentCachingStatus;
            BAIL_ON_FAILURE(hr);

            if (hr == S_ADS_NOMORE_ROWS) {
                hr = S_OK;
                goto done;
            }

            fRowAdvanced = TRUE;

            pNextResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);
            pNextObject = pNextResult->_pObjects + pNextResult->_dwObjectCurrent;
            if (_wcsicmp(pObject->szObjectName, pNextObject->szObjectName)) {
                //
                // No need to look in the next object, since objname is different
                //
                hr = S_OK;
                goto done;
            }
            else {
                //
                // Look in the next object, look for the same attribute
                //
                pAttribute = (LPNDS_ATTR_INFO)pNextObject->lpAttribute;
                for (cAttr=0;cAttr<pNextObject->dwNumAttributes;cAttr++,pAttribute++) {
                    if (_wcsicmp(
                            pAttribute->szAttributeName,
                            pszColumnName
                            ) == 0)
                        break;
                }
                if (cAttr == pNextObject->dwNumAttributes) {
                    //
                    // Didn't find in the next result set containing the row too
                    //
                    hr = S_OK;
                    goto done;
                }
            }
        }

        // 
        // If found, we'll append it to the last column
        //
        hr = NdsValueToADsColumnAppend(
                         pAttribute->dwSyntaxId,
                         pAttribute->dwNumberOfValues,
                         (LPBYTE) pAttribute->lpValue,
                         pColumn
                         );
        BAIL_ON_FAILURE(hr);
    }
done:

    if (fRowAdvanced) {
        phSearchInfo->_fCheckForDuplicates = FALSE;
        GetPreviousRow(phSearchInfo);
        phSearchInfo->_fCheckForDuplicates = TRUE;
    }

    if (szADsPath) {
        FreeADsMem(szADsPath);
    }
    
    if (pszNDSDn) {
        FreeADsMem(pszNDSDn);
    }
    
    if (pszNDSTreeName) {
        FreeADsMem(pszNDSTreeName);
    }

    RRETURN(S_OK);

error:

    if (fRowAdvanced) {
        phSearchInfo->_fCheckForDuplicates = FALSE;
        GetPreviousRow(phSearchInfo);
        phSearchInfo->_fCheckForDuplicates = TRUE;
    }

    if (szADsPath) {
        FreeADsMem(szADsPath);
    }
    
    if (pszNDSDn) {
        FreeADsMem(pszNDSDn);
    }
    
    if (pszNDSTreeName) {
        FreeADsMem(pszNDSTreeName);
    }

    FreeColumn(pColumn);

    RRETURN (hr);
}



HRESULT
CNDSGenObject::GetNextColumnName(
    IN ADS_SEARCH_HANDLE hSearchHandle,
    OUT LPWSTR * ppszColumnName
    )
{
    HRESULT hr = S_OK;
    LPNDS_ATTR_INFO pAttribute;
    LPNDS_ATTR_INFO pAttributeOld = NULL;
    LPNDS_NAME_ONLY pNameOnlyAttr;
    PNDS_SEARCH_RESULT pResult, pNextResult;
    PADSNDS_OBJECT_INFO   pObject, pNextObject;
    BOOL fRowAdvanced = FALSE;
    PNDS_SEARCHINFO phSearchInfo = (PNDS_SEARCHINFO) hSearchHandle;

    if( !phSearchInfo ||
        !phSearchInfo->_pSearchResults ||
        !ppszColumnName)
        RRETURN (E_ADS_BAD_PARAMETER);

    *ppszColumnName = NULL;

    if (phSearchInfo->_dwCurrResult < 0)
        RRETURN(S_ADS_NOMORE_ROWS);

    pResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);

    if( pResult->_dwObjectCurrent < 0 )
        RRETURN (E_ADS_BAD_PARAMETER);

    if ((pResult->_dwObjects == 0) || (!pResult->_pObjects))
        RRETURN (S_ADS_NOMORE_COLUMNS);

    pObject = pResult->_pObjects + pResult->_dwObjectCurrent;

    pNameOnlyAttr = (LPNDS_NAME_ONLY)pObject->lpAttribute + 
                    phSearchInfo->_dwCurrAttr;
    pAttribute = (LPNDS_ATTR_INFO)pObject->lpAttribute + 
                 phSearchInfo->_dwCurrAttr;

    //
    // Get the last attribute's name to test it to avoid getting duplicate 
    // column names. This will happen if a multi-value got divided into two 
    // packets. In that case, both attribute names would be the same.
    // We are only getting the last attribute if this object has greater than
    // 1 object, or else if this attribute is the first attribute, there would
    // not be a one before
    //
    if (phSearchInfo->_dwCurrAttr > 0) {
        pAttributeOld = pAttribute - 1;
    }

    if (phSearchInfo->_dwCurrAttr >= pObject->dwNumAttributes) {
        if(pResult->_dwObjectCurrent+1 != pResult->_dwObjects ||
           (phSearchInfo->_lIterationHandle == NO_MORE_ITERATIONS &&
            (phSearchInfo->_cResultPrefetched == 0))) {
            //
            // No need to look in the next result set;             
            //
            hr = S_ADS_NOMORE_COLUMNS;
            goto error;
        }
        else {
            //
            // There is a chance that the column may come in the next
            // result set. So, fetch the next set of results.
            //
            // Since this isn't actually the user causing the row to be advanced,
            // we don't want to do any cache evictions
            phSearchInfo->_fCheckForDuplicates = FALSE;
            BOOL fCurrentCachingStatus = phSearchInfo->_SearchPref._fCacheResults;
            phSearchInfo->_SearchPref._fCacheResults = TRUE;
            hr = GetNextRow(
                     phSearchInfo
                     );
            phSearchInfo->_fCheckForDuplicates = TRUE;
            phSearchInfo->_SearchPref._fCacheResults = fCurrentCachingStatus;

            BAIL_ON_FAILURE(hr);

            if (hr == S_ADS_NOMORE_ROWS) {
                hr = S_ADS_NOMORE_COLUMNS;
                goto error;
            }
    
            fRowAdvanced = TRUE;
    
            pNextResult = &(phSearchInfo->_pSearchResults[phSearchInfo->_dwCurrResult]);
            pNextObject = pNextResult->_pObjects + pNextResult->_dwObjectCurrent;
            if (_wcsicmp(pObject->szObjectName, pNextObject->szObjectName)) {
                //
                // No need to look in the next object; 
                //
                hr = S_ADS_NOMORE_COLUMNS;
                goto error;
            }
            else {
                //
                // Look in the next object
                //
                pNameOnlyAttr = (LPNDS_NAME_ONLY)pNextObject->lpAttribute + 
                                 phSearchInfo->_dwCurrAttr - 
                                  pObject->dwNumAttributes;
                pAttribute = (LPNDS_ATTR_INFO)pNextObject->lpAttribute + 
                                 phSearchInfo->_dwCurrAttr - 
                                  pObject->dwNumAttributes;
                //
                // If the new attribute is after the first attribute in the new object,
                // we'll reset AttributeOld to point to the attribute before this.
                // Because the old attribute will be the one before the current one
                // in this case.
                //
                if ((phSearchInfo->_dwCurrAttr - pObject->dwNumAttributes) > 0) {
                    pAttributeOld = pAttribute - 1;
                }

                if (phSearchInfo->_dwCurrAttr >= (pObject->dwNumAttributes + 
                                          pNextObject->dwNumAttributes)) {
                    //
                    // Didn't find in the next result set 
                    // containing the row too
                    //
                    hr = S_ADS_NOMORE_COLUMNS;
                    goto error;
                }

                //
                // If it is a duplicate column, go on to the next one
                //
                if (pAttributeOld) {
                    if(wcscmp(pAttribute->szAttributeName, 
                              pAttributeOld->szAttributeName) == 0) {
                        phSearchInfo->_dwCurrAttr++;
                        if (phSearchInfo->_dwCurrAttr >= (pObject->dwNumAttributes +
                                                          pNextObject->dwNumAttributes)) {
                            //
                            // Didn't find in the next result set
                            // containing the row too
                            //
                            hr = S_ADS_NOMORE_COLUMNS;
                            goto error;
                        }
                        pNameOnlyAttr = (LPNDS_NAME_ONLY)pNextObject->lpAttribute +
                                 phSearchInfo->_dwCurrAttr -
                                     pObject->dwNumAttributes;
                        pAttribute = (LPNDS_ATTR_INFO)pNextObject->lpAttribute +
                                     phSearchInfo->_dwCurrAttr -
                                     pObject->dwNumAttributes;
                    }
                }

            }
        }
    }

    if (phSearchInfo->_SearchPref._fAttrsOnly) 
    *ppszColumnName = AllocADsStr(
                          pNameOnlyAttr->szName
                          );
    else 
    *ppszColumnName = AllocADsStr(
                          pAttribute->szAttributeName
                          );

    phSearchInfo->_dwCurrAttr++;

    if (fRowAdvanced) {
        phSearchInfo->_fCheckForDuplicates = FALSE;
        GetPreviousRow(phSearchInfo);
        phSearchInfo->_fCheckForDuplicates = TRUE;
    }

    RRETURN(S_OK);

error:

    if (fRowAdvanced) {
        phSearchInfo->_fCheckForDuplicates = FALSE;
        GetPreviousRow(phSearchInfo);
        phSearchInfo->_fCheckForDuplicates = TRUE;
    }

    if (*ppszColumnName) 
        FreeADsStr(*ppszColumnName);


    if (hr == S_ADS_NOMORE_COLUMNS && phSearchInfo->_fADsPathPresent) {

        //
        // If ADsPath was specified, return it as the last column in the row
        //

        if (!phSearchInfo->_fADsPathReturned) {

            *ppszColumnName = AllocADsStr(L"ADsPath");
            phSearchInfo->_fADsPathReturned = TRUE;
            hr = S_OK;
        }
        else {

            // 
            // We need to reset it back so that we return it for the next
            // row
            //

            phSearchInfo->_fADsPathReturned = FALSE;
            hr = S_ADS_NOMORE_COLUMNS;
        }

    }

    RRETURN (hr);
}


HRESULT
CNDSGenObject::FreeColumn(
    IN PADS_SEARCH_COLUMN pColumn
    )
{
    HRESULT hr = S_OK;

    if(!pColumn)
        RRETURN (E_ADS_BAD_PARAMETER);

    if (pColumn->pszAttrName) 
        FreeADsStr(pColumn->pszAttrName);
    
    if (pColumn->pADsValues) {
        AdsFreeAdsValues(pColumn->pADsValues, pColumn->dwNumValues);
        FreeADsMem(pColumn->pADsValues);
    }

    RRETURN(hr);
}


HRESULT
NdsValueToADsColumn(
    LPWSTR      pszColumnName,
    DWORD       dwSyntaxId,
    DWORD       dwValues,
    LPBYTE      lpObject,
    ADS_SEARCH_COLUMN * pColumn
    )
{
    HRESULT hr = S_OK;
    LPNDS_ASN1_TYPE_1 lpNDS_ASN1_1;
    LPNDS_ASN1_TYPE_7 lpNDS_ASN1_7;
    LPNDS_ASN1_TYPE_8 lpNDS_ASN1_8;
    LPNDS_ASN1_TYPE_9 lpNDS_ASN1_9;
    LPNDS_ASN1_TYPE_11 lpNDS_ASN1_11;
    LPNDS_ASN1_TYPE_14 lpNDS_ASN1_14;
    LPNDS_ASN1_TYPE_18 lpNDS_ASN1_18;
    LPNDS_ASN1_TYPE_20 lpNDS_ASN1_20;
    LPNDS_ASN1_TYPE_24 lpNDS_ASN1_24;
    DWORD i, j, dwValuesAllocated = 0;
    LPBYTE lpValue = NULL;
    PNDSOBJECT lpNdsObject = NULL;

    if(!pszColumnName || !pColumn || !lpObject)
        RRETURN(E_ADS_BAD_PARAMETER);

    lpNdsObject = (PNDSOBJECT) lpObject;

    pColumn->hReserved = NULL;
    pColumn->dwNumValues = dwValues;
    pColumn->pADsValues = (PADSVALUE) AllocADsMem(
                                          sizeof(ADSVALUE) * dwValues
                                          );
    if (!pColumn->pADsValues) 
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);


    if (dwSyntaxId >= g_cMapNdsTypeToADsType) 
        pColumn->dwADsType = ADSTYPE_INVALID;
    else 
        pColumn->dwADsType = g_MapNdsTypeToADsType[dwSyntaxId];

    switch (dwSyntaxId) {
        // WIDE STRING
        case NDS_SYNTAX_ID_1:
        case NDS_SYNTAX_ID_2:
        case NDS_SYNTAX_ID_3:
        case NDS_SYNTAX_ID_4:
        case NDS_SYNTAX_ID_5:
        case NDS_SYNTAX_ID_10:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_1 = (LPNDS_ASN1_TYPE_1) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].CaseIgnoreString = AllocADsStr(lpNDS_ASN1_1->DNString);
                
                if (!(pColumn->pADsValues[i].CaseIgnoreString))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

                dwValuesAllocated++;
            }
            break;
            
        case NDS_SYNTAX_ID_20:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_20 = (LPNDS_ASN1_TYPE_20) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].ClassName = AllocADsStr(lpNDS_ASN1_20->ClassName);
                
                if (!(pColumn->pADsValues[i].ClassName))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

                dwValuesAllocated++;
            }
            break;

        // EMAIL                
        case NDS_SYNTAX_ID_14 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_14 = (LPNDS_ASN1_TYPE_14) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].Email.Address = AllocADsStr(lpNDS_ASN1_14->Address);
                pColumn->pADsValues[i].Email.Type = lpNDS_ASN1_14->Type;
                
                if (!(pColumn->pADsValues[i].Email.Address))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

                dwValuesAllocated++;
            }
            break;
            
        // BYTE STREAM
        case NDS_SYNTAX_ID_9:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_9 = (LPNDS_ASN1_TYPE_9) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                
                if (lpNDS_ASN1_9->Length)
                {
                    LPBYTE lpByte = (LPBYTE)AllocADsMem(lpNDS_ASN1_9->Length);
                    if (!lpByte)
                        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
                    
                    if (lpNDS_ASN1_9->OctetString)
                        memcpy(lpByte, lpNDS_ASN1_9->OctetString, lpNDS_ASN1_9->Length);
                    
                    pColumn->pADsValues[i].OctetString.dwLength =lpNDS_ASN1_9->Length;
                    pColumn->pADsValues[i].OctetString.lpValue = lpByte;
                }
                else
                {
                    pColumn->pADsValues[i].OctetString.dwLength = 0;
                    pColumn->pADsValues[i].OctetString.lpValue = NULL;
                }

                dwValuesAllocated++;
            }
            break;
            
        // BOOLEAN
        case NDS_SYNTAX_ID_7:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_7 = (LPNDS_ASN1_TYPE_7) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].Boolean = lpNDS_ASN1_7->Boolean;
            }

            dwValuesAllocated = dwValues;   // no intermediate failures possible
            break;
            
        // INTEGER
        case NDS_SYNTAX_ID_8:
        case NDS_SYNTAX_ID_22:
        case NDS_SYNTAX_ID_27:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_8 = (LPNDS_ASN1_TYPE_8) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].Integer = lpNDS_ASN1_8->Integer;
            }

            dwValuesAllocated = dwValues;   // no intermediate failures possible
            break;
            
        // TIME
        case NDS_SYNTAX_ID_24 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_24 = (LPNDS_ASN1_TYPE_24) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                hr = ConvertDWORDtoSYSTEMTIME(
                    lpNDS_ASN1_24->Time,
                    &(pColumn->pADsValues[i].UTCTime)
                    );
                BAIL_ON_FAILURE(hr);

                dwValuesAllocated++;
            }
            break;

        // FAX NUMBER
        case NDS_SYNTAX_ID_11 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_11 = (LPNDS_ASN1_TYPE_11) &((lpNdsObject + i)->NdsValue);

                pColumn->pADsValues[i].dwType = pColumn->dwADsType;

                pColumn->pADsValues[i].pFaxNumber = (PADS_FAXNUMBER)AllocADsMem(sizeof(ADS_FAXNUMBER));
                if (!pColumn->pADsValues[i].pFaxNumber) {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }

                pColumn->pADsValues[i].pFaxNumber->TelephoneNumber =
                                        AllocADsStr(lpNDS_ASN1_11->TelephoneNumber);

                if (!pColumn->pADsValues[i].pFaxNumber->TelephoneNumber) {
                    FreeADsMem(pColumn->pADsValues[i].pFaxNumber);
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }

                hr = CopyOctetString(lpNDS_ASN1_11->NumberOfBits,
                                     lpNDS_ASN1_11->Parameters,
                                     &pColumn->pADsValues[i].pFaxNumber->NumberOfBits,
                                     &pColumn->pADsValues[i].pFaxNumber->Parameters);
                if (FAILED(hr)) {
                    FreeADsStr(pColumn->pADsValues[i].pFaxNumber->TelephoneNumber);
                    FreeADsMem(pColumn->pADsValues[i].pFaxNumber);
                    BAIL_ON_FAILURE(hr);
                }

                dwValuesAllocated++;
            }
            break;

        // POSTAL ADDRESS
        case NDS_SYNTAX_ID_18 :
            for (i=0; i<dwValues; i++) {
                lpNDS_ASN1_18 = (LPNDS_ASN1_TYPE_18) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                
                pColumn->pADsValues[i].pPostalAddress = (PADS_POSTALADDRESS)AllocADsMem(sizeof(ADS_POSTALADDRESS));
                if (!pColumn->pADsValues[i].pPostalAddress) {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }
                
                for (j=0;j<6;j++) {
                    if (lpNDS_ASN1_18->PostalAddress[j]) {
                        pColumn->pADsValues[i].pPostalAddress->PostalAddress[j] =
                            AllocADsStr(
                            lpNDS_ASN1_18->PostalAddress[j]
                            );
                    }
                    else {
                        pColumn->pADsValues[i].pPostalAddress->PostalAddress[j] =
                            AllocADsStr(
                            L""
                            );
                    }
                    if (!pColumn->pADsValues[i].pPostalAddress->PostalAddress[j]) {
                        hr = E_OUTOFMEMORY;
                        while (j>0) {
                            FreeADsStr(pColumn->pADsValues[i].pPostalAddress->PostalAddress[j-1]);
                            j--;
                        }
                        FreeADsMem(pColumn->pADsValues[i].pPostalAddress);
                        BAIL_ON_FAILURE(hr);
                    }
                }

                dwValuesAllocated++;
            }
            break;

        case NDS_SYNTAX_ID_6 :
        case NDS_SYNTAX_ID_12 :
        case NDS_SYNTAX_ID_13 :
        case NDS_SYNTAX_ID_15 :
        case NDS_SYNTAX_ID_16 :
        case NDS_SYNTAX_ID_17 :
        case NDS_SYNTAX_ID_19 :
        case NDS_SYNTAX_ID_21 :
        case NDS_SYNTAX_ID_23 :
        case NDS_SYNTAX_ID_25 :
        case NDS_SYNTAX_ID_26 :
        default:
            for (i=0; i < dwValues; i++) {
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[i].ProviderSpecific.dwLength =0;
                pColumn->pADsValues[i].ProviderSpecific.lpValue = NULL;
            }

            dwValuesAllocated = dwValues;   // no intermediate failures possible
            break;
    }
    RRETURN(hr);

error:

    if (pColumn->pADsValues) {
        AdsFreeAdsValues(pColumn->pADsValues, dwValuesAllocated);

        FreeADsMem(pColumn->pADsValues);
        pColumn->pADsValues = NULL;
        pColumn->dwNumValues = 0;
    }

    RRETURN(hr);
}

HRESULT
NdsValueToADsColumnAppend(
    DWORD       dwSyntaxId,
    DWORD       dwValues,
    LPBYTE      lpObject,
    ADS_SEARCH_COLUMN * pColumn
    )
{
    HRESULT hr = S_OK;
    LPNDS_ASN1_TYPE_1 lpNDS_ASN1_1;
    LPNDS_ASN1_TYPE_7 lpNDS_ASN1_7;
    LPNDS_ASN1_TYPE_8 lpNDS_ASN1_8;
    LPNDS_ASN1_TYPE_9 lpNDS_ASN1_9;
    LPNDS_ASN1_TYPE_11 lpNDS_ASN1_11;
    LPNDS_ASN1_TYPE_14 lpNDS_ASN1_14;
    LPNDS_ASN1_TYPE_18 lpNDS_ASN1_18;
    LPNDS_ASN1_TYPE_20 lpNDS_ASN1_20;
    LPNDS_ASN1_TYPE_24 lpNDS_ASN1_24;
    DWORD i, j, dwValuesAllocated;
    PNDSOBJECT lpNdsObject = NULL;
    PADSVALUE pADsValuesNew = NULL;
    DWORD dwValuesBase;

    if(!pColumn || !lpObject)
        RRETURN(E_ADS_BAD_PARAMETER);

    dwValuesBase = pColumn->dwNumValues;
    dwValuesAllocated = pColumn->dwNumValues;
    lpNdsObject = (PNDSOBJECT) lpObject;

    //
    // Allocate memory for new values + old values
    //
    pADsValuesNew = (PADSVALUE) AllocADsMem(
                          sizeof(ADSVALUE) * (pColumn->dwNumValues + dwValues)
                          );
    if (!pADsValuesNew) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    //
    // Copy old values into new array, and free the old one
    //
    memcpy(pADsValuesNew,
           pColumn->pADsValues,
           sizeof(ADSVALUE) * dwValuesBase);
    FreeADsMem(pColumn->pADsValues);
    pColumn->pADsValues = pADsValuesNew;

    switch (dwSyntaxId) {
        // WIDE STRING
        case NDS_SYNTAX_ID_1:
        case NDS_SYNTAX_ID_2:
        case NDS_SYNTAX_ID_3:
        case NDS_SYNTAX_ID_4:
        case NDS_SYNTAX_ID_5:
        case NDS_SYNTAX_ID_10:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_1 = (LPNDS_ASN1_TYPE_1) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].CaseIgnoreString = AllocADsStr(lpNDS_ASN1_1->DNString);

                if (!(pColumn->pADsValues[dwValuesBase+i].CaseIgnoreString))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

                dwValuesAllocated++;
            }
            break;

        case NDS_SYNTAX_ID_20:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_20 = (LPNDS_ASN1_TYPE_20) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].ClassName = AllocADsStr(lpNDS_ASN1_20->ClassName);
                
                if (!(pColumn->pADsValues[dwValuesBase+i].ClassName))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
                
                dwValuesAllocated++;
            }
            break;
         
        // EMAIL    
        case NDS_SYNTAX_ID_14 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_14 = (LPNDS_ASN1_TYPE_14) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].Email.Address = AllocADsStr(lpNDS_ASN1_14->Address);
                pColumn->pADsValues[dwValuesBase+i].Email.Type = lpNDS_ASN1_14->Type;
                
                if (!(pColumn->pADsValues[dwValuesBase+i].Email.Address))
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
                
                dwValuesAllocated++;
            }
            break;

        // BYTE STREAM
        case NDS_SYNTAX_ID_9:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_9 = (LPNDS_ASN1_TYPE_9) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;

                if (lpNDS_ASN1_9->Length)
                {
                    LPBYTE lpByte = (LPBYTE)AllocADsMem(lpNDS_ASN1_9->Length);
                    if (!lpByte)
                        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

                    if (lpNDS_ASN1_9->OctetString)
                        memcpy(lpByte, lpNDS_ASN1_9->OctetString, lpNDS_ASN1_9->Length);

                    pColumn->pADsValues[dwValuesBase+i].OctetString.dwLength =lpNDS_ASN1_9->Length;
                    pColumn->pADsValues[dwValuesBase+i].OctetString.lpValue = lpByte;
                }
                else
                {
                    pColumn->pADsValues[dwValuesBase+i].OctetString.dwLength = 0;
                    pColumn->pADsValues[dwValuesBase+i].OctetString.lpValue = NULL;
                }

                dwValuesAllocated++;
            }
            break;

        // BOOLEAN
        case NDS_SYNTAX_ID_7:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_7 = (LPNDS_ASN1_TYPE_7) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].Boolean = lpNDS_ASN1_7->Boolean;
            }

            dwValuesAllocated += dwValues;  // no intermediate failures possible
            break;

        // INTEGER
        case NDS_SYNTAX_ID_8:
        case NDS_SYNTAX_ID_22:
        case NDS_SYNTAX_ID_27:
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_8 = (LPNDS_ASN1_TYPE_8) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].Integer = lpNDS_ASN1_8->Integer;
            }

            dwValuesAllocated += dwValues;  // no intermediate failures possible
            break;

        // TIME
        case NDS_SYNTAX_ID_24 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_24 = (LPNDS_ASN1_TYPE_24) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[i].dwType = pColumn->dwADsType;
                hr = ConvertDWORDtoSYSTEMTIME(
                            lpNDS_ASN1_24->Time,
                            &(pColumn->pADsValues[dwValuesBase+i].UTCTime)
                            );
                BAIL_ON_FAILURE(hr);

                dwValuesAllocated++;
            }
            break;

        // FAX NUMBER
        case NDS_SYNTAX_ID_11 :
            for (i=0; i < dwValues; i++) {
                lpNDS_ASN1_11 = (LPNDS_ASN1_TYPE_11) &((lpNdsObject + i)->NdsValue);

                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;

                pColumn->pADsValues[dwValuesBase+i].pFaxNumber = (PADS_FAXNUMBER)AllocADsMem(sizeof(ADS_FAXNUMBER));
                if (!pColumn->pADsValues[dwValuesBase+i].pFaxNumber) {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }

                pColumn->pADsValues[dwValuesBase+i].pFaxNumber->TelephoneNumber =
                                        AllocADsStr(lpNDS_ASN1_11->TelephoneNumber);

                if (!pColumn->pADsValues[dwValuesBase+i].pFaxNumber->TelephoneNumber) {
                    FreeADsMem(pColumn->pADsValues[dwValuesBase+i].pFaxNumber);
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }

                hr = CopyOctetString(lpNDS_ASN1_11->NumberOfBits,
                                     lpNDS_ASN1_11->Parameters,
                                     &pColumn->pADsValues[dwValuesBase+i].pFaxNumber->NumberOfBits,
                                     &pColumn->pADsValues[dwValuesBase+i].pFaxNumber->Parameters);
                if (FAILED(hr)) {
                    FreeADsStr(pColumn->pADsValues[dwValuesBase+i].pFaxNumber->TelephoneNumber);
                    FreeADsMem(pColumn->pADsValues[dwValuesBase+i].pFaxNumber);
                    BAIL_ON_FAILURE(hr);
                }

                dwValuesAllocated++;
            }
            break;

        // POSTAL ADDRESS
        case NDS_SYNTAX_ID_18 :
            for (i=0; i<dwValues; i++) {
                lpNDS_ASN1_18 = (LPNDS_ASN1_TYPE_18) &((lpNdsObject + i)->NdsValue);
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                
                pColumn->pADsValues[dwValuesBase+i].pPostalAddress = (PADS_POSTALADDRESS)AllocADsMem(sizeof(ADS_POSTALADDRESS));
                if (!pColumn->pADsValues[dwValuesBase+i].pPostalAddress) {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }
                
                for (j=0;j<6;j++) {
                    if (lpNDS_ASN1_18->PostalAddress[j]) {
                        pColumn->pADsValues[dwValuesBase+i].pPostalAddress->PostalAddress[j] =
                            AllocADsStr(
                            lpNDS_ASN1_18->PostalAddress[j]
                            );
                    }
                    else {
                        pColumn->pADsValues[dwValuesBase+i].pPostalAddress->PostalAddress[j] =
                            AllocADsStr(
                            L""
                            );
                    }
                    if (!pColumn->pADsValues[dwValuesBase+i].pPostalAddress->PostalAddress[j]) {
                        hr = E_OUTOFMEMORY;
                        while (j>0) {
                            FreeADsStr(pColumn->pADsValues[dwValuesBase+i].pPostalAddress->PostalAddress[j-1]);
                            j--;
                        }
                        FreeADsMem(pColumn->pADsValues[dwValuesBase+i].pPostalAddress);
                        BAIL_ON_FAILURE(hr);
                    }
                }

                dwValuesAllocated++;
            }
            break;

        case NDS_SYNTAX_ID_6 :
        case NDS_SYNTAX_ID_12 :
        case NDS_SYNTAX_ID_13 :
        case NDS_SYNTAX_ID_15 :
        case NDS_SYNTAX_ID_16 :
        case NDS_SYNTAX_ID_17 :
        case NDS_SYNTAX_ID_19 :
        case NDS_SYNTAX_ID_21 :
        case NDS_SYNTAX_ID_23 :
        case NDS_SYNTAX_ID_25 :
        case NDS_SYNTAX_ID_26 :
        default:
            for (i=0; i < dwValues; i++) {
                pColumn->pADsValues[dwValuesBase+i].dwType = pColumn->dwADsType;
                pColumn->pADsValues[dwValuesBase+i].ProviderSpecific.dwLength =0;
                pColumn->pADsValues[dwValuesBase+i].ProviderSpecific.lpValue = NULL;
            }

            dwValuesAllocated += dwValues;
            break;
    }
    pColumn->dwNumValues = pColumn->dwNumValues + dwValues;
    
    RRETURN(hr);

error:

    if (pColumn->pADsValues) {
        AdsFreeAdsValues(pColumn->pADsValues, dwValuesAllocated);

        FreeADsMem(pColumn->pADsValues);
        pColumn->pADsValues = NULL;
        pColumn->dwNumValues = 0;
    }

    RRETURN(hr);
}