windows-xp/Source/XPSP1/NT/ds/adsi/ldap/cprops.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1996.
//
//  File:       cprops.cxx
//
//  Contents:   Property Cache functionality for LDAP
//
//  Functions:
//                CPropertyCache::addproperty
//                CPropertyCache::updateproperty
//                CPropertyCache::findproperty
//                CPropertyCache::getproperty
//                CPropertyCache::putproperty
//                CProperyCache::CPropertyCache
//                CPropertyCache::~CPropertyCache
//                CPropertyCache::createpropertycache
//
//  History:      15-Jun-96   yihsins   Created.
//
//----------------------------------------------------------------------------
#include "ldap.hxx"

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::addproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName]    --
//              [vt]                --
//              [vaData]            --
//
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
addproperty(
    LPWSTR szPropertyName
    )
{
    HRESULT hr = S_OK;
    PPROPERTY pNewProperty = NULL;
    LPWSTR tempString1 = NULL;
    LPWSTR tempString2 = NULL;

    PPROPERTY pNewProperties = NULL;

    PDISPPROPERTY pDispNewProperty = NULL;
    PDISPPROPERTY pDispNewProperties = NULL;
    DWORD dwDispLoc = 0;


    //
    // Allocate the string first
    //
    tempString1 = AllocADsStr(szPropertyName);

    if (!tempString1)
       BAIL_ON_FAILURE(hr=E_OUTOFMEMORY);


    //
    // Make a copy for the Dispatch Mgr Table.
    //

    tempString2 = AllocADsStr(szPropertyName);

    if (!tempString2)
       BAIL_ON_FAILURE(hr=E_OUTOFMEMORY);


    //
    //  extend the property cache by adding a new property entry
    //

    pNewProperties = (PPROPERTY)ReallocADsMem(
                                _pProperties,
                                _cb,
                                _cb + sizeof(PROPERTY)
                                );
    if (!pNewProperties) {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    _pProperties = pNewProperties;

    pNewProperty = (PPROPERTY)((LPBYTE)_pProperties + _cb);


    //
    // Since the memory has already been allocated in tempString
    // just set the value/pointer now.
    //
    pNewProperty->szPropertyName = tempString1;

    //
    // Update the index
    //

    _dwMaxProperties++;
    _cb += sizeof(PROPERTY);

    //
    //  extend the property cache by adding a new property entry
    //

    //
    // Need to check if this property is already there in the
    // dispatch table - otherwise we are going to keep on growing
    // forever - AjayR 7-31-98.
    //

    hr = DispatchFindProperty(szPropertyName, &dwDispLoc);

    if (hr == S_OK) {
        // we do not need this string in this case
        if (tempString2) {
            FreeADsStr(tempString2);
            tempString2 = NULL;
        }
    } else {

        //
        // reset the hr otherwise we will return an
        // error incorrectly when there was none.
        //
        hr = S_OK;

        pDispNewProperties = (PDISPPROPERTY)ReallocADsMem(
                                    _pDispProperties,
                                    _cbDisp,
                                    _cbDisp + sizeof(DISPPROPERTY)
                                    );
        if (!pDispNewProperties) {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        _pDispProperties = pDispNewProperties;

        pDispNewProperty = (PDISPPROPERTY)((LPBYTE)_pDispProperties + _cbDisp);


        //
        // Since the memory has already been allocated in tempString
        // just set the value/pointer now.
        //
        pDispNewProperty->szPropertyName = tempString2;

        //
        // Update the index
        //

        _dwDispMaxProperties++;
        _cbDisp += sizeof(DISPPROPERTY);

    } // else clause - that is property not found in disp

    RRETURN(hr);
error:

    if (tempString1){
       FreeADsStr(tempString1);
    }

    if (tempString2) {
        FreeADsStr(tempString2);
    }


    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::putpropertyext
//
//  Synopsis: Similar to put property only unlike update it will add
//       the property to the cahce if it is not already there ! 
//
//
//  Arguments:  [szPropertyName]    --
//              [vaData]    --
//
//  History 
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
putpropertyext(
    LPWSTR szPropertyName,
    DWORD  dwFlags,
    DWORD  dwSyntaxId,
    LDAPOBJECTARRAY ldapObjectArray
    )
{
    HRESULT hr;
    DWORD dwIndex;
    BOOL fFound = FALSE;
    PPROPERTY pThisProperty = NULL;

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );

    //
    // If the property is not in the cache we need to add it
    // as updateproperty expects it to be in the cache.
    //
    if (hr == E_ADS_PROPERTY_NOT_FOUND) {
        hr = addproperty(
                 szPropertyName
                 );
    } 
    else {
        fFound = TRUE;
    }

    BAIL_ON_FAILURE(hr);

    //
    // at this time we can call putproperty
    //
    if (fFound) {
        hr = putproperty(
                 dwIndex,
                 dwFlags,
                 dwSyntaxId,
                 ldapObjectArray
                 );
    } 
    else {
        hr = putproperty(
                 szPropertyName,
                 dwFlags,
                 dwSyntaxId,
                 ldapObjectArray
                 );
    }

error:

    RRETURN(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::updateproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName]    --
//              [vaData]    --
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
updateproperty(
    LPWSTR szPropertyName,
    DWORD  dwSyntaxId,
    LDAPOBJECTARRAY ldapObjectArray,
    BOOL   fExplicit
    )
{
    HRESULT hr;
    DWORD dwIndex;
    PPROPERTY pThisProperty = NULL;

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );
    BAIL_ON_FAILURE(hr);

    pThisProperty = _pProperties + dwIndex;

    if (!fExplicit) {
        if ( PROPERTY_FLAGS(pThisProperty) == PROPERTY_UPDATE ) {
            hr = S_OK;
            goto error;
        }
    }

    // Free the old values first
    LdapTypeFreeLdapObjects( &(PROPERTY_LDAPOBJECTARRAY(pThisProperty)));

    PROPERTY_SYNTAX(pThisProperty) = dwSyntaxId;
    PROPERTY_FLAGS(pThisProperty) = PROPERTY_INIT;

    hr = LdapTypeCopyConstruct(
            ldapObjectArray,
            &(PROPERTY_LDAPOBJECTARRAY(pThisProperty))
            );
    BAIL_ON_FAILURE(hr);

error:

    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::findproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName] --
//              [pdwIndex]       --
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
findproperty(
    LPWSTR szPropertyName,
    PDWORD pdwIndex
    )
{
    DWORD i = 0;
    PPROPERTY pThisProperty = NULL;

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

        pThisProperty = _pProperties + i;

        if (!_wcsicmp(pThisProperty->szPropertyName, szPropertyName)) {
            *pdwIndex = i;
            RRETURN(S_OK);
        }
    }

    *pdwIndex = 0;
    RRETURN(E_ADS_PROPERTY_NOT_FOUND);

}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::getproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName]    --  Property to retrieve from the cache
//              [pvaData]           --  Data returned in a variant
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
getproperty(
    LPWSTR szPropertyName,
    PDWORD pdwSyntaxId,
    PDWORD pdwStatusFlag,
    LDAPOBJECTARRAY *pLdapObjectArray
    )
{
    HRESULT hr;
    DWORD dwIndex = 0L;


    //
    // retrieve index of property in cache
    //

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );

    //
    // if property not already in cache, try get properties from svr
    //

    //
    // INDEX_EMPTY(???) ???
    //

    if ((hr == E_ADS_PROPERTY_NOT_FOUND || 
         (INDEX_EMPTY(dwIndex) && !PROP_DELETED(dwIndex))
        ) && 
        !_fGetInfoDone)
    {
        BOOL fResult = FindSavingEntry(szPropertyName);

        if(!fResult) {
            hr = _pCoreADsObject->GetInfo(FALSE);

            // workaround to avoid confusing callers of getproperty.
            if (hr == E_NOTIMPL) {
                hr = E_ADS_PROPERTY_NOT_FOUND;
            }
            BAIL_ON_FAILURE(hr);

            hr = findproperty(szPropertyName, &dwIndex);
        }
        else {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }
    }
    BAIL_ON_FAILURE(hr);


    //
    // get property based on index in cache
    //

    hr = unboundgetproperty(
            dwIndex,
            pdwSyntaxId,
            pdwStatusFlag,
            pLdapObjectArray
            );

error:

   RRETURN(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::putproperty
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
putproperty(
    LPWSTR szPropertyName,
    DWORD  dwFlags,
    DWORD  dwSyntaxId,
    LDAPOBJECTARRAY ldapObjectArray
    )
{
    HRESULT hr = S_OK;
    DWORD dwIndex = 0L;

    hr = findproperty(szPropertyName, &dwIndex);
    if (SUCCEEDED(hr))
        hr = putproperty(dwIndex, dwFlags, dwSyntaxId, ldapObjectArray);

    RRETURN(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::putproperty
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
putproperty(
    DWORD  dwIndex,
    DWORD  dwFlags,
    DWORD  dwSyntaxId,
    LDAPOBJECTARRAY ldapObjectArray
    )
{
    HRESULT hr = S_OK;
    PPROPERTY pThisProperty = NULL;

    pThisProperty = _pProperties + dwIndex;

    // Free the old values first
    LdapTypeFreeLdapObjects( &(PROPERTY_LDAPOBJECTARRAY(pThisProperty)) );

    PROPERTY_SYNTAX(pThisProperty) = dwSyntaxId;

    switch ( dwFlags ) {

    case PROPERTY_INIT:
        if ( ldapObjectArray.dwCount > 0 )
        {
            hr = LdapTypeCopyConstruct(
                     ldapObjectArray,
                     &(PROPERTY_LDAPOBJECTARRAY(pThisProperty))
                     );
            BAIL_ON_FAILURE(hr);
        }

        PROPERTY_FLAGS(pThisProperty) = PROPERTY_INIT;
        break;

    case PROPERTY_DELETE:
        PROPERTY_FLAGS(pThisProperty) = PROPERTY_DELETE;
        break;

    case PROPERTY_UPDATE:
        if ( ldapObjectArray.dwCount > 0 )
        {
            hr = LdapTypeCopyConstruct(
                     ldapObjectArray,
                     &(PROPERTY_LDAPOBJECTARRAY(pThisProperty))
                     );
            BAIL_ON_FAILURE(hr);
        }

        PROPERTY_FLAGS(pThisProperty) = ldapObjectArray.dwCount?
                                        PROPERTY_UPDATE : PROPERTY_DELETE;
        break;


    case PROPERTY_DELETE_VALUE:
        if ( ldapObjectArray.dwCount > 0 )
        {
            hr = LdapTypeCopyConstruct(
                     ldapObjectArray,
                     &(PROPERTY_LDAPOBJECTARRAY(pThisProperty))
                     );
            BAIL_ON_FAILURE(hr);
        }

        PROPERTY_FLAGS(pThisProperty) = PROPERTY_DELETE_VALUE;

        break;



    case PROPERTY_ADD:
        hr = LdapTypeCopyConstruct(
                 ldapObjectArray,
                 &(PROPERTY_LDAPOBJECTARRAY(pThisProperty))
                 );
        BAIL_ON_FAILURE(hr);

        PROPERTY_FLAGS(pThisProperty) = PROPERTY_ADD;
        break;

    }

error:

    RRETURN(hr);
}



//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::CPropertyCache
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
CPropertyCache::
CPropertyCache():
    _dwMaxProperties(0),
    _pProperties(NULL),
    _cb(0),
    _dwCurrentIndex(0),
    _pCoreADsObject(NULL),
    _pGetAttributeSyntax(NULL),
    _fGetInfoDone(FALSE),
    _pDispProperties(NULL),
    _dwDispMaxProperties(0),
    _cbDisp(0),
    _pCredentials(NULL),
    _pszServerName(NULL),
    _dwPort(0)
{
    InitializeListHead(&_ListSavingEntries);

}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::~CPropertyCache
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
CPropertyCache::
~CPropertyCache()
{
    PPROPERTY pThisProperty = NULL;
    PDISPPROPERTY pThisDispProperty = NULL;
    
    if (_pProperties) {

        for ( DWORD i = 0; i < _dwMaxProperties; i++ ) {

            pThisProperty = _pProperties + i;

            if (pThisProperty->szPropertyName) {
               FreeADsStr(pThisProperty->szPropertyName);
               pThisProperty->szPropertyName = NULL;
            }

            LdapTypeFreeLdapObjects(&(PROPERTY_LDAPOBJECTARRAY(pThisProperty)));
        }

        FreeADsMem(_pProperties);
    }

    if (_pDispProperties) {

        for ( DWORD i = 0; i < _dwDispMaxProperties; i++ ) {

            pThisDispProperty = _pDispProperties + i;

            if (pThisDispProperty->szPropertyName) {
               FreeADsStr(pThisDispProperty->szPropertyName);
               pThisDispProperty->szPropertyName = NULL;
            }

        }

        FreeADsMem(_pDispProperties);
    }

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

    DeleteSavingEntry();


    //
    // The property cache is deleted before the object is
    // so the object will handle freeing the credentials.
    // We just keep a pointer to the credentials.
    //
    if (_pCredentials) {
        _pCredentials = NULL;
    }
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::ClearAllPropertyFlags
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
HRESULT CPropertyCache::ClearAllPropertyFlags(VOID)
{
    PPROPERTY pThisProperty = NULL;

    if (_pProperties) {

        for ( DWORD i = 0; i < _dwMaxProperties; i++ ) {

            pThisProperty = _pProperties + i;
            PROPERTY_FLAGS(pThisProperty) = PROPERTY_INIT;
        }
    }

    RRETURN(S_OK);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::ClearPropertyFlag
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
HRESULT CPropertyCache::ClearPropertyFlag( LPWSTR szPropertyName )
{
    PPROPERTY pThisProperty = NULL;
    HRESULT hr = S_OK;
    DWORD dwIndex;

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );
    BAIL_ON_FAILURE(hr);

    pThisProperty = _pProperties + dwIndex;
    if (PROPERTY_LDAPOBJECTARRAY(pThisProperty).pLdapObjects) {

        PROPERTY_FLAGS(pThisProperty) = PROPERTY_INIT;
    }

error:

    RRETURN(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::ClearMarshalledProperties
//
//  Synopsis: Once the properties have been marshalled and
// the set has been done, the properties on the cache are no
// longer valid. This method must be called to keep the property
// cache in a coherrent state.
//       The method frees the 'dirty' entries, sets implicit get
// flag. If the dirty entries cannot be cleared, then the
// entire contents are flushed and they will be picked up at the
// next GetInfo call -- AjayR
//
//  Arguments: None.
//
//
//-------------------------------------------------------------------------
HRESULT CPropertyCache::ClearMarshalledProperties()
{
    HRESULT hr = S_OK;
    DWORD dwIndx = 0;
    DWORD dwCtr = 0;
    DWORD dwChng = 0;
    PPROPERTY pNewProperties = NULL;
    PPROPERTY pThisProperty = NULL;
    PPROPERTY pNewCurProperty = NULL;
    DWORD dwNewProps = 0;


    //
    // Go through properties to see how many have changed
    //
    for (dwCtr = 0; dwCtr < _dwMaxProperties; dwCtr++ ) {
        pThisProperty = _pProperties + dwCtr;

        if (PROPERTY_FLAGS(pThisProperty) != PROPERTY_INIT)
            dwChng++;
    }

    if (dwChng == 0) {
        RRETURN(S_OK);
    }

    //
    // Need to remove those entries which were changed
    //

    dwNewProps = _dwMaxProperties - dwChng;

    if (dwNewProps != 0) {
        pNewProperties = (PPROPERTY) AllocADsMem(
                                         dwNewProps * sizeof(PROPERTY)
                                         );

        if (!pNewProperties) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            // if this fails, then we cannot recover
            // effectively. What alternative is there ?
            // We do not want to flush the cache.
        }
    }

    for (dwCtr = 0, dwIndx = 0; dwCtr < _dwMaxProperties; dwCtr++ ) {

        pThisProperty = _pProperties + dwCtr;

        if (PROPERTY_FLAGS(pThisProperty) != PROPERTY_INIT) {
            //
            // delete the property
            //

            if (pThisProperty->szPropertyName) {
               FreeADsStr(pThisProperty->szPropertyName);
               pThisProperty->szPropertyName = NULL;
            }

            LdapTypeFreeLdapObjects(&(PROPERTY_LDAPOBJECTARRAY(pThisProperty)));

        } else {

            //
            // Sanity Check, should not hit this if Assert preferable
            //
            if (dwIndx > dwNewProps || dwIndx == dwNewProps) {
                BAIL_ON_FAILURE(hr = E_FAIL);
            }

            pNewCurProperty = pNewProperties + dwIndx;

            pNewCurProperty->szPropertyName = pThisProperty->szPropertyName;

            pNewCurProperty->ldapObjectArray =
                PROPERTY_LDAPOBJECTARRAY(pThisProperty);

            pNewCurProperty->dwFlags = pThisProperty->dwFlags;

            pNewCurProperty->dwSyntaxId = pThisProperty->dwSyntaxId;

            dwIndx++;
        }
    } // for, copying the old elements to new buffer

    _dwMaxProperties -= dwChng;

    _cb = dwNewProps * sizeof(PROPERTY);

    if (_pProperties)
        FreeADsMem(_pProperties);

    _pProperties = pNewProperties;


    // Need to set this flag to implicitly fetch properties
    // the next time somebody asks for a poperty not in the cache.
    _fGetInfoDone = FALSE;

    RRETURN(S_OK);

error:

    if (pNewProperties) {
        FreeADsMem(pNewProperties);
    }

    RRETURN(hr);

}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::SetPropertyFlag
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
HRESULT CPropertyCache::SetPropertyFlag( LPWSTR szPropertyName, DWORD dwFlag )
{
    PPROPERTY pThisProperty = NULL;
    HRESULT hr = S_OK;
    DWORD dwIndex;

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );
    BAIL_ON_FAILURE(hr);

    pThisProperty = _pProperties + dwIndex;
    if (PROPERTY_LDAPOBJECTARRAY(pThisProperty).pLdapObjects) {

        PROPERTY_FLAGS(pThisProperty) = dwFlag;
    }

error:

    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::IsPropertyUpdated
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName] --
//              [pdwIndex]       --
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
IsPropertyUpdated(
    LPWSTR szPropertyName,
    BOOL   *pfUpdated
    )
{
    PPROPERTY pThisProperty = NULL;
    HRESULT hr = S_OK;
    DWORD dwIndex;

    *pfUpdated = FALSE;

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );
    BAIL_ON_FAILURE(hr);

    pThisProperty = _pProperties + dwIndex;
    if (PROPERTY_LDAPOBJECTARRAY(pThisProperty).pLdapObjects) {

        if ( PROPERTY_FLAGS(pThisProperty) == PROPERTY_UPDATE )
            *pfUpdated = TRUE;
    }

error:

    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::createpropertycache
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
createpropertycache(
    CCoreADsObject *pCoreADsObject,
    IGetAttributeSyntax *pGetAttributeSyntax,
    CPropertyCache **ppPropertyCache
    )
{
    CPropertyCache FAR * pPropertyCache = NULL;

    pPropertyCache = new CPropertyCache();

    if (!pPropertyCache) {
        RRETURN_EXP_IF_ERR(E_FAIL);
    }

    pPropertyCache->_pCoreADsObject = pCoreADsObject;
    pPropertyCache->_pGetAttributeSyntax = pGetAttributeSyntax;
    pPropertyCache->_fGetInfoDone = FALSE;

    *ppPropertyCache = pPropertyCache;

    RRETURN(S_OK);
}


HRESULT
CPropertyCache::SetObjInformation(
    CCredentials* pCredentials,
    LPWSTR pszServerName,
    DWORD dwPortNo
    )
{
    //
    // We need the credentials to be valid
    //
    if (!pCredentials) {
        ADsAssert(!"InvalidCredentials to prop cache");
    } else {
        _pCredentials = pCredentials;
    }

    //
    // This can be NULL, so it is better to allocate and dealloc
    // in destructor
    //
    if (_pszServerName) {
        FreeADsStr(_pszServerName);
        _pszServerName = NULL;
    }

    if (pszServerName) {
        _pszServerName = AllocADsStr(pszServerName);
        if (_pszServerName == NULL) {
            RRETURN(E_OUTOFMEMORY);
        }
    }

    _dwPort = dwPortNo;

    RRETURN(S_OK);
}
//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::flushpropertycache
//
//  Synopsis:   Flushes the property cache of all data.
//
//  The name <-> index mappings need to stay until the property cache is
//  destructed, because the indexes are also used as the DISPIDs of the
//  properties.  So this neither deallocates the names nor the array itself.
//
//-------------------------------------------------------------------------
void
CPropertyCache::
flushpropertycache()
{
    DWORD i = 0;
    PPROPERTY pThisProperty = NULL;

    if (_pProperties) {

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

            pThisProperty = _pProperties + i;

            if (pThisProperty->szPropertyName) {
               FreeADsStr(pThisProperty->szPropertyName);
               pThisProperty->szPropertyName = NULL;
            }

            LdapTypeFreeLdapObjects(&(PROPERTY_LDAPOBJECTARRAY(pThisProperty)));
            PROPERTY_FLAGS(pThisProperty) = PROPERTY_INIT;
        }

        FreeADsMem(_pProperties);

        _pProperties = NULL;
        _dwMaxProperties = 0;
        _cb = 0;

    }

    //
    // Reset the property cache
    //

    _dwCurrentIndex = 0;
    _fGetInfoDone = FALSE;
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::unmarshallproperty
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------

HRESULT
CPropertyCache::
unmarshallproperty(
    LPWSTR szPropertyName,
    PADSLDP pLdapHandle,
    LDAPMessage *entry,
    DWORD  dwSyntaxId,
    BOOL   fExplicit,
    BOOL * pfRangeRetrieval // defaulted to NULL
    )
{
    DWORD dwIndex = 0;
    HRESULT hr = S_OK;
    LDAPOBJECTARRAY ldapObjectArray;
    LPWSTR pszTemp = NULL;

    LDAPOBJECTARRAY_INIT(ldapObjectArray);

    //
    // If arg is valid default value to false.
    //
    if (pfRangeRetrieval) {
        *pfRangeRetrieval = FALSE;
    }

    hr = UnMarshallLDAPToLDAPSynID(
             szPropertyName,
             pLdapHandle,
             entry,
             dwSyntaxId,
             &ldapObjectArray
             );

    //
    // Need to look for ; as in members;range or value;binary
    // and strip the ; out before adding to cache.
    //
    if ((pszTemp = wcschr(szPropertyName, L';')) != NULL ) {
            *pszTemp = L'\0';
    }
    //
    // Find this property in the cache
    //

    hr = findproperty(
                szPropertyName,
                &dwIndex
                );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //


    if (FAILED(hr)) {
        hr = addproperty(
                    szPropertyName
                    );

        //
        // If the operation fails for some reason
        // move on to the next property
        //
        BAIL_ON_FAILURE(hr);

    }

    //
    // Now update the property in the cache
    //

    hr = updateproperty(
                    szPropertyName,
                    dwSyntaxId,
                    ldapObjectArray,
                    fExplicit
                    );
    BAIL_ON_FAILURE(hr);

    //
    // Put the ; back if we replaced it.
    //
    if (pszTemp) {

        //
        // Do we need to update the flag ?
        //
        if (pfRangeRetrieval) {
            //
            // See if this was members and update flag.
            //
            if (!_wcsicmp(L"member", szPropertyName)) {
                *pfRangeRetrieval = TRUE;
            }
        }

        *pszTemp = L';';

    }

    if ( ldapObjectArray.fIsString )
        LdapValueFree( (TCHAR **) ldapObjectArray.pLdapObjects );
    else
        LdapValueFreeLen( (struct berval **) ldapObjectArray.pLdapObjects );

error:

    RRETURN_EXP_IF_ERR(hr);
}


HRESULT
CPropertyCache::
LDAPUnMarshallProperties(
    LPWSTR   pszServerPath,
    PADSLDP pLdapHandle,
    LDAPMessage *ldapmsg,
    BOOL     fExplicit,
    CCredentials& Credentials
    )
{
    int nNumberOfEntries = 0L;
    int nNumberOfValues = 0L;
    HRESULT hr = S_OK;
    DWORD i = 0;
    LDAPMessage *entry;
    LPWSTR pszAttrName = NULL;
    void *ptr;

    OBJECTINFO ObjectInfo;
    POBJECTINFO pObjectInfo = &ObjectInfo;

    memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    //
    // Compute the number of attributes in the
    // read buffer.

    nNumberOfEntries = LdapCountEntries( pLdapHandle, ldapmsg );

    if ( nNumberOfEntries == 0 )
        RRETURN(S_OK);

    hr = LdapFirstEntry( pLdapHandle, ldapmsg, &entry );

    BAIL_ON_FAILURE(hr);

    hr = LdapFirstAttribute( pLdapHandle, entry, &ptr, &pszAttrName );
    BAIL_ON_FAILURE(hr);

    while ( pszAttrName != NULL )
    {
        DWORD dwSyntax = LDAPTYPE_UNKNOWN;

        LPWSTR pszADsPath;
        hr = _pCoreADsObject->get_CoreADsPath(&pszADsPath);
        BAIL_ON_FAILURE(hr);

        hr = ADsObject(pszADsPath, pObjectInfo);
        BAIL_ON_FAILURE(hr);

        //
        // unmarshall this property into the
        // property cache.
        // LdapGetSyntax takes care of ; while looking up
        // the schema no need to handle at this level.
        //
        hr = LdapGetSyntaxOfAttributeOnServer(
                 pszServerPath,
                 pszAttrName,
                 &dwSyntax,
                 Credentials,
                 pObjectInfo->PortNumber,
                 TRUE // fForce
                 );
        ADsFreeString(pszADsPath);

        if ( SUCCEEDED(hr) && (dwSyntax != LDAPTYPE_UNKNOWN))
        {
            if ( (!_wcsicmp(pszAttrName, L"ntSecurityDescriptor")) &&
                 (dwSyntax == LDAPTYPE_OCTETSTRING) )
            {
                dwSyntax = LDAPTYPE_SECURITY_DESCRIPTOR;
            }

            (VOID) unmarshallproperty(
                       pszAttrName,
                       pLdapHandle,
                       entry,
                       dwSyntax,
                       fExplicit
                       );
        }

        LdapAttributeFree( pszAttrName );
        pszAttrName = NULL;

        //
        // If we cannot find the syntax, ignore the property and
        // continue with the next property
        //
        hr = S_OK;

        hr = LdapNextAttribute( pLdapHandle, entry, ptr, &pszAttrName );

        BAIL_ON_FAILURE(hr);

        FreeObjectInfo(pObjectInfo);

        memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    }

error:

    FreeObjectInfo(pObjectInfo);

    RRETURN_EXP_IF_ERR(hr);

}

////////////////////////////////////////////////////////////////////////
//
// Unmarshall attributes (& their values) in [ldapmsg] into cache.
// Syntaxes of attributes are read from schema on server [pszServerPath].
// If an attribute not in the schema (e.g. not in our default schema used
// in case of schemaless server), the attribute is unmarshalled as ldap
// binary data with type = LDAPTYPE_UNKWNON.
//
// [Credentials]
//      - used to access pszServerPath
//
// [pLdapHandle]
//      - handle assoc with [ldapmsg]
//      - used to retrive attributes and their values from [ldapmsg]
//
// [fExplicit]
//      - overwrite value of exiting attributes in cache iff = TRUE
//
// NOTE: This function modified LDAPUnMarshallProperties to allow
// unmarshalling of attributes not in the schema.
//
////////////////////////////////////////////////////////////////////////

HRESULT
CPropertyCache::
LDAPUnMarshallProperties2(
    IN LPWSTR   pszServerPath,
    IN PADSLDP pLdapHandle,
    IN LDAPMessage *ldapmsg,
    IN BOOL     fExplicit,
    IN CCredentials& Credentials,
    OUT BOOL * pfRangeRetrieval
    )
{

    HRESULT hr = S_OK;
    int nNumberOfEntries = 0L;
    LDAPMessage *entry = NULL;
    void *ptr = NULL;
    LPWSTR pszAttrName = NULL;
    DWORD dwSyntax = LDAPTYPE_UNKNOWN;
    LPWSTR pszADsPath = NULL;
    OBJECTINFO ObjectInfo;
    BOOL fRange = FALSE;
    memset(&ObjectInfo, 0, sizeof(OBJECTINFO));

    ADsAssert(pfRangeRetrieval);
    *pfRangeRetrieval = FALSE;

    if (!pLdapHandle || !ldapmsg)
        RRETURN(E_ADS_BAD_PARAMETER);


    //
    // Compute the number of attributes in the read buffer.
    //

    nNumberOfEntries = LdapCountEntries(pLdapHandle, ldapmsg);

    if ( nNumberOfEntries == 0 )
        RRETURN(S_OK);


    //
    // get port number to talk to server on which schema locate ???
    //

    hr = _pCoreADsObject->get_CoreADsPath(&pszADsPath);
    BAIL_ON_FAILURE(hr);

    hr = ADsObject(pszADsPath, &ObjectInfo);
    BAIL_ON_FAILURE(hr);


    //
    // Get first entry from ldapmsg first. Should be only one entry.
    //

    hr = LdapFirstEntry( pLdapHandle, ldapmsg, &entry );
    BAIL_ON_FAILURE(hr);


    //
    // get first attribute's name
    //

    hr = LdapFirstAttribute( pLdapHandle, entry, &ptr, &pszAttrName );
    BAIL_ON_FAILURE(hr);


    while ( pszAttrName != NULL )
    {
        //
        // get syntax of attribute from schema on sever (may be cached);
        // continue to unmarshall the attribute even if it isn't in the
        // schema.
        //

        dwSyntax = LDAPTYPE_UNKNOWN;

        (VOID) LdapGetSyntaxOfAttributeOnServer(
                    pszServerPath,
                    pszAttrName,
                    &dwSyntax,
                    Credentials,
                    ObjectInfo.PortNumber,
                    TRUE // fForce
                    );


        //
        // There is currently no such syntax as "SecurityDescriptor" on
        // server, ADSI will unmarshall "OctetString" security descriptor
        // as as ntSecurityDescriptor
        //

        if ( (!_wcsicmp(pszAttrName, L"ntSecurityDescriptor"))
                &&   (dwSyntax == LDAPTYPE_OCTETSTRING)
           )
        {
               dwSyntax = LDAPTYPE_SECURITY_DESCRIPTOR;
        }

        //
        // unmarshall the property into cache, LDAPTYPE_UNWKNOWN
        // (dwSyntax) will be unmarshalled as binary data.
        //

        (VOID) unmarshallproperty(
                       pszAttrName,
                       pLdapHandle,
                       entry,
                       dwSyntax,
                       fExplicit,
                       fRange ? NULL : pfRangeRetrieval
                       );

        //
        // Small trick to make sure we do not loose the range
        // retrieval information for members attribute.
        //
        fRange = *pfRangeRetrieval;

        //
        // get next attribute
        //

        LdapAttributeFree( pszAttrName );
        pszAttrName = NULL;
        hr = LdapNextAttribute( pLdapHandle, entry, ptr, &pszAttrName );
        BAIL_ON_FAILURE(hr);
    }

error:

    if (pszADsPath)
        ADsFreeString(pszADsPath);

    FreeObjectInfo(&ObjectInfo);

    RRETURN_EXP_IF_ERR(hr);

}



HRESULT
CPropertyCache::
LDAPMarshallProperties(
    LDAPModW ***aMods,
    PBOOL pfNTSecDes,
    SECURITY_INFORMATION *pSeInfo
    )
{

    HRESULT hr = S_OK;
    DWORD i = 0;
    DWORD j = 0;
    PPROPERTY pThisProperty = NULL;
    int dwCount = 0;
    LDAPModW *aModsBuffer = NULL;
    LDAPOBJECTARRAY ldapObjectArray;
    
    PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;

    BOOL fDaclDefaulted = FALSE;
    BOOL fSaclDefaulted = FALSE;
    BOOL fOwnerDefaulted = FALSE;
    BOOL fGroupDefaulted = FALSE;

    PSID pOwnerSid = NULL;
    PSID pGroupSid = NULL;
    PACL pDacl = NULL;
    PACL pSacl = NULL;
    
    BOOL DaclPresent = FALSE;
    BOOL SaclPresent = FALSE;

    BOOL fSecDesProp = FALSE;

    *pSeInfo = INVALID_SE_VALUE;
    *pfNTSecDes = FALSE;

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

        pThisProperty = _pProperties + i;

        //
        // Bypass any property that has not been
        // modified
        //

        if (PROPERTY_FLAGS(pThisProperty) != PROPERTY_INIT)
            dwCount++;
    }

    if ( dwCount == 0 )  // Nothing to change
    {
        *aMods = NULL;
        RRETURN(S_OK);
    }

    *aMods = (LDAPModW **) AllocADsMem((dwCount+1) * sizeof(LDAPModW *));

    if ( *aMods == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    aModsBuffer = (LDAPModW *) AllocADsMem( dwCount * sizeof(LDAPModW));

    if ( aModsBuffer == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    for (i = 0, j = 0; i < _dwMaxProperties; i++) {

        pThisProperty = _pProperties + i;

        //
        // Bypass any property that has not been
        // modified
        //

        if (PROPERTY_FLAGS(pThisProperty) == PROPERTY_INIT ) {

            continue;
        }


        if (!_wcsicmp(PROPERTY_NAME(pThisProperty),L"ntSecurityDescriptor")) {
            *pfNTSecDes = TRUE;
            fSecDesProp = TRUE;
        } else {
            fSecDesProp = FALSE;
        }

        ldapObjectArray = PROPERTY_LDAPOBJECTARRAY(pThisProperty);

        (*aMods)[j] = &aModsBuffer[j];
        aModsBuffer[j].mod_type   = PROPERTY_NAME(pThisProperty);

        if ( ldapObjectArray.fIsString )
        {
            aModsBuffer[j].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects;
        }
        else
        {
            aModsBuffer[j].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects;
            aModsBuffer[j].mod_op = LDAP_MOD_BVALUES;
            if (fSecDesProp) {
                pSecurityDescriptor = LDAPOBJECT_BERVAL_VAL(ldapObjectArray.pLdapObjects);

                if ( GetSecurityDescriptorOwner(
                                pSecurityDescriptor,
                                &pOwnerSid,
                                &fOwnerDefaulted
                                )
                            &&
                     
                     GetSecurityDescriptorGroup(
                                pSecurityDescriptor,
                                &pGroupSid,
                                &fGroupDefaulted
                                    )
                            &&

                     GetSecurityDescriptorDacl(
                                pSecurityDescriptor,
                                &DaclPresent,
                                &pDacl,
                                &fDaclDefaulted
                                )
                            &&
                     
                     GetSecurityDescriptorSacl(
                                pSecurityDescriptor,
                                &SaclPresent,
                                &pSacl,
                                &fSaclDefaulted
                                )
                   ) {
                    //
                    // All the calls succeeded, so we should reset to 0
                    // instead of the invalid value.
                    //
                    *pSeInfo = 0;

                    if (!fOwnerDefaulted) {
                        *pSeInfo = *pSeInfo | OWNER_SECURITY_INFORMATION;
                    }

                    if (!fGroupDefaulted) {
                        *pSeInfo = *pSeInfo | GROUP_SECURITY_INFORMATION;
                    }

                    //
                    // If the DACL is present we need to send DACL bit.
                    // 
                    if (DaclPresent) {
                        *pSeInfo = *pSeInfo | DACL_SECURITY_INFORMATION;
                    }

                    //
                    // If SACL present then we set the SACL bit.
                    if (SaclPresent) {
                        *pSeInfo = *pSeInfo | SACL_SECURITY_INFORMATION;
                    }

                }

            }
        }

        switch( PROPERTY_FLAGS(pThisProperty))
        {
            case PROPERTY_UPDATE:
                aModsBuffer[j].mod_op |= LDAP_MOD_REPLACE;
                break;

            case PROPERTY_ADD:
                aModsBuffer[j].mod_op |= LDAP_MOD_ADD;
                break;

            case PROPERTY_DELETE:
                aModsBuffer[j].mod_op |= LDAP_MOD_DELETE;
                break;


            case PROPERTY_DELETE_VALUE:
                aModsBuffer[j].mod_op |= LDAP_MOD_DELETE;
                break;

        }

        j++;

    }


    RRETURN(hr);

error:

    FreeADsMem( aModsBuffer );
    FreeADsMem( *aMods );

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CPropertyCache::
LDAPMarshallProperties2(
    LDAPModW ***aMods,
    DWORD *pdwNumOfMods
    )
{

    HRESULT hr = S_OK;
    DWORD i = 0;
    DWORD j = 0;
    PPROPERTY pThisProperty = NULL;
    int dwCount = 0;
    LDAPModW *aModsBuffer = NULL;
    LDAPOBJECTARRAY ldapObjectArray;

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

        pThisProperty = _pProperties + i;

        //
        // Bypass any property that has not been
        // modified
        //

        if (PROPERTY_FLAGS(pThisProperty) != PROPERTY_INIT)
            dwCount++;
    }

    if ( dwCount == 0 )  // Nothing to change
        RRETURN(S_OK);

    if ( *aMods == NULL )
    {
        *aMods = (LDAPModW **) AllocADsMem((dwCount+1) * sizeof(LDAPModW *));

        if ( *aMods == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        aModsBuffer = (LDAPModW *) AllocADsMem( dwCount * sizeof(LDAPModW));

        if ( aModsBuffer == NULL )
        {
            FreeADsMem( *aMods );
            *aMods = NULL;
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }
    }
    else
    {
        LDAPModW **aModsTemp = NULL;

        aModsTemp = (LDAPModW **) AllocADsMem(
                        (*pdwNumOfMods+ dwCount + 1) * sizeof(LDAPModW *));

        if ( aModsTemp == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        aModsBuffer = (LDAPModW *) AllocADsMem(
                          (*pdwNumOfMods + dwCount) * sizeof(LDAPModW));

        if ( aModsBuffer == NULL )
        {
            FreeADsMem( aModsTemp );
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        memcpy( aModsBuffer, **aMods, *pdwNumOfMods * sizeof(LDAPModW));
        FreeADsMem( **aMods );
        FreeADsMem( *aMods );

        *aMods = aModsTemp;

        for ( j = 0; j < *pdwNumOfMods; j++ )
        {
            (*aMods)[j] = &aModsBuffer[j];
        }
    }

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

        pThisProperty = _pProperties + i;

        //
        // Bypass any property that has not been
        // modified
        //

        if (PROPERTY_FLAGS(pThisProperty) == PROPERTY_INIT ) {

            continue;
        }

        ldapObjectArray = PROPERTY_LDAPOBJECTARRAY(pThisProperty);

        (*aMods)[j] = &aModsBuffer[j];
        aModsBuffer[j].mod_type   = PROPERTY_NAME(pThisProperty);

        if ( ldapObjectArray.fIsString )
        {
            aModsBuffer[j].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects;
        }
        else
        {
            aModsBuffer[j].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects;
            aModsBuffer[j].mod_op = LDAP_MOD_BVALUES;
        }

        switch( PROPERTY_FLAGS(pThisProperty))
        {
            case PROPERTY_UPDATE:
                aModsBuffer[j].mod_op |= LDAP_MOD_REPLACE;
                break;

            case PROPERTY_ADD:
                aModsBuffer[j].mod_op |= LDAP_MOD_ADD;
                break;

            case PROPERTY_DELETE:
                aModsBuffer[j].mod_op |= LDAP_MOD_DELETE;
                break;
        }

        j++;

    }

    *pdwNumOfMods += dwCount;

error:

    RRETURN_EXP_IF_ERR(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::unboundgetproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName]    --  Property to retrieve from the cache
//              [pvaData]           --  Data returned in a variant
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
unboundgetproperty(
    LPWSTR  szPropertyName,
    PDWORD  pdwSyntaxId,
    PDWORD  pdwStatusFlag,
    LDAPOBJECTARRAY *pLdapObjectArray
    )
{
    HRESULT hr;
    DWORD dwIndex = 0L;


    //
    // get index of property in cache
    //

    hr = findproperty(
            szPropertyName,
            &dwIndex
            );
    BAIL_ON_FAILURE(hr);


    //
    // get property based on index in cache
    //

    hr = unboundgetproperty(
            dwIndex,
            pdwSyntaxId,
            pdwStatusFlag,
            pLdapObjectArray
            );

error:

   RRETURN_EXP_IF_ERR(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::unboundgetproperty
//
//  Synopsis: Note that this version takes the index of the element to
//      fetch. It also returns the control code of the item in the cache.
//
//
//  Arguments:  [dwIndex]           --  Index of the property to retrieve.
//              [pdwSytnaxId]       --  SyntaxId of the data.
//              [pdwStatusFlag]     --  Status of this property in cache.
//              [pLdapObjectArray]  --  Array of ldapObjects returned.
//
//  NOTE: [dwIndex] is invalid -> E_ADS_PROPERTY_NOT_FOUND//E_FAIL ???
//
//-------------------------------------------------------------------------

HRESULT
CPropertyCache::
unboundgetproperty(
    DWORD dwIndex,
    PDWORD pdwSyntaxId,
    PDWORD pdwStatusFlag,
    LDAPOBJECTARRAY *pLdapObjectArray
    )
{
    HRESULT hr = S_OK;
    PPROPERTY pThisProperty = NULL;


    if (!index_valid(dwIndex))
        RRETURN(E_ADS_PROPERTY_NOT_FOUND);

    pThisProperty = _pProperties + dwIndex;


    // Status flag has to be valid if we found the property
    *pdwStatusFlag = PROPERTY_FLAGS(pThisProperty);


    if (PROPERTY_LDAPOBJECTARRAY(pThisProperty).pLdapObjects) {

        //
        // property has non-empty values
        //

        *pdwSyntaxId = (DWORD)PROPERTY_SYNTAX(pThisProperty);

        hr = LdapTypeCopyConstruct(
                PROPERTY_LDAPOBJECTARRAY(pThisProperty),
                pLdapObjectArray
                );
        BAIL_ON_FAILURE(hr);

    }else {

        //
        // property has empty values: E.g. status flag indicate delete
        // operation (or empty values allowed on non-ntds ldap server?)
        //

        pLdapObjectArray->pLdapObjects = NULL;
        pLdapObjectArray->dwCount = 0;
        *pdwSyntaxId = LDAPTYPE_UNKNOWN;
        //hr = E_FAIL;
    }

error:

   RRETURN(hr);
}


void
CPropertyCache::
reset_propindex(
    )
{
  _dwCurrentIndex = 0;

}


HRESULT
CPropertyCache::
skip_propindex(
    DWORD dwElements
    )
{
    DWORD newIndex = _dwCurrentIndex + dwElements;

    if (!index_valid())
        RRETURN_EXP_IF_ERR(E_FAIL);

    //
    // - allow current index to go from within range to out of range by 1
    // - by 1 since initial state is out of range by 1
    //

    if ( newIndex > _dwMaxProperties )
        RRETURN_EXP_IF_ERR(E_FAIL);

    _dwCurrentIndex = newIndex;
    RRETURN(S_OK);

}

HRESULT
CPropertyCache::
get_PropertyCount(
    PDWORD pdwMaxProperties
    )
{
    ADsAssert(pdwMaxProperties);    // function private -> use assertion

    *pdwMaxProperties = _dwMaxProperties;

    RRETURN(S_OK);
}

DWORD
CPropertyCache::
get_CurrentIndex(
    )
{
    return(_dwCurrentIndex);
}


LPWSTR
CPropertyCache::
get_CurrentPropName(
    )

{
    PPROPERTY pThisProperty = NULL;

    if (!index_valid())
       return(NULL);

    pThisProperty = _pProperties + _dwCurrentIndex;

    return(PROPERTY_NAME(pThisProperty));
}


LPWSTR
CPropertyCache::
get_PropName(
    DWORD dwIndex
    )

{
    PPROPERTY pThisProperty = NULL;

    if (!index_valid(dwIndex))
       return(NULL);

    pThisProperty = _pProperties + dwIndex;

    return(PROPERTY_NAME(pThisProperty));
}



HRESULT
CPropertyCache::
LDAPUnMarshallPropertyAs(
    LPWSTR   pszServerPath,
    PADSLDP pLdapHandle,
    LDAPMessage *ldapmsg,
    LPWSTR szPropertyName,
    DWORD dwSyntaxId,
    BOOL     fExplicit,
    CCredentials& Credentials
    )
{
    int nNumberOfEntries = 0L;
    int nNumberOfValues = 0L;
    HRESULT hr = S_OK;
    DWORD i = 0;
    LDAPMessage *entry;
    LPWSTR pszAttrName = NULL;
    void *ptr;

    OBJECTINFO ObjectInfo;
    POBJECTINFO pObjectInfo = &ObjectInfo;


    memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    //
    // Compute the number of attributes in the
    // read buffer.
    //

    nNumberOfEntries = LdapCountEntries( pLdapHandle, ldapmsg );

    if ( nNumberOfEntries == 0 )
        RRETURN(S_OK);

    hr = LdapFirstEntry( pLdapHandle, ldapmsg, &entry );

    BAIL_ON_FAILURE(hr);

    hr = LdapFirstAttribute( pLdapHandle, entry, &ptr, &pszAttrName );
    BAIL_ON_FAILURE(hr);

    while ( pszAttrName != NULL )
    {
        DWORD dwSyntax = LDAPTYPE_UNKNOWN;

        LPWSTR pszADsPath;
        hr = _pCoreADsObject->get_CoreADsPath(&pszADsPath);
        BAIL_ON_FAILURE(hr);

        hr = ADsObject(pszADsPath, pObjectInfo);
        BAIL_ON_FAILURE(hr);

        //
        // unmarshall this property into the
        // property cache
        //
        hr = LdapGetSyntaxOfAttributeOnServer(
                 pszServerPath,
                 pszAttrName,
                 &dwSyntax,
                 Credentials,
                 pObjectInfo->PortNumber
                 );
        ADsFreeString(pszADsPath);

        if ( SUCCEEDED(hr) && (dwSyntax != LDAPTYPE_UNKNOWN))
        {
            if ( (!_wcsicmp(pszAttrName, L"ntSecurityDescriptor")) &&
                 (dwSyntax == LDAPTYPE_OCTETSTRING) )
            {
                dwSyntax = LDAPTYPE_SECURITY_DESCRIPTOR;
            }

            (VOID) unmarshallproperty(
                       pszAttrName,
                       pLdapHandle,
                       entry,
                       dwSyntax,
                       fExplicit
                       );
        }else {

            if (!_wcsicmp(pszAttrName, szPropertyName)) {

                (VOID) unmarshallproperty(
                           pszAttrName,
                           pLdapHandle,
                           entry,
                           dwSyntaxId,
                           fExplicit
                           );

            }


        }

        LdapAttributeFree( pszAttrName );
        pszAttrName = NULL;

        //
        // If we cannot find the syntax, ignore the property and
        // continue with the next property
        //
        hr = S_OK;

        hr = LdapNextAttribute( pLdapHandle, entry, ptr, &pszAttrName );

        BAIL_ON_FAILURE(hr);

        FreeObjectInfo(pObjectInfo);

        memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    }

error:

    FreeObjectInfo(pObjectInfo);

    RRETURN_EXP_IF_ERR(hr);

}



HRESULT
CPropertyCache::
LDAPUnMarshallPropertiesAs(
    LPWSTR   pszServerPath,
    PADSLDP pLdapHandle,
    LDAPMessage *ldapmsg,
    DWORD dwSyntaxId,
    BOOL     fExplicit,
    CCredentials& Credentials
    )
{
    int nNumberOfEntries = 0L;
    int nNumberOfValues = 0L;
    HRESULT hr = S_OK;
    DWORD i = 0;
    LDAPMessage *entry;
    LPWSTR pszAttrName = NULL;
    void *ptr;

    //
    // Compute the number of attributes in the
    // read buffer.
    //

    nNumberOfEntries = LdapCountEntries( pLdapHandle, ldapmsg );

    if ( nNumberOfEntries == 0 )
        RRETURN(S_OK);

    hr = LdapFirstEntry( pLdapHandle, ldapmsg, &entry );

    BAIL_ON_FAILURE(hr);

    hr = LdapFirstAttribute( pLdapHandle, entry, &ptr, &pszAttrName );
    BAIL_ON_FAILURE(hr);

    while ( pszAttrName != NULL )
    {
        (VOID) unmarshallproperty(
                   pszAttrName,
                   pLdapHandle,
                   entry,
                   dwSyntaxId,
                   fExplicit
                   );

        LdapAttributeFree( pszAttrName );
        pszAttrName = NULL;

        hr = LdapNextAttribute( pLdapHandle, entry, ptr, &pszAttrName );

        BAIL_ON_FAILURE(hr);
    }

error:

    RRETURN_EXP_IF_ERR(hr);

}

HRESULT
CPropertyCache::
deleteproperty(
    DWORD dwIndex
    )
{
   HRESULT hr = S_OK;
   PPROPERTY pNewProperties = NULL;
   PPROPERTY pThisProperty = _pProperties + dwIndex;

   if (!index_valid(dwIndex)) {
      hr = E_FAIL;
      BAIL_ON_FAILURE(hr);
   }

   if (_dwMaxProperties == 1) {
      //
      // Deleting everything
      //
      FreeADsStr(pThisProperty->szPropertyName);
      LdapTypeFreeLdapObjects( &(PROPERTY_LDAPOBJECTARRAY(pThisProperty)) );
      FreeADsMem(_pProperties);
      _pProperties = NULL;
      _dwMaxProperties = 0;
      _cb = 0;
      //
      // Need to reset the current index too just in case.
      //
      _dwCurrentIndex = 0;
      RRETURN(hr);
   }

   pNewProperties = (PPROPERTY)AllocADsMem(
                               _cb - sizeof(PROPERTY)
                               );
   if (!pNewProperties) {
       hr = E_OUTOFMEMORY;
       BAIL_ON_FAILURE(hr);
   }

   //
   // Copying the memory before the deleted item
   //
   if (dwIndex != 0) {
      memcpy( pNewProperties,
              _pProperties,
              dwIndex * sizeof(PROPERTY));
   }

   //
   // Copying the memory following the deleted item
   //
   if (dwIndex != (_dwMaxProperties-1)) {
      memcpy( pNewProperties + dwIndex,
              _pProperties + dwIndex + 1,
              (_dwMaxProperties - dwIndex - 1) * sizeof(PROPERTY));
   }

   FreeADsStr(pThisProperty->szPropertyName);
   LdapTypeFreeLdapObjects( &(PROPERTY_LDAPOBJECTARRAY(pThisProperty)) );
   FreeADsMem(_pProperties);
   _pProperties = pNewProperties;
   _dwMaxProperties--;
   _cb -= sizeof(PROPERTY);

   //
   // Reset the current index if necesary so we do not skip a property.
   //
   if (_dwCurrentIndex > dwIndex) {
       _dwCurrentIndex--;
   }
error:

   RRETURN_EXP_IF_ERR(hr);
}

//
// For dynamic dispid's.
//

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::locateproperty
//
//  Synopsis:   Finds a property in the cache by name.
//
//  This differs from findproperty() in return code; this returns no ADSI
//  errors, since it's going to a VB interface.
//
//  If the property is not found in the cache, this uses the IDirectoryObject
//  interface of the containing object to get the attributes of the object.
//  If GetObjectAttributes doesn't return any information about the property,
//  this method returns DISP_E_UNKNOWNNAME.
//
//  Arguments:  [szPropertyName]        -- Name of the property.
//              [pdwIndex]              -- Index in the array of properties.
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::locateproperty(
    LPWSTR szPropertyName,
    PDWORD pdwIndex
    )
{
    HRESULT hr = findproperty(szPropertyName, pdwIndex);

    if (hr == E_ADS_PROPERTY_NOT_FOUND)
    {
        DWORD dwLdapSyntaxId = 0;
        PPROPERTY pProperty = NULL;

        hr = _pGetAttributeSyntax->GetAttributeSyntax(
            szPropertyName,
            &dwLdapSyntaxId
            );
        BAIL_ON_FAILURE(hr);

        hr = addproperty(szPropertyName);
        BAIL_ON_FAILURE(hr);

        hr = findproperty(szPropertyName, pdwIndex);
        BAIL_ON_FAILURE(hr);

        pProperty = _pProperties + *pdwIndex;
        PROPERTY_SYNTAX(pProperty) = dwLdapSyntaxId;
        PROPERTY_FLAGS(pProperty) = PROPERTY_INIT;
        PROPERTY_LDAPOBJECTARRAY(pProperty).dwCount = 0;
        PROPERTY_LDAPOBJECTARRAY(pProperty).pLdapObjects = NULL;
    }

error:
    //
    // Automation return code would be DISP_E_UNKNOWNNAME.
    // ADSI return code would be E_ADS_PROPERTY_NOT_FOUND (like findproperty.)
    //
    if (FAILED(hr))
        hr = E_ADS_PROPERTY_NOT_FOUND;

    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::getproperty
//
//  Synopsis:   Get the values of a property from the cache.
//              The values are returned as a VARIANT.
//
//  Arguments:  [dwIndex]               -- Index of property to retrieve
//              [pVarResult]            -- Data returned as a VARIANT
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::getproperty(
    DWORD dwIndex,
    PDWORD dwStatusFlag,
    VARIANT *pVarResult,
    CCredentials &Credentials
    )
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId;
    LDAPOBJECTARRAY LdapObjectArray;

    LDAPOBJECTARRAY_INIT(LdapObjectArray);

    //
    // This should not return E_ADS_PROPERTY_NOT_FOUND in this case.
    // We have an index, which should indicate that we have an array entry.
    // If we weren't dealing with VB, I'd be tempted to make this an Assert.
    //
    if (!index_valid(dwIndex))
        BAIL_ON_FAILURE(hr = DISP_E_MEMBERNOTFOUND);

    if (INDEX_EMPTY(dwIndex) && 
        !PROP_DELETED(dwIndex) && 
        !_fGetInfoDone)
    {
        hr = _pCoreADsObject->GetInfo(FALSE);

        // workaround to avoid confusing callers of getproperty.
        if (hr == E_NOTIMPL)
            hr = DISP_E_MEMBERNOTFOUND;
        BAIL_ON_FAILURE(hr);
    }

    hr = unboundgetproperty(
             dwIndex,
             &dwSyntaxId,
             dwStatusFlag,
             &LdapObjectArray
             );

    // For backward compatibility
    if (!LdapObjectArray.pLdapObjects && SUCCEEDED(hr)) {
        hr = E_FAIL;
    }

    if (SUCCEEDED(hr))
    {
        if (LdapObjectArray.dwCount == 1) {
            hr = LdapTypeToVarTypeCopy(
                NULL,
                Credentials,
                LdapObjectArray.pLdapObjects,
                dwSyntaxId,
                pVarResult);
        }
        else {
            hr = LdapTypeToVarTypeCopyConstruct(
                NULL,
                Credentials,
                LdapObjectArray,
                dwSyntaxId,
                pVarResult);
        }
    }
    else
    {
        //
        // unboundgetproperty() returns E_FAIL on failure.
        // But getproperty() should return E_ADS_PROPERTY_NOT_FOUND.
        //
        if (hr == E_FAIL)
            hr = E_ADS_PROPERTY_NOT_FOUND;

        //
        // A proper Automation return value would be
        //   hr = DISP_E_MEMBERNOTFOUND;
        //
        ADsAssert(pVarResult);
        V_VT(pVarResult) = VT_ERROR;
    }

error:
    LdapTypeFreeLdapObjects(&LdapObjectArray);

    RRETURN(hr);
}


//
//
// This is here just so that we can compile, no one should be
// calling this
//
//  - The comment above and within the function is INCORRECT.
//  - At present, this function is called and works with known bug.
//    This function should NOT be a wrap around of getproperty with
//    3 param. The [dwIndex] in this function should have a DIFFERENT
//    meaning than the index in the cache.
//  - Please LEAVE this for irenef to fix before beta2.
//

HRESULT
CPropertyCache::getproperty(
    DWORD dwIndex,
    VARIANT *pVarResult,
    CCredentials &Credentials
    )
{
    HRESULT hr = S_OK;
    DWORD dwStatus = 0;

    // Ideally we need to get rid of this but this would mean that
    // we need to change the cdispmgr code and the IPropertyCache
    // interface.
    hr = getproperty(
             dwIndex,
             &dwStatus,
             pVarResult,
             Credentials
             );

    if (hr == E_ADS_PROPERTY_NOT_FOUND)
    {
        hr = DISP_E_MEMBERNOTFOUND;
    }

    RRETURN(hr);
}


//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::putproperty
//
//  Synopsis:   Updates a property in the property cache.
//              The property is specified by its index in the array of
//              properties (which is also its DISPID), and the new value
//              is given by a VARIANT.
//
//  Arguments:  [dwIndex]               -- Index of the property.
//              [varValue]              -- Value of the property.
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::putproperty(
    DWORD dwIndex,
    VARIANT vValue
    )
{
    HRESULT hr;
    LDAPOBJECTARRAY LdapObjectArray;
    DWORD dwLdapType;

    LDAPOBJECTARRAY_INIT(LdapObjectArray);

    VARIANT *pvValue = &vValue, *pvArray = NULL;
    DWORD dwNumValues = 1;

    //
    // This should not return E_ADS_PROPERTY_NOT_FOUND in this case.
    // We have an index, which should indicate that we have an array entry.
    // If we weren't dealing with VB, I'd be tempted to make this an Assert.
    //
    if (!index_valid(dwIndex))
        BAIL_ON_FAILURE(hr = DISP_E_MEMBERNOTFOUND);


    //
    // If we get a safe array of variants, convert it to a regular array
    // of variants, so we can pass the first one to GetLdapSyntaxFromVariant.
    // We assume that all the elements of the array are of the same type
    //
    if (V_VT(pvValue) == (VT_VARIANT|VT_ARRAY))
    {
        hr = ConvertSafeArrayToVariantArray(vValue, &pvArray, &dwNumValues);
        BAIL_ON_FAILURE(hr);
        pvValue = pvArray;
    }

    //
    // - dwLdapType in cache can be LDAPTYPE_UNKNOWN.
    // - for consistency btw this function and Put/PutEx, will
    //   get type from input VARIANT and overwrite existing type in
    //   cache if any
    //

    ADsAssert(_pCredentials);

    hr = GetLdapSyntaxFromVariant(
             pvValue,
             &dwLdapType,
             _pszServerName,
             (_pProperties+dwIndex)->szPropertyName,
             *_pCredentials,
             _dwPort
             );

    BAIL_ON_FAILURE(hr);

    hr = VarTypeToLdapTypeCopyConstruct(
        _pszServerName,
        *_pCredentials,
        dwLdapType,
        pvValue,
        dwNumValues,
        &LdapObjectArray
        );
    BAIL_ON_FAILURE(hr);

    hr = putproperty(dwIndex, PROPERTY_UPDATE, dwLdapType, LdapObjectArray);
    BAIL_ON_FAILURE(hr);

error:
    // if (hr == E_ADS_CANT_CONVERT_DATATYPE)
    //     hr = DISP_E_TYPEMISMATCH;

    LdapTypeFreeLdapObjects(&LdapObjectArray);

    if (pvArray) {

        for (DWORD i=0; i < dwNumValues; i++) {
            VariantClear(pvArray + i);
        }

        FreeADsMem(pvArray);
    }

    RRETURN(hr);
}


//
// This method is called by _pCoreADsObject->GetInfo().  It signifies
// exactly that the property cache has been filled with all the data
// the server has, i.e. that a GetInfo() has been done.  When this is
// set, further implicit calls to GetInfo are skipped.  This flag is
// cleared only by "flushpropertycache".
//
void
CPropertyCache::setGetInfoFlag()
{
    _fGetInfoDone = TRUE;
}

//+------------------------------------------------------------------------
//
//  Function:   CPropertyCache::findproperty
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName] --
//              [pdwIndex]       --
//
//-------------------------------------------------------------------------
HRESULT
CPropertyCache::
DispatchFindProperty(
    LPWSTR szPropertyName,
    PDWORD pdwIndex
    )
{
    DWORD i = 0;
    PDISPPROPERTY pThisDispProperty = NULL;

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

        pThisDispProperty = _pDispProperties + i;

        if (!_wcsicmp(pThisDispProperty->szPropertyName, szPropertyName)) {
            *pdwIndex = i;
            RRETURN(S_OK);
        }
    }

    *pdwIndex = 0;
    RRETURN(E_ADS_PROPERTY_NOT_FOUND);

}

//+---------------------------------------------------------------------------
// Function:   CPropertyCache::GetPropertyNames.
//
// Synopsis:   Gets a list of the names of the properties in this object.
//
// Arguments:  ppUmiPropVals    -   Contains the return value.
//
// Returns:    S_OK, or any appropriate error code.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyCache::GetPropertyNames(
    UMI_PROPERTY_VALUES **ppUmiPropVals
    )
{
    HRESULT hr = S_OK;
    PUMI_PROPERTY_VALUES pUmiPropVals = NULL;
    PUMI_PROPERTY pUmiProps = NULL;
    PPROPERTY pNextProperty = NULL;
    DWORD dwCtr = 0;

    ADsAssert(ppUmiPropVals);

    //
    // Always have only 1 value.
    //
    pUmiPropVals = (PUMI_PROPERTY_VALUES) 
                       AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
    if (!pUmiPropVals) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    if (!_dwMaxProperties) {
        //
        // No properties, we need to special case this.
        //
        *ppUmiPropVals = pUmiPropVals;
        RRETURN(S_OK);
    }

    pUmiProps = (PUMI_PROPERTY) AllocADsMem(
                    _dwMaxProperties * sizeof(UMI_PROPERTY)
                    );

    if (!pUmiProps) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    
    for(dwCtr = 0; dwCtr < _dwMaxProperties; dwCtr++) {
        pNextProperty = _pProperties + dwCtr;

        pUmiProps[dwCtr].pszPropertyName =
            (LPWSTR) AllocADsStr(pNextProperty->szPropertyName);
        if(pUmiProps[dwCtr].pszPropertyName == NULL) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }

        pUmiProps[dwCtr].uCount = 0;
        //
        // Put correct operation type
        //
        hr = ConvertLdapCodeToUmiPropCode(
                 pNextProperty->dwFlags,
                 pUmiProps[dwCtr].uOperationType
                 );
        //
        // Verify that this is the right thing to do.
        // 
        pUmiProps[dwCtr].uType = UMI_TYPE_NULL;
    }

    pUmiPropVals->uCount = _dwMaxProperties;
    pUmiPropVals->pPropArray = pUmiProps;

    *ppUmiPropVals = pUmiPropVals;

    RRETURN(S_OK);

error:

    if(pUmiProps != NULL) {
        for(dwCtr = 0; dwCtr < _dwMaxProperties; dwCtr++) {
            if(pUmiProps[dwCtr].pszPropertyName != NULL) {
                FreeADsStr(pUmiProps[dwCtr].pszPropertyName);
            }
        }
        FreeADsMem(pUmiProps);
    }

    if (pUmiProps) {
        FreeADsMem(pUmiPropVals);
    }

    RRETURN(hr);
}

HRESULT
CPropertyCache::
AddSavingEntry(
    LPWSTR propertyName
    )
{
    HRESULT hr = S_OK;
    PSAVINGENTRY tempEntry = NULL;
    BOOL fResult = FALSE;

    fResult = FindSavingEntry(propertyName);

    if(!fResult) {
    	tempEntry = new SAVINGENTRY;
        if(!tempEntry) {
            hr = E_OUTOFMEMORY;
    	    BAIL_ON_FAILURE(hr);
        }
    
        tempEntry->entryData = AllocADsStr(propertyName);
        if(!(tempEntry->entryData)) {
            hr = E_OUTOFMEMORY;
            delete tempEntry;
         	
            BAIL_ON_FAILURE(hr);
        }
    
        InsertTailList( &_ListSavingEntries, &tempEntry->ListEntry );
    }
    
error:

	return hr;	
    
}

BOOL
CPropertyCache::
FindSavingEntry(
    LPWSTR propertyName
    )
{
    PLIST_ENTRY listEntry = NULL;
    PSAVINGENTRY EntryInfo = NULL;
    BOOL fResult = FALSE;

    listEntry = _ListSavingEntries.Flink;
    while (listEntry != &_ListSavingEntries) {
        EntryInfo = CONTAINING_RECORD( listEntry, SAVINGENTRY, ListEntry );
        if (!_wcsicmp(EntryInfo->entryData, propertyName)) {
            fResult = TRUE;
            break;
        }

        listEntry = listEntry->Flink;
    }

    return fResult;

}

HRESULT
CPropertyCache::
DeleteSavingEntry()
{
    PLIST_ENTRY pEntry;
    PSAVINGENTRY EntryInfo;

    while (!IsListEmpty (&_ListSavingEntries)) {
        pEntry = RemoveHeadList (&_ListSavingEntries);
        EntryInfo = CONTAINING_RECORD (pEntry, SAVINGENTRY, ListEntry);

        if(EntryInfo->entryData) {
            FreeADsStr(EntryInfo->entryData);
            EntryInfo->entryData = NULL;
        }

        delete EntryInfo;
    }

    RRETURN(S_OK);
}