773 lines
18 KiB
C++
773 lines
18 KiB
C++
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996
|
|
//
|
|
// File: cgenobj.cxx
|
|
//
|
|
// Contents: Microsoft ADs LDAP Provider Generic Object
|
|
//
|
|
//
|
|
// History: 08-30-96 yihsins Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include "ldap.hxx"
|
|
#pragma hdrstop
|
|
|
|
HRESULT
|
|
CLDAPGenObject::get_PropertyCount(
|
|
THIS_ long FAR *plCount
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
BSTR bstrProperty = NULL;
|
|
SAFEARRAY *psaProperty = NULL;
|
|
SAFEARRAYBOUND rgsabound[1];
|
|
long lsaDim[1];
|
|
VARIANT varProperty;
|
|
|
|
|
|
// ??? _pPropertyCache canNOT be NULL or bailed out during
|
|
// CLDAPGenObject creation already
|
|
// assert(_PropertyCache);
|
|
|
|
if (_pPropertyCache) {
|
|
hr = _pPropertyCache->get_PropertyCount((PDWORD)plCount);
|
|
}
|
|
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// - Return the "next" item (item with the current index) in cache, if any,
|
|
// in a property entry [*pVariant].
|
|
// - Return E_ADS_PROPERTY_NOT_FOUND when current index is out of bound.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::Next(
|
|
THIS_ VARIANT FAR *pVariant
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DWORD dwSyntaxId = 0;
|
|
DWORD dwNumValues = 0;
|
|
LDAPOBJECTARRAY ldapSrcObjects;
|
|
IDispatch * pDispatch = NULL;
|
|
DWORD dwNumAdsValues = 0;
|
|
DWORD dwAdsType = 0;
|
|
DWORD dwPropStatus = 0;
|
|
DWORD dwCtrlCode = 0;
|
|
|
|
if(!_pPropertyCache->index_valid())
|
|
RRETURN_EXP_IF_ERR(E_FAIL);
|
|
|
|
LDAPOBJECTARRAY_INIT(ldapSrcObjects);
|
|
|
|
hr = _pPropertyCache->unboundgetproperty(
|
|
_pPropertyCache->get_CurrentIndex(),
|
|
&dwSyntaxId,
|
|
&dwPropStatus,
|
|
&ldapSrcObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
dwCtrlCode = MapPropCacheFlagToControlCode(dwPropStatus);
|
|
|
|
//
|
|
// translate the LDAP objects to variants
|
|
//
|
|
|
|
hr = ConvertLdapValuesToVariant(
|
|
_pPropertyCache->get_CurrentPropName(),
|
|
&ldapSrcObjects,
|
|
dwSyntaxId,
|
|
dwCtrlCode,
|
|
pVariant,
|
|
_pszLDAPServer,
|
|
&_Credentials
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
error:
|
|
|
|
//
|
|
// - goto next one even if error to avoid infinite looping at a property
|
|
// which we cannot convert (e.g. schemaless server property.)
|
|
// - do not return the result of Skip() as current operation does not
|
|
// depend on the sucess of Skip().
|
|
//
|
|
|
|
Skip(1);
|
|
|
|
LdapTypeFreeLdapObjects(&ldapSrcObjects);
|
|
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::Skip(
|
|
THIS_ long cElements
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = _pPropertyCache->skip_propindex(
|
|
cElements
|
|
);
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::Reset(
|
|
|
|
)
|
|
{
|
|
_pPropertyCache->reset_propindex();
|
|
|
|
RRETURN_EXP_IF_ERR(S_OK);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::ResetPropertyItem(THIS_ VARIANT varEntry)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwIndex = 0;
|
|
|
|
switch (V_VT(&varEntry)) {
|
|
|
|
case VT_BSTR:
|
|
|
|
hr = _pPropertyCache->findproperty(
|
|
V_BSTR(&varEntry),
|
|
&dwIndex
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
break;
|
|
|
|
case VT_I4:
|
|
dwIndex = V_I4(&varEntry);
|
|
break;
|
|
|
|
|
|
case VT_I2:
|
|
dwIndex = V_I2(&varEntry);
|
|
break;
|
|
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
hr = _pPropertyCache->deleteproperty(
|
|
dwIndex
|
|
);
|
|
error:
|
|
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Retrieve property [bstrName] from the cache (only, no wire calls) as
|
|
// a PropertyEntry.
|
|
//
|
|
// [*pVariant]
|
|
// - store ptr to IDispatch of the PropertyEntry.
|
|
//
|
|
// If the property in cache has control code = ADS_PROPERTY_DELETE,
|
|
// - PropertyEntry will contain an empty variant and
|
|
// - adstype = ADSTYPE_INVALID.
|
|
//
|
|
// If property in cache has UNKNWON type, (not deleted, for schemaless-server
|
|
// property which is not in ADSI default schema)
|
|
// - [lnAdsType] must be a valid type (NO ADSTYPE_UNKNWON/INVALID)
|
|
// - property will be retrieved as [lnADsType]
|
|
//
|
|
// If property in cache has KNOWN type,
|
|
// - [lnADsType] must either match type in cache or == ADSTYPE_UNKNOWN
|
|
// - property will be retreived as the type in cache.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::GetPropertyItem(
|
|
THIS_
|
|
IN BSTR bstrName,
|
|
IN LONG lnADsType,
|
|
IN OUT VARIANT * pVariant
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwCachedSyntax = LDAPTYPE_UNKNOWN;
|
|
DWORD dwUserSyntax = LDAPTYPE_UNKNOWN;
|
|
DWORD dwSyntaxUsed = LDAPTYPE_UNKNOWN; // extra, make code easier to read
|
|
DWORD dwPropStatus = 0;
|
|
DWORD dwCtrlCode = 0;
|
|
LDAPOBJECTARRAY ldapSrcObjects;
|
|
LDAPOBJECTARRAY ldapSrc2Objects;
|
|
LDAPOBJECTARRAY * pLdapSrcObjects = NULL;
|
|
|
|
LDAPOBJECTARRAY_INIT(ldapSrcObjects);
|
|
LDAPOBJECTARRAY_INIT(ldapSrc2Objects);
|
|
|
|
|
|
if (!bstrName || !pVariant)
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
|
|
//
|
|
// retrieve property from cache; CONTINUE if property exist but
|
|
// has no value (control code flag as a DELETE)
|
|
//
|
|
|
|
hr = _pPropertyCache->unboundgetproperty(
|
|
bstrName,
|
|
&dwCachedSyntax,
|
|
&dwPropStatus,
|
|
&ldapSrcObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// For backward compatibility -- no issue as you
|
|
// need to return a value even if it is delete.
|
|
|
|
|
|
//
|
|
// map adstype from client to ldap type;
|
|
//
|
|
|
|
dwUserSyntax = MapADSTypeToLDAPType((ADSTYPE)lnADsType);
|
|
|
|
|
|
//
|
|
// determine the syntax to retrieve property in
|
|
//
|
|
|
|
if ( (dwCachedSyntax == LDAPTYPE_UNKNOWN)
|
|
||
|
|
(dwCachedSyntax == 0) // should NOT be 0, but misuse of 0 everywhere
|
|
) // and in case i didn't clean up all
|
|
{
|
|
//
|
|
// syntax not stored in cache, user must spcify a valid sytax
|
|
// Exception: cleared property values have LDAPTYPE_UNKNOWN, and we
|
|
// return them as ADSTYPE_UNKNOWN
|
|
//
|
|
|
|
if ((dwUserSyntax == LDAPTYPE_UNKNOWN) && (dwPropStatus != PROPERTY_DELETE))
|
|
{
|
|
hr = E_ADS_CANT_CONVERT_DATATYPE;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
dwSyntaxUsed = dwUserSyntax;
|
|
|
|
//
|
|
// convert from cached data from ldap binary format to ldap string
|
|
// IFF necessary based on dwUserSyntax
|
|
//
|
|
|
|
hr = LdapTypeBinaryToString(
|
|
dwSyntaxUsed,
|
|
&ldapSrcObjects,
|
|
&ldapSrc2Objects
|
|
);
|
|
|
|
//
|
|
// dwSyntaxUsed (dwUserSyntax) must be valid from
|
|
// MapADSTypeToLDAPType() or code bug in MapADsTypeToLDAPType() !!
|
|
//
|
|
|
|
ADsAssert(SUCCEEDED(hr));
|
|
|
|
if (hr==S_OK)
|
|
{
|
|
pLdapSrcObjects = &ldapSrc2Objects; // conversion done
|
|
}
|
|
else // hr == S_FALSE
|
|
{
|
|
pLdapSrcObjects = &ldapSrcObjects; // no conversion
|
|
}
|
|
}
|
|
|
|
else // dwCachedSyntax known and valid
|
|
{
|
|
//
|
|
// syntax stored in cache, user MUST either specify
|
|
// 1) ADSTYPE_UNKNWON or
|
|
// 2) a syntax which matches the one in cache. The comparision must
|
|
// be done in ADsType, not LdapType, since LdapType To ADSType
|
|
// is n to 1 mapping and as long as ADsType match, ok.
|
|
//
|
|
|
|
if ( ! (
|
|
(dwUserSyntax == LDAPTYPE_UNKNOWN)
|
|
||
|
|
( (ADSTYPE) lnADsType == MapLDAPTypeToADSType(dwCachedSyntax))
|
|
)
|
|
)
|
|
{
|
|
|
|
if (dwUserSyntax != dwCachedSyntax) {
|
|
|
|
//
|
|
// Check if the user wants the data back for the
|
|
// security descriptor as an octet or vice versa
|
|
//
|
|
if ( (dwUserSyntax == LDAPTYPE_OCTETSTRING
|
|
&& dwCachedSyntax == LDAPTYPE_SECURITY_DESCRIPTOR)
|
|
||(dwUserSyntax == LDAPTYPE_SECURITY_DESCRIPTOR
|
|
&& dwCachedSyntax == LDAPTYPE_OCTETSTRING))
|
|
{
|
|
dwCachedSyntax = dwUserSyntax;
|
|
|
|
} else {
|
|
//
|
|
// Check for UTC/GenTime mismatch before ret error.
|
|
//
|
|
if (!((dwCachedSyntax == LDAPTYPE_GENERALIZEDTIME)
|
|
&& (dwUserSyntax == LDAPTYPE_UTCTIME))) {
|
|
|
|
hr = E_ADS_CANT_CONVERT_DATATYPE;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
} // if dwUserSyntax != dwCachedSyntax
|
|
}
|
|
|
|
dwSyntaxUsed = dwCachedSyntax;
|
|
|
|
pLdapSrcObjects = &ldapSrcObjects; // no conversion needed
|
|
}
|
|
|
|
|
|
//
|
|
// translate ldap prop status to ads control code
|
|
//
|
|
|
|
dwCtrlCode = MapPropCacheFlagToControlCode(dwPropStatus);
|
|
|
|
|
|
//
|
|
// translate the property from Ldap objects to a PropertyEntry
|
|
//
|
|
|
|
hr = ConvertLdapValuesToVariant(
|
|
bstrName,
|
|
pLdapSrcObjects,
|
|
dwSyntaxUsed,
|
|
dwCtrlCode,
|
|
pVariant,
|
|
_pszLDAPServer,
|
|
&_Credentials
|
|
);
|
|
|
|
error:
|
|
|
|
LdapTypeFreeLdapObjects( &ldapSrcObjects );
|
|
LdapTypeFreeLdapObjects( &ldapSrc2Objects );
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::PutPropertyItem(
|
|
THIS_ VARIANT varData
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwFlags = 0;
|
|
|
|
DWORD dwIndex = 0;
|
|
DWORD dwControlCode = 0;
|
|
LDAPOBJECTARRAY ldapDestObjects;
|
|
WCHAR szPropertyName[MAX_PATH];
|
|
DWORD dwSyntaxId = 0;
|
|
|
|
LDAPOBJECTARRAY_INIT(ldapDestObjects);
|
|
|
|
hr = ConvertVariantToLdapValues(
|
|
varData,
|
|
szPropertyName,
|
|
&dwControlCode,
|
|
&ldapDestObjects,
|
|
&dwSyntaxId,
|
|
_pszLDAPServer,
|
|
&_Credentials,
|
|
_dwPort
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
switch ( dwControlCode ) {
|
|
|
|
case 0 :
|
|
//
|
|
// Users better know what they are doing here,
|
|
// This the property as cleared so we do not send it
|
|
// on the wire on th next SetInfo.
|
|
//
|
|
dwFlags = PROPERTY_INIT;
|
|
break;
|
|
|
|
case ADS_PROPERTY_CLEAR:
|
|
|
|
//
|
|
// Clears an entire property
|
|
//
|
|
|
|
dwFlags = PROPERTY_DELETE;
|
|
break;
|
|
|
|
case ADS_PROPERTY_UPDATE:
|
|
|
|
//
|
|
// Updates the entire property
|
|
//
|
|
|
|
dwFlags = PROPERTY_UPDATE;
|
|
break;
|
|
|
|
case ADS_PROPERTY_APPEND:
|
|
//
|
|
// Appends a set of values to the property
|
|
//
|
|
|
|
dwFlags = PROPERTY_ADD;
|
|
break;
|
|
|
|
case ADS_PROPERTY_DELETE:
|
|
//
|
|
// Delete a value(s) from the property
|
|
|
|
dwFlags = PROPERTY_DELETE_VALUE;
|
|
break;
|
|
|
|
|
|
default:
|
|
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Find this property in the cache
|
|
//
|
|
|
|
hr = _pPropertyCache->findproperty(
|
|
szPropertyName,
|
|
&dwIndex
|
|
);
|
|
|
|
//
|
|
// If this property does not exist in the
|
|
// cache, add this property into the cache.
|
|
//
|
|
|
|
|
|
if (FAILED(hr)) {
|
|
|
|
hr = _pPropertyCache->addproperty( szPropertyName );
|
|
|
|
//
|
|
// If dwNumValues == 0 ( delete the property ) but couldn't find
|
|
// the property, or if the add operation fails, return the error.
|
|
//
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
//
|
|
// Now update the property in the cache
|
|
//
|
|
|
|
hr = _pPropertyCache->putproperty(
|
|
szPropertyName,
|
|
dwFlags,
|
|
dwSyntaxId,
|
|
ldapDestObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
error:
|
|
|
|
LdapTypeFreeLdapObjects( &ldapDestObjects );
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CreatePropEntry(
|
|
LPWSTR szPropName,
|
|
DWORD ADsType,
|
|
DWORD numValues,
|
|
DWORD dwOperation,
|
|
VARIANT varData,
|
|
REFIID riid,
|
|
LPVOID * ppDispatch
|
|
)
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IADsPropertyEntry * pPropEntry = NULL;
|
|
|
|
hr = CoCreateInstance(
|
|
CLSID_PropertyEntry,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IADsPropertyEntry,
|
|
(void **)&pPropEntry
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
hr = pPropEntry->put_Name(szPropName);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPropEntry->put_ADsType(ADsType);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPropEntry->put_Values(varData);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (dwOperation) {
|
|
hr = pPropEntry->put_ControlCode((long)dwOperation);
|
|
}
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPropEntry->QueryInterface(
|
|
riid,
|
|
ppDispatch
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
error:
|
|
|
|
if (pPropEntry) {
|
|
pPropEntry->Release();
|
|
}
|
|
|
|
RRETURN(hr);
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::Item(
|
|
THIS_ VARIANT varIndex,
|
|
VARIANT * pVariant
|
|
)
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwSyntaxId;
|
|
LDAPOBJECTARRAY ldapSrcObjects;
|
|
PADSVALUE pAdsValues = NULL;
|
|
DWORD dwNumAdsValues = 0;
|
|
DWORD dwAdsType = 0;
|
|
DWORD dwNumValues = 0;
|
|
LPWSTR szPropName = NULL;
|
|
DWORD dwPropStatus = 0;
|
|
DWORD dwCtrlCode = (DWORD) -1;
|
|
VARIANT * pvVar = &varIndex;
|
|
|
|
LDAPOBJECTARRAY_INIT(ldapSrcObjects);
|
|
|
|
//
|
|
// retrieve data object from cache; if one exis
|
|
//
|
|
|
|
// If the object has been deleted (and is in the cache
|
|
// marked for deletion), we return
|
|
// the item with DELETE ctrl code in all
|
|
// the cases below. This is consistent with GetPropertyItem's
|
|
// behavior as well.
|
|
|
|
if (V_VT(pvVar) == (VT_BYREF|VT_VARIANT)) {
|
|
//
|
|
// The value is being passed in byref so we need to
|
|
// deref it for vbs stuff to work
|
|
//
|
|
pvVar = V_VARIANTREF(&varIndex);
|
|
}
|
|
|
|
switch (V_VT(pvVar)) {
|
|
|
|
case VT_BSTR:
|
|
|
|
//
|
|
// retrieve data object from cache; if one exists
|
|
//
|
|
|
|
hr = _pPropertyCache->unboundgetproperty(
|
|
V_BSTR(pvVar),
|
|
&dwSyntaxId,
|
|
&dwPropStatus,
|
|
&ldapSrcObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
dwCtrlCode = MapPropCacheFlagToControlCode(dwPropStatus);
|
|
|
|
hr = ConvertLdapValuesToVariant(
|
|
V_BSTR(pvVar),
|
|
&ldapSrcObjects,
|
|
dwSyntaxId,
|
|
dwCtrlCode,
|
|
pVariant,
|
|
_pszLDAPServer,
|
|
&_Credentials
|
|
);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
break;
|
|
|
|
case VT_I4:
|
|
|
|
hr = _pPropertyCache->unboundgetproperty(
|
|
(DWORD)V_I4(pvVar),
|
|
&dwSyntaxId,
|
|
&dwPropStatus,
|
|
&ldapSrcObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
szPropName = _pPropertyCache->get_PropName(
|
|
(DWORD)V_I4(pvVar)
|
|
);
|
|
|
|
dwCtrlCode = MapPropCacheFlagToControlCode(dwPropStatus);
|
|
|
|
hr = ConvertLdapValuesToVariant(
|
|
szPropName,
|
|
&ldapSrcObjects,
|
|
dwSyntaxId,
|
|
dwCtrlCode,
|
|
pVariant,
|
|
_pszLDAPServer,
|
|
&_Credentials
|
|
);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
break;
|
|
|
|
|
|
case VT_I2:
|
|
|
|
hr = _pPropertyCache->unboundgetproperty(
|
|
(DWORD)V_I2(pvVar),
|
|
&dwSyntaxId,
|
|
&dwPropStatus,
|
|
&ldapSrcObjects
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
szPropName = _pPropertyCache->get_PropName(
|
|
(DWORD)V_I2(pvVar)
|
|
);
|
|
|
|
dwCtrlCode = MapPropCacheFlagToControlCode(dwPropStatus);
|
|
|
|
hr = ConvertLdapValuesToVariant(
|
|
szPropName,
|
|
&ldapSrcObjects,
|
|
dwSyntaxId,
|
|
dwCtrlCode,
|
|
pVariant,
|
|
_pszLDAPServer,
|
|
&_Credentials
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
}
|
|
|
|
//
|
|
// translate the Ldap objects to variants
|
|
//
|
|
|
|
|
|
error:
|
|
LdapTypeFreeLdapObjects( &ldapSrcObjects );
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CLDAPGenObject::PurgePropertyList()
|
|
{
|
|
_pPropertyCache->flushpropertycache();
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
|
|
DWORD
|
|
MapPropCacheFlagToControlCode(
|
|
DWORD dwPropStatus
|
|
)
|
|
{
|
|
DWORD dwADsCtrlCode = (DWORD) -1;
|
|
|
|
switch (dwPropStatus) {
|
|
|
|
case PROPERTY_INIT:
|
|
//
|
|
// 0 is not defined as any of the ADS_PROPERTY_ flags
|
|
// use it to indicate that property is in init state
|
|
//
|
|
dwADsCtrlCode = 0;
|
|
break;
|
|
|
|
case PROPERTY_UPDATE:
|
|
dwADsCtrlCode = ADS_PROPERTY_UPDATE;
|
|
break;
|
|
|
|
case PROPERTY_ADD:
|
|
dwADsCtrlCode = ADS_PROPERTY_APPEND;
|
|
break;
|
|
|
|
case PROPERTY_DELETE:
|
|
dwADsCtrlCode = ADS_PROPERTY_CLEAR;
|
|
break;
|
|
|
|
case PROPERTY_DELETE_VALUE:
|
|
dwADsCtrlCode = ADS_PROPERTY_DELETE;
|
|
break;
|
|
|
|
default:
|
|
// set to speical value to indicate unknow code
|
|
dwADsCtrlCode = (DWORD) -1;
|
|
break;
|
|
}
|
|
|
|
return dwADsCtrlCode;
|
|
}
|
|
|