807 lines
18 KiB
C++
807 lines
18 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1998 - 1999
|
|
//
|
|
// File: attribute.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
|
|
#include "common.h"
|
|
#include "attr.h"
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// CADSIAttribute
|
|
|
|
CADSIAttribute::CADSIAttribute(ADS_ATTR_INFO* pInfo, BOOL bMulti, PCWSTR pszSyntax, BOOL bReadOnly)
|
|
{
|
|
m_pAttrInfo = pInfo;
|
|
m_bDirty = FALSE;
|
|
m_bMulti = bMulti;
|
|
m_bReadOnly = bReadOnly;
|
|
m_bSet = FALSE;
|
|
m_bMandatory = FALSE;
|
|
m_szSyntax = pszSyntax;
|
|
|
|
PWSTR pwz = wcsrchr(pInfo->pszAttrName, L';');
|
|
if (pwz)
|
|
{
|
|
pwz; // move past the hyphen to the range end value.
|
|
ASSERT(*pwz);
|
|
*pwz=L'\0';
|
|
}
|
|
|
|
}
|
|
|
|
CADSIAttribute::CADSIAttribute(PADS_ATTR_INFO pInfo)
|
|
{
|
|
//
|
|
// REVIEW_JEFFJON : these need to be updated with correct values
|
|
//
|
|
m_pAttrInfo = pInfo;
|
|
m_bDirty = FALSE;
|
|
m_bMulti = FALSE;
|
|
m_bReadOnly = FALSE;
|
|
m_bSet = FALSE;
|
|
m_bMandatory = FALSE;
|
|
|
|
PWSTR pwz = wcsrchr(pInfo->pszAttrName, L';');
|
|
if (pwz)
|
|
{
|
|
pwz; // move past the hyphen to the range end value.
|
|
ASSERT(*pwz);
|
|
*pwz=L'\0';
|
|
}
|
|
|
|
}
|
|
|
|
CADSIAttribute::CADSIAttribute(LPCWSTR lpszAttr)
|
|
{
|
|
m_pAttrInfo = new ADS_ATTR_INFO;
|
|
memset(m_pAttrInfo, 0, sizeof(ADS_ATTR_INFO));
|
|
|
|
PWSTR pwz = wcsrchr(lpszAttr, L';');
|
|
if (pwz)
|
|
{
|
|
pwz; // move past the hyphen to the range end value.
|
|
ASSERT(*pwz);
|
|
*pwz=L'\0';
|
|
}
|
|
_AllocString(lpszAttr, &(m_pAttrInfo->pszAttrName));
|
|
|
|
m_bMulti = FALSE;
|
|
m_bDirty = FALSE;
|
|
m_bReadOnly = FALSE;
|
|
m_bSet = FALSE;
|
|
m_bMandatory = FALSE;
|
|
}
|
|
|
|
CADSIAttribute::CADSIAttribute(CADSIAttribute* pOldAttr)
|
|
{
|
|
m_pAttrInfo = NULL;
|
|
ADS_ATTR_INFO* pAttrInfo = pOldAttr->GetAttrInfo();
|
|
|
|
// These copies are done separately because there are places
|
|
// that I need to copy only the ADsAttrInfo and not the values
|
|
//
|
|
_CopyADsAttrInfo(pAttrInfo, &m_pAttrInfo);
|
|
_CopyADsValues(pAttrInfo, m_pAttrInfo );
|
|
|
|
m_bReadOnly = FALSE;
|
|
m_bMulti = pOldAttr->m_bMulti;
|
|
m_bDirty = pOldAttr->m_bDirty;
|
|
m_szSyntax = pOldAttr->m_szSyntax;
|
|
}
|
|
|
|
|
|
CADSIAttribute::~CADSIAttribute()
|
|
{
|
|
if (!m_bReadOnly)
|
|
{
|
|
_FreeADsAttrInfo(&m_pAttrInfo, m_bReadOnly);
|
|
}
|
|
}
|
|
|
|
|
|
ADSVALUE* CADSIAttribute::GetADSVALUE(int idx)
|
|
{
|
|
|
|
return &(m_pAttrInfo->pADsValues[idx]);
|
|
}
|
|
|
|
HRESULT CADSIAttribute::SetValues(PADSVALUE pADsValue, DWORD dwNumValues)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ADS_ATTR_INFO* pNewAttrInfo = NULL;
|
|
if (!_CopyADsAttrInfo(m_pAttrInfo, &pNewAttrInfo))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
pNewAttrInfo->dwNumValues = dwNumValues;
|
|
pNewAttrInfo->pADsValues = pADsValue;
|
|
|
|
if (pADsValue == NULL)
|
|
{
|
|
pNewAttrInfo->dwControlCode = ADS_ATTR_CLEAR;
|
|
}
|
|
else
|
|
{
|
|
pNewAttrInfo->dwADsType = pADsValue->dwType;
|
|
}
|
|
|
|
//
|
|
// Free the old one and swap in the new one
|
|
//
|
|
if (!m_bReadOnly)
|
|
{
|
|
_FreeADsAttrInfo(&m_pAttrInfo, m_bReadOnly);
|
|
}
|
|
|
|
m_pAttrInfo = pNewAttrInfo;
|
|
m_bReadOnly = FALSE;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CADSIAttribute::SetValues(const CStringList& sValues)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ADS_ATTR_INFO* pNewAttrInfo = NULL;
|
|
if (!_CopyADsAttrInfo(m_pAttrInfo, &pNewAttrInfo))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
int iCount = sValues.GetCount();
|
|
pNewAttrInfo->dwNumValues = iCount;
|
|
|
|
if (!_AllocValues(&pNewAttrInfo->pADsValues, iCount))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
int idx = 0;
|
|
POSITION pos = sValues.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CString s = sValues.GetNext(pos);
|
|
|
|
ADSVALUE* pADsValue = &(pNewAttrInfo->pADsValues[idx]);
|
|
ASSERT(pADsValue != NULL);
|
|
|
|
hr = _SetADsFromString(
|
|
s,
|
|
pNewAttrInfo->dwADsType,
|
|
pADsValue
|
|
);
|
|
if (FAILED(hr))
|
|
{
|
|
_FreeADsAttrInfo(&pNewAttrInfo, FALSE);
|
|
return hr;
|
|
}
|
|
idx++;
|
|
}
|
|
|
|
// Free the old one and swap in the new one
|
|
//
|
|
_FreeADsAttrInfo(&m_pAttrInfo, m_bReadOnly);
|
|
|
|
m_pAttrInfo = pNewAttrInfo;
|
|
m_bReadOnly = FALSE;
|
|
return hr;
|
|
}
|
|
|
|
void CADSIAttribute::GetValues(CStringList& sValues, DWORD dwMaxCharCount)
|
|
{
|
|
GetStringFromADs(m_pAttrInfo, sValues, dwMaxCharCount);
|
|
}
|
|
|
|
ADS_ATTR_INFO* CADSIAttribute::GetAttrInfo()
|
|
{
|
|
return m_pAttrInfo;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Public Helper Functions
|
|
///////////////////////////////////////////////////////////////////////
|
|
HRESULT CADSIAttribute::SetValuesInDS(CAttrList2* ptouchedAttr, IDirectoryObject* pDirObject)
|
|
{
|
|
DWORD dwReturn;
|
|
DWORD dwAttrCount = 0;
|
|
ADS_ATTR_INFO* pAttrInfo;
|
|
pAttrInfo = new ADS_ATTR_INFO[ptouchedAttr->GetCount()];
|
|
|
|
CADSIAttribute* pCurrentAttr;
|
|
POSITION pos = ptouchedAttr->GetHeadPosition();
|
|
while(pos != NULL)
|
|
{
|
|
ptouchedAttr->GetNextDirty(pos, &pCurrentAttr);
|
|
|
|
if (pCurrentAttr != NULL)
|
|
{
|
|
ADS_ATTR_INFO* pCurrentAttrInfo = pCurrentAttr->GetAttrInfo();
|
|
ADS_ATTR_INFO* pNewAttrInfo = &pAttrInfo[dwAttrCount];
|
|
|
|
if (!_CopyADsAttrInfo(pCurrentAttrInfo, pNewAttrInfo))
|
|
{
|
|
for (DWORD itr = 0; itr < dwAttrCount; itr++)
|
|
{
|
|
_FreeADsAttrInfo(&pAttrInfo[itr]);
|
|
}
|
|
delete[] pAttrInfo;
|
|
pAttrInfo = NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (!_CopyADsValues(pCurrentAttrInfo, pNewAttrInfo))
|
|
{
|
|
delete[] pAttrInfo;
|
|
pAttrInfo = NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (pAttrInfo[dwAttrCount].dwNumValues == 0)
|
|
{
|
|
pAttrInfo[dwAttrCount].dwControlCode = ADS_ATTR_CLEAR;
|
|
}
|
|
else
|
|
{
|
|
pAttrInfo[dwAttrCount].dwControlCode = ADS_ATTR_UPDATE;
|
|
}
|
|
|
|
dwAttrCount++;
|
|
}
|
|
}
|
|
|
|
// Commit the changes that have been made to the ADSI cache
|
|
//
|
|
HRESULT hr = pDirObject->SetObjectAttributes(pAttrInfo, dwAttrCount, &dwReturn);
|
|
|
|
for (DWORD itr = 0; itr < dwAttrCount; itr++)
|
|
{
|
|
_FreeADsAttrInfo(&pAttrInfo[itr]);
|
|
}
|
|
delete[] pAttrInfo;
|
|
pAttrInfo = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// Private Helper Functions
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CADSIAttribute::_SetADsFromString(LPCWSTR lpszValue, ADSTYPE adsType, ADSVALUE* pADsValue)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if ( adsType == ADSTYPE_INVALID )
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
pADsValue->dwType = adsType;
|
|
|
|
switch( adsType )
|
|
{
|
|
case ADSTYPE_DN_STRING :
|
|
if (!_AllocString(lpszValue, &pADsValue->DNString))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_CASE_EXACT_STRING :
|
|
if (!_AllocString(lpszValue, &pADsValue->CaseExactString))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_CASE_IGNORE_STRING :
|
|
if (!_AllocString(lpszValue, &pADsValue->CaseIgnoreString))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_PRINTABLE_STRING :
|
|
if (!_AllocString(lpszValue, &pADsValue->PrintableString))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_NUMERIC_STRING :
|
|
if (!_AllocString(lpszValue, &pADsValue->NumericString))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_OBJECT_CLASS :
|
|
if (!_AllocString(lpszValue, &pADsValue->ClassName))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_BOOLEAN :
|
|
if (_wcsnicmp(lpszValue, L"TRUE", 4) == 0)
|
|
{
|
|
(DWORD)pADsValue->Boolean = TRUE;
|
|
}
|
|
else if (_wcsnicmp(lpszValue, L"FALSE", 5) == 0)
|
|
{
|
|
(DWORD)pADsValue->Boolean = FALSE;
|
|
}
|
|
else
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_INTEGER :
|
|
int value;
|
|
value = swscanf(lpszValue, L"%ld", &pADsValue->Integer);
|
|
if (value > 0)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_OCTET_STRING :
|
|
{
|
|
pADsValue->OctetString.lpValue = new BYTE[256];
|
|
int iCount = 0, index = 0, iResult = 0;
|
|
|
|
do
|
|
{
|
|
while (lpszValue[index] == ' ' || lpszValue[index] == '/t')
|
|
{
|
|
index++;
|
|
}
|
|
iResult = swscanf(&lpszValue[index], L"0x%2x", &pADsValue->OctetString.lpValue[iCount++]);
|
|
if (iResult == 0 && lpszValue[index] == '\0')
|
|
{
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
index += 4; // REVIEW : OctetStrings must be in the form 0x00, ie 4 characters
|
|
|
|
} while (iResult != 0);
|
|
|
|
iCount--; // the last one had to fail
|
|
pADsValue->OctetString.dwLength = iCount;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_LARGE_INTEGER :
|
|
wtoli(lpszValue, pADsValue->LargeInteger);
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADSTYPE_UTC_TIME :
|
|
int iNum;
|
|
WORD n;
|
|
iNum = swscanf(lpszValue, L"%02d/%02d/%04d %02d:%02d:%02d",
|
|
&n,
|
|
&pADsValue->UTCTime.wDay,
|
|
&pADsValue->UTCTime.wYear,
|
|
&pADsValue->UTCTime.wHour,
|
|
&pADsValue->UTCTime.wMinute,
|
|
&pADsValue->UTCTime.wSecond
|
|
);
|
|
pADsValue->UTCTime.wMonth = n;
|
|
|
|
// This strange conversion is done so that the DayOfWeek will be set in
|
|
// the UTCTime. By converting it to a filetime it ignores the dayofweek but
|
|
// converting back fills it in.
|
|
//
|
|
FILETIME ft;
|
|
SystemTimeToFileTime(&pADsValue->UTCTime, &ft);
|
|
FileTimeToSystemTime(&ft, &pADsValue->UTCTime);
|
|
|
|
if (iNum == 6)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL CADSIAttribute::_AllocOctetString(ADS_OCTET_STRING& rOldOctetString,
|
|
ADS_OCTET_STRING& rNew)
|
|
{
|
|
_FreeOctetString(rNew.lpValue);
|
|
|
|
int iLength = rOldOctetString.dwLength;
|
|
rNew.dwLength = iLength;
|
|
rNew.lpValue = new BYTE[iLength];
|
|
if (rNew.lpValue == NULL)
|
|
{
|
|
_FreeOctetString(rNew.lpValue);
|
|
return FALSE;
|
|
}
|
|
memcpy(rNew.lpValue, rOldOctetString.lpValue, iLength);
|
|
return TRUE;
|
|
}
|
|
|
|
void CADSIAttribute::_FreeOctetString(BYTE* lpValue)
|
|
{
|
|
if (lpValue != NULL)
|
|
{
|
|
delete lpValue;
|
|
lpValue = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL CADSIAttribute::_AllocString(LPCWSTR lpsz, LPWSTR* lppszNew)
|
|
{
|
|
_FreeString(lppszNew);
|
|
|
|
int iLength = wcslen(lpsz);
|
|
*lppszNew = new WCHAR[iLength + 1]; // an extra for the NULL
|
|
if (*lppszNew == NULL)
|
|
{
|
|
_FreeString(lppszNew);
|
|
return FALSE;
|
|
}
|
|
wcscpy(*lppszNew, lpsz);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CADSIAttribute::_FreeString(LPWSTR* lppsz)
|
|
{
|
|
if (*lppsz != NULL)
|
|
{
|
|
delete *lppsz;
|
|
}
|
|
*lppsz = NULL;
|
|
}
|
|
|
|
BOOL CADSIAttribute::_AllocValues(ADSVALUE** ppValues, DWORD dwLength)
|
|
{
|
|
_FreeADsValues(ppValues, dwLength);
|
|
|
|
*ppValues = new ADSVALUE[dwLength];
|
|
if (*ppValues == NULL)
|
|
{
|
|
_FreeADsValues(ppValues, dwLength);
|
|
return FALSE;
|
|
}
|
|
memset(*ppValues, 0, sizeof(ADSVALUE) * dwLength);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CADSIAttribute::_CopyADsValues(ADS_ATTR_INFO* pOldAttrInfo, ADS_ATTR_INFO* pNewAttrInfo)
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
|
|
pNewAttrInfo->dwNumValues = pOldAttrInfo->dwNumValues;
|
|
if (!_AllocValues(&pNewAttrInfo->pADsValues, pOldAttrInfo->dwNumValues))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
|
|
for (DWORD itr = 0; itr < pOldAttrInfo->dwNumValues; itr++)
|
|
{
|
|
pNewAttrInfo->pADsValues[itr].dwType = pOldAttrInfo->pADsValues[itr].dwType;
|
|
|
|
switch( pNewAttrInfo->pADsValues[itr].dwType )
|
|
{
|
|
case ADSTYPE_DN_STRING :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].DNString,
|
|
&pNewAttrInfo->pADsValues[itr].DNString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_CASE_EXACT_STRING :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].CaseExactString,
|
|
&pNewAttrInfo->pADsValues[itr].CaseExactString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_CASE_IGNORE_STRING :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].CaseIgnoreString,
|
|
&pNewAttrInfo->pADsValues[itr].CaseIgnoreString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_PRINTABLE_STRING :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].PrintableString,
|
|
&pNewAttrInfo->pADsValues[itr].PrintableString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_NUMERIC_STRING :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].NumericString,
|
|
&pNewAttrInfo->pADsValues[itr].NumericString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_OBJECT_CLASS :
|
|
if (!_AllocString(pOldAttrInfo->pADsValues[itr].ClassName,
|
|
&pNewAttrInfo->pADsValues[itr].ClassName))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_BOOLEAN :
|
|
pNewAttrInfo->pADsValues[itr].Boolean = pOldAttrInfo->pADsValues[itr].Boolean;
|
|
break;
|
|
|
|
case ADSTYPE_INTEGER :
|
|
pNewAttrInfo->pADsValues[itr].Integer = pOldAttrInfo->pADsValues[itr].Integer;
|
|
break;
|
|
|
|
case ADSTYPE_OCTET_STRING :
|
|
if (!_AllocOctetString(pOldAttrInfo->pADsValues[itr].OctetString,
|
|
pNewAttrInfo->pADsValues[itr].OctetString))
|
|
{
|
|
_FreeADsValues(&pNewAttrInfo->pADsValues, pNewAttrInfo->dwNumValues);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case ADSTYPE_LARGE_INTEGER :
|
|
pNewAttrInfo->pADsValues[itr].LargeInteger = pOldAttrInfo->pADsValues[itr].LargeInteger;
|
|
break;
|
|
|
|
case ADSTYPE_UTC_TIME :
|
|
pNewAttrInfo->pADsValues[itr].UTCTime = pOldAttrInfo->pADsValues[itr].UTCTime;
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void CADSIAttribute::_FreeADsValues(ADSVALUE** ppADsValues, DWORD dwLength)
|
|
{
|
|
ADSVALUE* pADsValue = *ppADsValues;
|
|
|
|
for (DWORD idx = 0; idx < dwLength; idx++)
|
|
{
|
|
if (pADsValue != NULL)
|
|
{
|
|
switch( pADsValue->dwType )
|
|
{
|
|
case ADSTYPE_DN_STRING :
|
|
_FreeString(&pADsValue->DNString);
|
|
break;
|
|
|
|
case ADSTYPE_CASE_EXACT_STRING :
|
|
_FreeString(&pADsValue->CaseExactString);
|
|
break;
|
|
|
|
case ADSTYPE_CASE_IGNORE_STRING :
|
|
_FreeString(&pADsValue->CaseIgnoreString);
|
|
break;
|
|
|
|
case ADSTYPE_PRINTABLE_STRING :
|
|
_FreeString(&pADsValue->PrintableString);
|
|
break;
|
|
|
|
case ADSTYPE_NUMERIC_STRING :
|
|
_FreeString(&pADsValue->NumericString);
|
|
break;
|
|
|
|
case ADSTYPE_OBJECT_CLASS :
|
|
_FreeString(&pADsValue->ClassName);
|
|
break;
|
|
|
|
case ADSTYPE_OCTET_STRING :
|
|
_FreeOctetString(pADsValue->OctetString.lpValue);
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
pADsValue++;
|
|
}
|
|
}
|
|
// May be NULL if there are no values set
|
|
// WARNING! : make sure that you memset the memory after
|
|
// creating an ADS_ATTR_INFO so that it will be NULL if there
|
|
// are no values
|
|
//
|
|
if (*ppADsValues != NULL)
|
|
{
|
|
delete *ppADsValues;
|
|
*ppADsValues = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
// The values are not copied here. They must be copied after the ADS_ATTR_INFO
|
|
// is copied by using _CopyADsValues()
|
|
//
|
|
BOOL CADSIAttribute::_CopyADsAttrInfo(ADS_ATTR_INFO* pAttrInfo, ADS_ATTR_INFO** ppNewAttrInfo)
|
|
{
|
|
_FreeADsAttrInfo(ppNewAttrInfo, FALSE);
|
|
|
|
*ppNewAttrInfo = new ADS_ATTR_INFO;
|
|
if (*ppNewAttrInfo == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
memset(*ppNewAttrInfo, 0, sizeof(ADS_ATTR_INFO));
|
|
|
|
BOOL bReturn = _AllocString(pAttrInfo->pszAttrName, &((*ppNewAttrInfo)->pszAttrName));
|
|
if (!bReturn)
|
|
{
|
|
_FreeADsAttrInfo(ppNewAttrInfo, FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
(*ppNewAttrInfo)->dwADsType = pAttrInfo->dwADsType;
|
|
(*ppNewAttrInfo)->dwControlCode = pAttrInfo->dwControlCode;
|
|
(*ppNewAttrInfo)->dwNumValues = pAttrInfo->dwNumValues;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CADSIAttribute::_CopyADsAttrInfo(ADS_ATTR_INFO* pAttrInfo, ADS_ATTR_INFO* pNewAttrInfo)
|
|
{
|
|
memset(pNewAttrInfo, 0, sizeof(ADS_ATTR_INFO));
|
|
|
|
BOOL bReturn = _AllocString(pAttrInfo->pszAttrName, &pNewAttrInfo->pszAttrName);
|
|
if (!bReturn)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
pNewAttrInfo->dwADsType = pAttrInfo->dwADsType;
|
|
pNewAttrInfo->dwControlCode = pAttrInfo->dwControlCode;
|
|
pNewAttrInfo->dwNumValues = pAttrInfo->dwNumValues;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CADSIAttribute::_FreeADsAttrInfo(ADS_ATTR_INFO** ppAttrInfo, BOOL bReadOnly)
|
|
{
|
|
if (*ppAttrInfo == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!bReadOnly)
|
|
{
|
|
_FreeString(&(*ppAttrInfo)->pszAttrName);
|
|
_FreeADsValues(&(*ppAttrInfo)->pADsValues, (*ppAttrInfo)->dwNumValues);
|
|
delete *ppAttrInfo;
|
|
}
|
|
else
|
|
{
|
|
FreeADsMem(*ppAttrInfo);
|
|
}
|
|
*ppAttrInfo = NULL;
|
|
}
|
|
|
|
void CADSIAttribute::_FreeADsAttrInfo(ADS_ATTR_INFO* pAttrInfo)
|
|
{
|
|
if (pAttrInfo == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_FreeString(&pAttrInfo->pszAttrName);
|
|
_FreeADsValues(&pAttrInfo->pADsValues, pAttrInfo->dwNumValues);
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// CAttrList2
|
|
|
|
POSITION CAttrList2::FindProperty(LPCWSTR lpszAttr)
|
|
{
|
|
CADSIAttribute* pAttr;
|
|
|
|
for (POSITION p = GetHeadPosition(); p != NULL; GetNext(p))
|
|
{
|
|
// I use GetAt here because I don't want to advance the POSITION
|
|
// because it is returned if they are equal
|
|
//
|
|
pAttr = GetAt(p);
|
|
CString sName;
|
|
pAttr->GetProperty(sName);
|
|
if (wcscmp(sName, lpszAttr) == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
|
|
BOOL CAttrList2::HasProperty(LPCWSTR lpszAttr)
|
|
{
|
|
POSITION pos = FindProperty(lpszAttr);
|
|
return pos != NULL;
|
|
}
|
|
|
|
|
|
// Searches through the cache for the attribute
|
|
// ppAttr will point to the CADSIAttribute if found, NULL if not
|
|
//
|
|
void CAttrList2::GetNextDirty(POSITION& pos, CADSIAttribute** ppAttr)
|
|
{
|
|
*ppAttr = GetNext(pos);
|
|
if (pos == NULL && !(*ppAttr)->IsDirty())
|
|
{
|
|
*ppAttr = NULL;
|
|
return;
|
|
}
|
|
|
|
while (!(*ppAttr)->IsDirty() && pos != NULL)
|
|
{
|
|
*ppAttr = GetNext(pos);
|
|
if (!(*ppAttr)->IsDirty() && pos == NULL)
|
|
{
|
|
*ppAttr = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CAttrList2::HasDirty()
|
|
{
|
|
POSITION pos = GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CADSIAttribute* pAttr = GetNext(pos);
|
|
if (pAttr->IsDirty())
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
} |