2819 lines
67 KiB
C++
2819 lines
67 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// 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);
|
|
}
|
|
|
|
|
|
|
|
|
|
|