Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

3324 lines
75 KiB

//---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995
//
// File: cPropertyValue.cxx
//
// Contents: PropertyValue object
//
// History: 11-1-95 krishnag Created.
//
//----------------------------------------------------------------------------
#include "oleds.hxx"
#pragma hdrstop
DEFINE_IDispatch_Implementation(CPropertyValue)
CPropertyValue::CPropertyValue():
_pDispMgr(NULL),
_dwDataType(0),
_pDispatch(NULL)
{
memset(&_ADsValue, 0, sizeof(ADSVALUE));
ENLIST_TRACKING(CPropertyValue);
}
HRESULT
CPropertyValue::CreatePropertyValue(
REFIID riid,
void **ppvObj
)
{
CPropertyValue FAR * pPropertyValue = NULL;
HRESULT hr = S_OK;
hr = AllocatePropertyValueObject(&pPropertyValue);
BAIL_ON_FAILURE(hr);
hr = pPropertyValue->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pPropertyValue->Release();
RRETURN(hr);
error:
delete pPropertyValue;
RRETURN_EXP_IF_ERR(hr);
}
CPropertyValue::~CPropertyValue( )
{
ClearData();
delete _pDispMgr;
}
STDMETHODIMP
CPropertyValue::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsPropertyValue FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsPropertyValue))
{
*ppv = (IADsPropertyValue FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsPropertyValue2))
{
*ppv = (IADsPropertyValue2 FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsPropertyValue FAR *) this;
}
else if (IsEqualIID(iid, IID_ISupportErrorInfo))
{
*ppv = (ISupportErrorInfo FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsValue))
{
*ppv = (IADsValue FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CPropertyValue::AllocatePropertyValueObject(
CPropertyValue ** ppPropertyValue
)
{
CPropertyValue FAR * pPropertyValue = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pPropertyValue = new CPropertyValue();
if (pPropertyValue == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
pDispMgr = new CDispatchMgr;
if (pDispMgr == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(
pDispMgr,
LIBID_ADs,
IID_IADsPropertyValue,
(IADsPropertyValue *)pPropertyValue,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(
pDispMgr,
LIBID_ADs,
IID_IADsPropertyValue2,
(IADsPropertyValue2 *)pPropertyValue,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pPropertyValue->_pDispMgr = pDispMgr;
*ppPropertyValue = pPropertyValue;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN_EXP_IF_ERR(hr);
}
//
// ISupportErrorInfo method
//
STDMETHODIMP
CPropertyValue::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
if (IsEqualIID(riid, IID_IADsPropertyValue) ||
IsEqualIID(riid, IID_IADsPropertyValue) ||
IsEqualIID(riid, IID_IADsValue)) {
return S_OK;
} else {
return S_FALSE;
}
}
STDMETHODIMP
CPropertyValue::Clear(THIS_ )
{
ClearData();
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_ADsType(THIS_ long FAR * retval)
{
*retval = _ADsValue.dwType;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::put_ADsType(THIS_ long lnADsType)
{
_ADsValue.dwType = (ADSTYPE)lnADsType;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_DNString(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_DN_STRING) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
hr = ADsAllocString(_ADsValue.DNString, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_DNString(THIS_ BSTR bstrDNString)
{
ClearData();
_ADsValue.DNString = AllocADsStr(bstrDNString);
_ADsValue.dwType = ADSTYPE_DN_STRING;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_CaseExactString(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_CASE_EXACT_STRING) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
hr = ADsAllocString(_ADsValue.CaseExactString, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_CaseExactString(THIS_ BSTR bstrCaseExactString)
{
ClearData();
_ADsValue.DNString = AllocADsStr(bstrCaseExactString);
_ADsValue.dwType = ADSTYPE_CASE_EXACT_STRING;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_CaseIgnoreString(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_CASE_IGNORE_STRING) {
RRETURN_EXP_IF_ERR(E_ADS_CANT_CONVERT_DATATYPE);
}
hr = ADsAllocString(_ADsValue.CaseIgnoreString, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_CaseIgnoreString(THIS_ BSTR bstrCaseIgnoreString)
{
ClearData();
_ADsValue.DNString = AllocADsStr(bstrCaseIgnoreString);
_ADsValue.dwType = ADSTYPE_CASE_IGNORE_STRING;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_PrintableString(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_PRINTABLE_STRING) {
RRETURN_EXP_IF_ERR(E_ADS_CANT_CONVERT_DATATYPE);
}
hr = ADsAllocString(_ADsValue.PrintableString, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_PrintableString(THIS_ BSTR bstrPrintableString)
{
ClearData();
_ADsValue.PrintableString = AllocADsStr(bstrPrintableString);
_ADsValue.dwType = ADSTYPE_PRINTABLE_STRING;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_NumericString(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_NUMERIC_STRING) {
RRETURN_EXP_IF_ERR(E_ADS_CANT_CONVERT_DATATYPE);
}
hr = ADsAllocString(_ADsValue.NumericString, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_NumericString(THIS_ BSTR bstrNumericString)
{
ClearData();
_ADsValue.DNString = AllocADsStr(bstrNumericString);
_ADsValue.dwType = ADSTYPE_NUMERIC_STRING;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_OctetString(THIS_ VARIANT FAR *retval )
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
if (_ADsValue.dwType != ADSTYPE_OCTET_STRING) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
aBound.lLbound = 0;
aBound.cElements = _ADsValue.OctetString.dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( pArray,
_ADsValue.OctetString.lpValue,
aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(retval) = VT_ARRAY | VT_UI1;
V_ARRAY(retval) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_OctetString(THIS_ VARIANT VarOctetString)
{
LONG dwSLBound = 0;
LONG dwSUBound = 0;
CHAR HUGEP *pArray = NULL;
VARIANT * pvVar = &VarOctetString;
HRESULT hr = S_OK;
ClearData();
_ADsValue.dwType = ADSTYPE_OCTET_STRING;
if ( VarOctetString.vt == (VT_ARRAY | VT_BYREF)) {
pvVar = V_VARIANTREF(&VarOctetString);
}
if( pvVar->vt != (VT_ARRAY | VT_UI1)) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = SafeArrayGetLBound(V_ARRAY(pvVar),
1,
(long FAR *) &dwSLBound );
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(pvVar),
1,
(long FAR *) &dwSUBound );
BAIL_ON_FAILURE(hr);
_ADsValue.OctetString.lpValue = (LPBYTE)AllocADsMem(dwSUBound - dwSLBound + 1);
if ( _ADsValue.OctetString.lpValue == NULL) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.OctetString.dwLength = dwSUBound - dwSLBound + 1;
hr = SafeArrayAccessData( V_ARRAY(pvVar),
(void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( _ADsValue.OctetString.lpValue,
pArray,
dwSUBound-dwSLBound+1);
SafeArrayUnaccessData( V_ARRAY(pvVar) );
error:
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::get_Integer(THIS_ LONG FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_INTEGER) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
*retval = _ADsValue.Boolean;
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_Integer(THIS_ LONG lnInteger)
{
ClearData();
_ADsValue.Integer = lnInteger;
_ADsValue.dwType = ADSTYPE_INTEGER;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_Boolean(THIS_ LONG FAR * retval)
{
HRESULT hr = S_OK;
if (_ADsValue.dwType != ADSTYPE_BOOLEAN) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
*retval = _ADsValue.Boolean;
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_Boolean(THIS_ LONG lnBoolean)
{
ClearData();
_ADsValue.Boolean = lnBoolean;
_ADsValue.dwType = ADSTYPE_BOOLEAN;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyValue::get_SecurityDescriptor(THIS_ IDispatch FAR * FAR * ppDispatch)
{
HRESULT hr = E_ADS_CANT_CONVERT_DATATYPE;
//
// Check if we have a valid IDispatch at this point
//
if (_pDispatch) {
switch (_dwDataType) {
case VAL_IDISPATCH_SECDESC_ONLY :
case VAL_IDISPATCH_SECDESC_ALL :
hr = _pDispatch->QueryInterface(
IID_IDispatch,
(void **) ppDispatch
);
break;
default:
hr = E_ADS_CANT_CONVERT_DATATYPE;
}
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_SecurityDescriptor(THIS_ IDispatch * pSecurityDescriptor)
{
HRESULT hr = S_OK;
IADsSecurityDescriptor *pIADsSecDes;
IDispatch* pIDispatch;
ClearData();
_ADsValue.dwType = ADSTYPE_NT_SECURITY_DESCRIPTOR;
//
// This qi ensures that this is a security descriptor
//
hr = pSecurityDescriptor->QueryInterface(
IID_IADsSecurityDescriptor,
(void **) &pIADsSecDes
);
BAIL_ON_FAILURE(hr);
pIADsSecDes->Release();
pIADsSecDes = NULL;
hr = pSecurityDescriptor->QueryInterface(
IID_IDispatch,
(void **) &pIDispatch
);
BAIL_ON_FAILURE(hr);
_dwDataType = VAL_IDISPATCH_SECDESC_ONLY;
_pDispatch = pIDispatch;
RRETURN(hr);
error:
if (pIADsSecDes) {
pIADsSecDes->Release();
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::get_LargeInteger(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsLargeInteger * pLargeInteger = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_LARGE_INTEGER) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_LargeInteger,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsLargeInteger,
(void **) &pLargeInteger);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->put_LowPart(_ADsValue.LargeInteger.LowPart);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->put_HighPart(_ADsValue.LargeInteger.HighPart);
BAIL_ON_FAILURE(hr);
pLargeInteger->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pLargeInteger) {
pLargeInteger->Release();
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_LargeInteger(THIS_ IDispatch FAR* lnLargeInteger)
{
IADsLargeInteger *pLargeInteger = NULL;
HRESULT hr = S_OK;
LONG lnDataHigh = 0;
LONG lnDataLow = 0;
ClearData();
hr = lnLargeInteger->QueryInterface(
IID_IADsLargeInteger,
(void **)&pLargeInteger
);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->get_HighPart(&lnDataHigh);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->get_LowPart(&lnDataLow);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_LARGE_INTEGER;
_ADsValue.LargeInteger.HighPart = lnDataHigh;
_ADsValue.LargeInteger.LowPart = lnDataLow;
error:
if (pLargeInteger) {
pLargeInteger->Release();
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::get_UTCTime(THIS_ DATE *retval)
{
HRESULT hr = S_OK;
int result = FALSE;
if (_ADsValue.dwType != ADSTYPE_UTC_TIME) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
result = SystemTimeToVariantTime(&_ADsValue.UTCTime, retval);
if (result != TRUE) {
hr = E_FAIL;
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::put_UTCTime(THIS_ DATE DateInDate)
{
HRESULT hr = S_OK;
int result = FALSE;
ClearData();
_ADsValue.dwType = ADSTYPE_UTC_TIME;
result = VariantTimeToSystemTime(DateInDate, &_ADsValue.UTCTime);
if (result != TRUE) {
hr = E_FAIL;
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::ConvertADsValueToPropertyValue(THIS_ PADSVALUE pADsValue)
{
HRESULT hr = S_OK;
hr = ConvertADsValueToPropertyValue2(
pADsValue,
NULL,
NULL,
TRUE
);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::ConvertADsValueToPropertyValue2(
THIS_ PADSVALUE pADsValue,
LPWSTR pszServerName,
CCredentials* pCredentials,
BOOL fNTDSType
)
{
HRESULT hr = S_OK;
ClearData();
hr = AdsCopyADsValueToPropObj(
pADsValue,
this,
pszServerName,
pCredentials,
fNTDSType
);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::ConvertPropertyValueToADsValue(THIS_ PADSVALUE pADsValue)
{
return( ConvertPropertyValueToADsValue2(
pADsValue,
NULL, // serverName
NULL, // userName
NULL, // userPassword
0, // default flags.
TRUE // flag NTDS
)
);
}
//
// Handles all the parameters
//
STDMETHODIMP
CPropertyValue::ConvertPropertyValueToADsValue2(
THIS_ PADSVALUE pADsValue,
LPWSTR pszServerName,
LPWSTR pszUserName,
LPWSTR pszPassWord,
LONG dwFlags,
BOOL fNTDSType
)
{
HRESULT hr = S_OK;
CCredentials Credentials( pszUserName, pszPassWord, dwFlags);
hr = AdsCopyPropObjToADsValue(
this,
pADsValue,
pszServerName,
&Credentials,
fNTDSType
);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::get_CaseIgnoreList(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsCaseIgnoreList * pCaseIgnoreList = NULL;
IDispatch * pDispatch = NULL;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
long i;
BSTR bstrAddress;
PADS_CASEIGNORE_LIST pCurrent = NULL;
DWORD cElements = 0;
VARIANT VarDestObject;
VariantInit( &VarDestObject );
if (_ADsValue.dwType != ADSTYPE_CASEIGNORE_LIST) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pCaseIgnoreList) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_CaseIgnoreList,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsCaseIgnoreList,
(void **) &pCaseIgnoreList);
BAIL_ON_FAILURE(hr);
pCurrent = _ADsValue.pCaseIgnoreList;
while (pCurrent) {
cElements++;
pCurrent = pCurrent->Next;
}
aBound.lLbound = 0;
aBound.cElements = cElements;
aList = SafeArrayCreate( VT_BSTR, 1, &aBound );
if ( aList == NULL ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = _ADsValue.pCaseIgnoreList;
for ( i = 0; i < (long)cElements; i++ ) {
hr = ADsAllocString(
pCurrent->String,
&bstrAddress
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayPutElement( aList, &i, bstrAddress );
BAIL_ON_FAILURE(hr);
pCurrent = pCurrent->Next;
}
V_VT(&VarDestObject) = VT_ARRAY | VT_BSTR;
V_ARRAY(&VarDestObject) = aList;
hr = pCaseIgnoreList->put_CaseIgnoreList(VarDestObject);
BAIL_ON_FAILURE(hr);
hr = pCaseIgnoreList->QueryInterface(IID_IDispatch, (void**)&pDispatch);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
VariantClear( &VarDestObject );
if (pCaseIgnoreList) {
pCaseIgnoreList->Release();
}
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_CaseIgnoreList(THIS_ IDispatch FAR* pdCaseIgnoreList)
{
IADsCaseIgnoreList *pCaseIgnoreList = NULL;
HRESULT hr = S_OK;
LONG lnAmount= 0;
DWORD dwSLBound = 0;
DWORD dwSUBound = 0;
long i;
PADS_CASEIGNORE_LIST pCurrent = NULL;
IDispatch FAR * pDispatch = NULL;
BYTE* pbParameter = NULL;
VARIANT varCaseIgnoreList;
VARIANT varBstrElement;
ClearData();
VariantInit(&varCaseIgnoreList);
hr = pdCaseIgnoreList->QueryInterface(
IID_IADsCaseIgnoreList,
(void **)&pCaseIgnoreList
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_CASEIGNORE_LIST;
hr = pCaseIgnoreList->get_CaseIgnoreList(&varCaseIgnoreList);
BAIL_ON_FAILURE(hr);
if(!((V_VT(&varCaseIgnoreList) & VT_VARIANT) && V_ISARRAY(&varCaseIgnoreList))) {
return(E_FAIL);
}
if ((V_ARRAY(&varCaseIgnoreList))->cDims != 1) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
if ((V_ARRAY(&varCaseIgnoreList))->rgsabound[0].cElements <= 0) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayGetLBound(V_ARRAY(&varCaseIgnoreList),
1,
(long FAR *)&dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(&varCaseIgnoreList),
1,
(long FAR *)&dwSUBound
);
BAIL_ON_FAILURE(hr);
_ADsValue.pCaseIgnoreList = (PADS_CASEIGNORE_LIST)AllocADsMem(sizeof(ADS_CASEIGNORE_LIST));
if (!_ADsValue.pCaseIgnoreList) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = _ADsValue.pCaseIgnoreList;
for (i = dwSLBound; i <= (long)dwSUBound; i++) {
VariantInit(&varBstrElement);
hr = SafeArrayGetElement(V_ARRAY(&varCaseIgnoreList),
(long FAR *)&i,
&varBstrElement
);
BAIL_ON_FAILURE(hr);
pCurrent->String = AllocADsStr(V_BSTR(&varBstrElement));
VariantClear(&varBstrElement);
if (!pCurrent->String) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
if (i != (long)dwSUBound) {
pCurrent->Next = (PADS_CASEIGNORE_LIST)AllocADsMem(sizeof(ADS_CASEIGNORE_LIST));
if (!pCurrent->Next) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = pCurrent->Next;
}
}
pCurrent->Next = NULL;
RRETURN(S_OK);
error:
VariantClear(&varCaseIgnoreList);
if (pCaseIgnoreList) {
pCaseIgnoreList->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_FaxNumber(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsFaxNumber * pFaxNumber = NULL;
IDispatch * pDispatch = NULL;
VARIANT Var;
if (_ADsValue.dwType != ADSTYPE_FAXNUMBER) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pFaxNumber) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_FaxNumber,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsFaxNumber,
(void **) &pFaxNumber);
BAIL_ON_FAILURE(hr);
VariantInit(&Var);
hr = BinaryToVariant(
_ADsValue.pFaxNumber->NumberOfBits,
_ADsValue.pFaxNumber->Parameters,
&Var);
BAIL_ON_FAILURE(hr);
hr = pFaxNumber->put_Parameters(Var);
BAIL_ON_FAILURE(hr);
VariantClear(&Var);
hr = pFaxNumber->put_TelephoneNumber(_ADsValue.pFaxNumber->TelephoneNumber);
BAIL_ON_FAILURE(hr);
pFaxNumber->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pFaxNumber) {
pFaxNumber->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_FaxNumber(THIS_ IDispatch FAR* pdFaxNumber)
{
IADsFaxNumber *pFaxNumber = NULL;
HRESULT hr = S_OK;
BSTR bstrTelephoneNumber;
VARIANT varAddress;
VariantInit(&varAddress);
ClearData();
hr = pdFaxNumber->QueryInterface(
IID_IADsFaxNumber,
(void **)&pFaxNumber
);
BAIL_ON_FAILURE(hr);
hr = pFaxNumber->get_TelephoneNumber(&bstrTelephoneNumber);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_FAXNUMBER;
_ADsValue.pFaxNumber = (PADS_FAXNUMBER)AllocADsMem(sizeof(ADS_FAXNUMBER));
if (!_ADsValue.pFaxNumber) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.pFaxNumber->TelephoneNumber = AllocADsStr(bstrTelephoneNumber);
if (!_ADsValue.pFaxNumber->TelephoneNumber) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = pFaxNumber->get_Parameters(&varAddress);
BAIL_ON_FAILURE(hr);
hr = VariantToBinary(
&varAddress,
&_ADsValue.pFaxNumber->NumberOfBits,
&_ADsValue.pFaxNumber->Parameters
);
BAIL_ON_FAILURE(hr);
error:
VariantClear(&varAddress);
if (pFaxNumber) {
pFaxNumber->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_NetAddress(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsNetAddress * pNetAddress = NULL;
IDispatch * pDispatch = NULL;
VARIANT VarAddress;
VariantInit(&VarAddress);
if (_ADsValue.dwType != ADSTYPE_NETADDRESS) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pNetAddress) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_NetAddress,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsNetAddress,
(void **) &pNetAddress);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->put_AddressType(_ADsValue.pNetAddress->AddressType);
BAIL_ON_FAILURE(hr);
hr = BinaryToVariant(
_ADsValue.pNetAddress->AddressLength,
_ADsValue.pNetAddress->Address,
&VarAddress);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->put_Address(VarAddress);
BAIL_ON_FAILURE(hr);
pNetAddress->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
VariantClear(&VarAddress);
if (pNetAddress) {
pNetAddress->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_NetAddress(THIS_ IDispatch FAR* pdNetAddress)
{
IADsNetAddress *pNetAddress = NULL;
HRESULT hr = S_OK;
LONG lnAddressType = 0;
VARIANT varAddress;
ClearData();
VariantInit(&varAddress);
_ADsValue.pNetAddress = (PADS_NETADDRESS)AllocADsMem(sizeof(ADS_NETADDRESS));
if (!_ADsValue.pNetAddress) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = pdNetAddress->QueryInterface(
IID_IADsNetAddress,
(void **)&pNetAddress
);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->get_AddressType(
&lnAddressType
);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->get_Address(
&varAddress
);
BAIL_ON_FAILURE(hr);
hr = VariantToBinary(
&varAddress,
&_ADsValue.pNetAddress->AddressLength,
&_ADsValue.pNetAddress->Address
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_NETADDRESS;
_ADsValue.pNetAddress->AddressType = lnAddressType;
error:
VariantClear(&varAddress);
if (pNetAddress) {
pNetAddress->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_OctetList(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsOctetList* pOctetList = NULL;
IDispatch * pDispatch = NULL;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
long i;
PADS_OCTET_LIST pCurrent = NULL;
DWORD cElements = 0;
VARIANT VarDestObject;
VARIANT varElement;
VariantInit( &VarDestObject );
if (_ADsValue.dwType != ADSTYPE_OCTET_LIST) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pOctetList) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_OctetList,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsOctetList,
(void **) &pOctetList);
BAIL_ON_FAILURE(hr);
pCurrent = _ADsValue.pOctetList;
while (pCurrent) {
cElements++;
pCurrent = pCurrent->Next;
}
aBound.lLbound = 0;
aBound.cElements = cElements;
aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
if ( aList == NULL ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = _ADsValue.pOctetList;
for ( i = 0; i < (long)cElements; i++ ) {
hr = BinaryToVariant(
pCurrent->Length,
pCurrent->Data,
&varElement);
BAIL_ON_FAILURE(hr);
hr = SafeArrayPutElement( aList, &i, &varElement);
BAIL_ON_FAILURE(hr);
pCurrent = pCurrent->Next;
}
V_VT(&VarDestObject) = VT_ARRAY | VT_BSTR;
V_ARRAY(&VarDestObject) = aList;
hr = pOctetList->put_OctetList(VarDestObject);
BAIL_ON_FAILURE(hr);
hr = pOctetList->QueryInterface(IID_IDispatch, (void**)&pDispatch);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
VariantClear( &VarDestObject );
if (pOctetList) {
pOctetList->Release();
}
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_OctetList(THIS_ IDispatch FAR* pdOctetList)
{
IADsOctetList *pOctetList = NULL;
HRESULT hr = S_OK;
LONG lnAmount= 0;
DWORD dwSLBound = 0;
DWORD dwSUBound = 0;
long i;
PADS_OCTET_LIST pCurrent = NULL;
IDispatch FAR * pDispatch = NULL;
BYTE* pbParameter = NULL;
VARIANT varOctetList;
VARIANT varElement;
VariantInit(&varOctetList);
ClearData();
hr = pdOctetList->QueryInterface(
IID_IADsOctetList,
(void **)&pOctetList
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_OCTET_LIST;
hr = pOctetList->get_OctetList(&varOctetList);
BAIL_ON_FAILURE(hr);
if(!((V_VT(&varOctetList) & VT_VARIANT) && V_ISARRAY(&varOctetList))) {
return(E_FAIL);
}
if ((V_ARRAY(&varOctetList))->cDims != 1) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
if ((V_ARRAY(&varOctetList))->rgsabound[0].cElements <= 0) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayGetLBound(V_ARRAY(&varOctetList),
1,
(long FAR *)&dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(&varOctetList),
1,
(long FAR *)&dwSUBound
);
BAIL_ON_FAILURE(hr);
_ADsValue.pOctetList = (PADS_OCTET_LIST)AllocADsMem(sizeof(ADS_OCTET_LIST));
if (!_ADsValue.pOctetList) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = _ADsValue.pOctetList;
for (i = dwSLBound; i <= (long)dwSUBound; i++) {
VariantInit(&varElement);
hr = SafeArrayGetElement(V_ARRAY(&varOctetList),
(long FAR *)&i,
&varElement
);
BAIL_ON_FAILURE(hr);
hr = VariantToBinary(
&varElement,
&pCurrent->Length,
&pCurrent->Data
);
BAIL_ON_FAILURE(hr);
if (i != (long)dwSUBound) {
pCurrent->Next = (PADS_OCTET_LIST)AllocADsMem(sizeof(ADS_OCTET_LIST));
if (!pCurrent->Next) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = pCurrent->Next;
}
VariantClear(&varElement);
}
pCurrent->Next = NULL;
error:
VariantClear(&varOctetList);
if (pOctetList) {
pOctetList->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_Email(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsEmail* pEmail = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_EMAIL) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_Email,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsEmail,
(void **) &pEmail);
BAIL_ON_FAILURE(hr);
hr = pEmail->put_Type(_ADsValue.Email.Type);
BAIL_ON_FAILURE(hr);
hr = pEmail->put_Address(_ADsValue.Email.Address);
BAIL_ON_FAILURE(hr);
pEmail->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pEmail) {
pEmail->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_Email(THIS_ IDispatch FAR* pdEmail)
{
IADsEmail *pEmail = NULL;
HRESULT hr = S_OK;
LONG lnType= 0;
BSTR bstrAddress;
ClearData();
hr = pdEmail->QueryInterface(
IID_IADsEmail,
(void **)&pEmail
);
BAIL_ON_FAILURE(hr);
hr = pEmail->get_Type(
&lnType
);
BAIL_ON_FAILURE(hr);
hr = pEmail->get_Address(&bstrAddress);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_EMAIL;
_ADsValue.Email.Type = lnType;
_ADsValue.Email.Address = AllocADsStr(bstrAddress);
if (!_ADsValue.Email.Address) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
if (pEmail) {
pEmail->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_Path(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsPath* pPath = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_PATH) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pPath) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_Path,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsPath,
(void **) &pPath);
BAIL_ON_FAILURE(hr);
hr = pPath->put_Type(_ADsValue.pPath->Type);
BAIL_ON_FAILURE(hr);
hr = pPath->put_VolumeName(_ADsValue.pPath->VolumeName);
BAIL_ON_FAILURE(hr);
hr = pPath->put_Path(_ADsValue.pPath->Path);
BAIL_ON_FAILURE(hr);
pPath->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pPath) {
pPath->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_Path(THIS_ IDispatch FAR* pdPath)
{
IADsPath *pPath = NULL;
HRESULT hr = S_OK;
LONG lnType = 0;
BSTR bstrVolumeName;
BSTR bstrPath;
ClearData();
hr = pdPath->QueryInterface(
IID_IADsPath,
(void **)&pPath
);
BAIL_ON_FAILURE(hr);
hr = pPath->get_Type(
&lnType
);
BAIL_ON_FAILURE(hr);
hr = pPath->get_VolumeName(
&bstrVolumeName
);
BAIL_ON_FAILURE(hr);
hr = pPath->get_Path(
&bstrPath
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_PATH;
_ADsValue.pPath = (PADS_PATH)AllocADsMem(sizeof(ADS_PATH));
if (!_ADsValue.pPath) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.pPath->Type = lnType;
_ADsValue.pPath->VolumeName = AllocADsStr(bstrVolumeName);
if (!_ADsValue.pPath->VolumeName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.pPath->Path = AllocADsStr(bstrPath);
if (!_ADsValue.pPath->Path) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
if (pPath) {
pPath->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_ReplicaPointer(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsReplicaPointer* pReplicaPointer = NULL;
IDispatch * pDispatch = NULL;
IADsNetAddress* pNetAddress = NULL;
VARIANT VarNetAddress;
VARIANT VarDest;
VariantInit(&VarNetAddress);
VariantInit(&VarDest);
if (_ADsValue.dwType != ADSTYPE_REPLICAPOINTER) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pReplicaPointer) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_ReplicaPointer,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsReplicaPointer,
(void **) &pReplicaPointer);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->put_ReplicaType(_ADsValue.pReplicaPointer->ReplicaType);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->put_ReplicaNumber(_ADsValue.pReplicaPointer->ReplicaNumber);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->put_Count(_ADsValue.pReplicaPointer->Count);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->put_ServerName(_ADsValue.pReplicaPointer->ServerName);
BAIL_ON_FAILURE(hr);
////
hr = CoCreateInstance(
CLSID_NetAddress,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsNetAddress,
(void **) &pNetAddress);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->put_AddressType(_ADsValue.pReplicaPointer->ReplicaAddressHints->AddressType);
BAIL_ON_FAILURE(hr);
hr = BinaryToVariant(
_ADsValue.pReplicaPointer->ReplicaAddressHints->AddressLength,
_ADsValue.pReplicaPointer->ReplicaAddressHints->Address,
&VarNetAddress);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->put_Address(VarNetAddress);
BAIL_ON_FAILURE(hr);
pNetAddress->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
V_VT(&VarDest) = VT_DISPATCH;
V_DISPATCH(&VarDest) = pDispatch;
hr = pReplicaPointer->put_ReplicaAddressHints(VarDest);
BAIL_ON_FAILURE(hr);
pReplicaPointer->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
VariantClear(&VarNetAddress);
VariantClear(&VarDest);
if (pReplicaPointer) {
pReplicaPointer->Release();
}
if (pNetAddress) {
pNetAddress->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_ReplicaPointer(THIS_ IDispatch FAR* pdReplicaPointer)
{
IADsReplicaPointer *pReplicaPointer = NULL;
HRESULT hr = S_OK;
LONG lnAmount= 0;
IADsNetAddress *pNetAddress = NULL;
LONG lnAddressType = 0;
VARIANT varAddress;
IDispatch *pdNetAddress = NULL;
long lnReplicaType;
long lnReplicaNumber;
long lnCount;
BSTR bstrServerName;
VariantInit(&varAddress);
ClearData();
_ADsValue.pReplicaPointer = (PADS_REPLICAPOINTER)AllocADsMem(sizeof(ADS_REPLICAPOINTER));
if (!_ADsValue.pReplicaPointer) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.pReplicaPointer->ReplicaAddressHints =
(PADS_NETADDRESS)
AllocADsMem(
sizeof(ADS_NETADDRESS)
);
if (!(_ADsValue.pReplicaPointer->ReplicaAddressHints)) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = pdReplicaPointer->QueryInterface(
IID_IADsReplicaPointer,
(void **)&pReplicaPointer
);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->get_ReplicaType(
&lnReplicaType
);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->get_ReplicaNumber(
&lnReplicaNumber
);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->get_Count(
&lnCount
);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->get_ServerName(
&bstrServerName
);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->get_ReplicaAddressHints(&varAddress);
BAIL_ON_FAILURE(hr);
if (V_VT(&varAddress) != VT_DISPATCH){
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
pdNetAddress = V_DISPATCH(&varAddress);
hr = pdNetAddress->QueryInterface(
IID_IADsNetAddress,
(void **)&pNetAddress
);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->get_AddressType(
&lnAddressType
);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->get_Address(
&varAddress
);
BAIL_ON_FAILURE(hr);
hr = VariantToBinary(
&varAddress,
&_ADsValue.pReplicaPointer->ReplicaAddressHints->AddressLength,
&_ADsValue.pReplicaPointer->ReplicaAddressHints->Address
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_REPLICAPOINTER;
_ADsValue.pReplicaPointer->ReplicaAddressHints->AddressType = lnAddressType;
_ADsValue.pReplicaPointer->ReplicaType = lnReplicaType;
_ADsValue.pReplicaPointer->ReplicaNumber = lnReplicaNumber;
_ADsValue.pReplicaPointer->Count = lnCount;
_ADsValue.pReplicaPointer->ServerName = AllocADsStr(bstrServerName);
if (!_ADsValue.pReplicaPointer->ServerName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
VariantClear(&varAddress);
if (pNetAddress) {
pNetAddress->Release();
}
if (pReplicaPointer) {
pReplicaPointer->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_Timestamp(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsTimestamp* pTimestamp = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_TIMESTAMP) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_Timestamp,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsTimestamp,
(void **) &pTimestamp);
BAIL_ON_FAILURE(hr);
hr = pTimestamp->put_WholeSeconds(_ADsValue.Timestamp.WholeSeconds);
BAIL_ON_FAILURE(hr);
hr = pTimestamp->put_EventID(_ADsValue.Timestamp.EventID);
BAIL_ON_FAILURE(hr);
pTimestamp->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pTimestamp) {
pTimestamp->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_Timestamp(THIS_ IDispatch FAR* lnTimestamp)
{
IADsTimestamp *pTimestamp = NULL;
HRESULT hr = S_OK;
LONG lnWholeSeconds = 0;
LONG lnEventID = 0;
ClearData();
hr = lnTimestamp->QueryInterface(
IID_IADsTimestamp,
(void **)&pTimestamp
);
BAIL_ON_FAILURE(hr);
hr = pTimestamp->get_WholeSeconds(
&lnWholeSeconds
);
BAIL_ON_FAILURE(hr);
hr = pTimestamp->get_EventID(
&lnEventID
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_TIMESTAMP;
_ADsValue.Timestamp.WholeSeconds = lnWholeSeconds;
_ADsValue.Timestamp.EventID = lnEventID;
error:
if (pTimestamp) {
pTimestamp->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_PostalAddress(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsPostalAddress * pPostalAddress = NULL;
IDispatch * pDispatch = NULL;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
long i;
BSTR bstrAddress;
DWORD cElements = 0;
VARIANT VarDestObject;
VariantInit( &VarDestObject );
if (_ADsValue.dwType != ADSTYPE_POSTALADDRESS) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pPostalAddress) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_PostalAddress,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsPostalAddress,
(void **) &pPostalAddress);
BAIL_ON_FAILURE(hr);
aBound.lLbound = 0;
aBound.cElements = 6;
aList = SafeArrayCreate( VT_BSTR, 1, &aBound );
if ( aList == NULL ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
for ( i = 0; i < (long) 6; i++ )
{
hr = ADsAllocString(
_ADsValue.pPostalAddress->PostalAddress[i],
&bstrAddress
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayPutElement( aList, &i, bstrAddress );
BAIL_ON_FAILURE(hr);
}
V_VT(&VarDestObject) = VT_ARRAY | VT_BSTR;
V_ARRAY(&VarDestObject) = aList;
hr = pPostalAddress->put_PostalAddress(VarDestObject);
BAIL_ON_FAILURE(hr);
hr = pPostalAddress->QueryInterface(IID_IDispatch, (void**)&pDispatch);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
RRETURN(hr);
error:
VariantClear( &VarDestObject );
if (pPostalAddress) {
pPostalAddress->Release();
}
if (aList) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_PostalAddress(THIS_ IDispatch FAR* pdPostalAddress)
{
IADsPostalAddress *pPostalAddress = NULL;
HRESULT hr = S_OK;
LONG lnAmount= 0;
DWORD dwSLBound = 0;
DWORD dwSUBound = 0;
long i;
IDispatch FAR * pDispatch = NULL;
BYTE* pbParameter = NULL;
VARIANT varAddress;
VARIANT varBstrElement;
VariantInit(&varAddress);
ClearData();
hr = pdPostalAddress->QueryInterface(
IID_IADsPostalAddress,
(void **)&pPostalAddress
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_POSTALADDRESS;
_ADsValue.pPostalAddress = (PADS_POSTALADDRESS)AllocADsMem(sizeof(ADS_POSTALADDRESS));
if (!_ADsValue.pPostalAddress) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = pPostalAddress->get_PostalAddress(
&varAddress
);
BAIL_ON_FAILURE(hr);
if(!((V_VT(&varAddress) & VT_VARIANT) && V_ISARRAY(&varAddress))) {
return(E_FAIL);
}
if ((V_ARRAY(&varAddress))->cDims != 1) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
if ( ((V_ARRAY(&varAddress))->rgsabound[0].cElements <= 0) ||
((V_ARRAY(&varAddress))->rgsabound[0].cElements >6) ) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayGetLBound(V_ARRAY(&varAddress),
1,
(long FAR *)&dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(&varAddress),
1,
(long FAR *)&dwSUBound
);
BAIL_ON_FAILURE(hr);
for (i = dwSLBound; i <= (long)dwSUBound; i++) {
VariantInit(&varBstrElement);
hr = SafeArrayGetElement(V_ARRAY(&varAddress),
(long FAR *)&i,
&varBstrElement
);
BAIL_ON_FAILURE(hr);
_ADsValue.pPostalAddress->PostalAddress[i-dwSLBound] = AllocADsStr(V_BSTR(&varBstrElement));
VariantClear(&varBstrElement);
if (!_ADsValue.pPostalAddress->PostalAddress[i-dwSLBound]) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
}
RRETURN(S_OK);
error:
VariantClear(&varAddress);
if (pPostalAddress) {
pPostalAddress->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_BackLink(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsBackLink* pBackLink = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_BACKLINK) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_BackLink,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsBackLink,
(void **) &pBackLink);
BAIL_ON_FAILURE(hr);
hr = pBackLink->put_RemoteID(_ADsValue.BackLink.RemoteID);
BAIL_ON_FAILURE(hr);
hr = pBackLink->put_ObjectName(_ADsValue.BackLink.ObjectName);
BAIL_ON_FAILURE(hr);
pBackLink->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pBackLink) {
pBackLink->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_BackLink(THIS_ IDispatch FAR* pdBackLink)
{
IADsBackLink *pBackLink = NULL;
HRESULT hr = S_OK;
LONG lnRemoteID = 0;
BSTR bstrObjectName;
ClearData();
hr = pdBackLink->QueryInterface(
IID_IADsBackLink,
(void **)&pBackLink
);
BAIL_ON_FAILURE(hr);
hr = pBackLink->get_RemoteID(
&lnRemoteID
);
BAIL_ON_FAILURE(hr);
hr = pBackLink->get_ObjectName(
&bstrObjectName
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_BACKLINK;
_ADsValue.BackLink.RemoteID = lnRemoteID;
_ADsValue.BackLink.ObjectName = AllocADsStr(bstrObjectName);
if (!_ADsValue.BackLink.ObjectName ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
if (pBackLink) {
pBackLink->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_TypedName(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsTypedName* pTypedName = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_TYPEDNAME) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
if (!_ADsValue.pTypedName) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_TypedName,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsTypedName,
(void **) &pTypedName);
BAIL_ON_FAILURE(hr);
hr = pTypedName->put_Level(_ADsValue.pTypedName->Level);
BAIL_ON_FAILURE(hr);
hr = pTypedName->put_Interval(_ADsValue.pTypedName->Interval);
BAIL_ON_FAILURE(hr);
hr = pTypedName->put_ObjectName(_ADsValue.pTypedName->ObjectName);
BAIL_ON_FAILURE(hr);
pTypedName->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pTypedName) {
pTypedName->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_TypedName(THIS_ IDispatch FAR* pdTypedName)
{
IADsTypedName* pTypedName = NULL;
HRESULT hr = S_OK;
LONG lnLevel= 0;
LONG lnInterval= 0;
BSTR bstrObjectName;
ClearData();
hr = pdTypedName->QueryInterface(
IID_IADsTypedName,
(void **)&pTypedName
);
BAIL_ON_FAILURE(hr);
hr = pTypedName->get_Level(
&lnLevel
);
BAIL_ON_FAILURE(hr);
hr = pTypedName->get_Interval(
&lnInterval
);
BAIL_ON_FAILURE(hr);
hr = pTypedName->get_ObjectName(
&bstrObjectName
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_TYPEDNAME;
_ADsValue.pTypedName = (PADS_TYPEDNAME)AllocADsMem(sizeof(ADS_TYPEDNAME));
if (!_ADsValue.pTypedName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.pTypedName->Level= lnLevel;
_ADsValue.pTypedName->Interval= lnInterval;
_ADsValue.pTypedName->ObjectName = AllocADsStr(bstrObjectName);
if (!_ADsValue.pTypedName->ObjectName ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
if (pTypedName) {
pTypedName->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::get_Hold(THIS_ IDispatch FAR * FAR *retval)
{
HRESULT hr = S_OK;
IADsHold* pHold = NULL;
IDispatch * pDispatch = NULL;
if (_ADsValue.dwType != ADSTYPE_HOLD) {
hr = E_ADS_CANT_CONVERT_DATATYPE;
BAIL_ON_FAILURE(hr);
}
hr = CoCreateInstance(
CLSID_Hold,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsHold,
(void **) &pHold);
BAIL_ON_FAILURE(hr);
hr = pHold->put_Amount(_ADsValue.Hold.Amount);
BAIL_ON_FAILURE(hr);
hr = pHold->put_ObjectName(_ADsValue.Hold.ObjectName);
BAIL_ON_FAILURE(hr);
pHold->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
*retval = pDispatch;
error:
if (pHold) {
pHold->Release();
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::put_Hold(THIS_ IDispatch FAR* pdHold)
{
IADsHold *pHold = NULL;
HRESULT hr = S_OK;
LONG lnAmount= 0;
BSTR bstrObjectName;
ClearData();
hr = pdHold->QueryInterface(
IID_IADsHold,
(void **)&pHold
);
BAIL_ON_FAILURE(hr);
hr = pHold->get_Amount(
&lnAmount
);
BAIL_ON_FAILURE(hr);
hr = pHold->get_ObjectName(
&bstrObjectName
);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_HOLD;
_ADsValue.Hold.Amount= lnAmount;
_ADsValue.Hold.ObjectName = AllocADsStr(bstrObjectName);
if (!_ADsValue.Hold.ObjectName ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
if (pHold) {
pHold->Release();
}
RRETURN(hr);
}
//
// Helper to get octetString in variant if we have a
// secDesc stored underneath.
//
STDMETHODIMP
CPropertyValue::getOctetStringFromSecDesc(VARIANT FAR *retval)
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
ADSVALUE ADsDestValue;
memset(&ADsDestValue, 0, sizeof(ADSVALUE));
hr = AdsCopyPropObjToADsValue(
this,
&ADsDestValue,
NULL, // pszServerName,
NULL, // pCredentials - use default credentials
TRUE // fNTDSType
);
BAIL_ON_FAILURE(hr);
if (ADsDestValue.dwType != ADSTYPE_OCTET_STRING) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
aBound.lLbound = 0;
aBound.cElements = ADsDestValue.OctetString.dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if ( aList == NULL ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray);
BAIL_ON_FAILURE(hr);
memcpy(pArray, ADsDestValue.OctetString.lpValue, aBound.cElements);
SafeArrayUnaccessData( aList );
V_VT(retval) = VT_ARRAY | VT_UI1;
V_ARRAY(retval) = aList;
error:
if (FAILED(hr) && aList) {
SafeArrayDestroy(aList);
}
AdsClear(&ADsDestValue);
RRETURN(hr);
}
//
// Helper to get SecDesc in variant if we have a
// octetString stored underneath.
//
STDMETHODIMP
CPropertyValue::getSecurityDescriptorFromOctStr(VARIANT FAR *retval)
{
HRESULT hr = S_OK;
CCredentials dummyCredentials(NULL, NULL, 0);
hr = ConvertSecDescriptorToVariant(
NULL, // pszServerName
dummyCredentials,
_ADsValue.OctetString.lpValue,
retval,
TRUE // NTDS Type
);
RRETURN(hr);
}
//
// There has to be a better way to do this. Ideally this code
// should live in one plae and we should be able to use that
// everywhere. Currently it lives here as well as in the ldap
// provider - slight differences though.
// This comment holds true for DNWithString also - AjayR 4-30-99
//
STDMETHODIMP
CPropertyValue::getDNWithBinary(THIS_ IDispatch FAR * FAR * ppDispatch)
{
HRESULT hr = S_OK;
IADsDNWithBinary *pDNWithBinary = NULL;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
BSTR bstrTemp = NULL;
VARIANT vVar;
VariantInit(&vVar);
if (_ADsValue.dwType != ADSTYPE_DN_WITH_BINARY) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = CoCreateInstance(
CLSID_DNWithBinary,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsDNWithBinary,
(void **) &pDNWithBinary
);
BAIL_ON_FAILURE(hr);
if (_ADsValue.pDNWithBinary->pszDNString) {
hr = ADsAllocString(_ADsValue.pDNWithBinary->pszDNString, &bstrTemp);
BAIL_ON_FAILURE(hr);
//
// Put the value in the object - we can only set BSTR's
//
hr = pDNWithBinary->put_DNString(bstrTemp);
BAIL_ON_FAILURE(hr);
}
aBound.lLbound = 0;
aBound.cElements = _ADsValue.pDNWithBinary->dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( pArray, _ADsValue.pDNWithBinary->lpBinaryValue, aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(&vVar) = VT_ARRAY | VT_UI1;
V_ARRAY(&vVar) = aList;
hr = pDNWithBinary->put_BinaryValue(vVar);
VariantClear(&vVar);
BAIL_ON_FAILURE(hr);
hr = pDNWithBinary->QueryInterface(
IID_IDispatch,
(void **) ppDispatch
);
BAIL_ON_FAILURE(hr);
error:
if (pDNWithBinary) {
pDNWithBinary->Release();
}
if (bstrTemp) {
ADsFreeString(bstrTemp);
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::putDNWithBinary(THIS_ IDispatch * pDNWithBinary)
{
HRESULT hr = S_OK;
IADsDNWithBinary * pDNBinary = NULL;
PADS_DN_WITH_BINARY pDNBin = NULL;
VARIANT vBinary;
DWORD dwSUBound = 0;
DWORD dwSLBound = 0;
DWORD dwLength = 0;
BSTR bstrDN = NULL;
LPBYTE lpByte = NULL;
CHAR HUGEP *pArray = NULL;
VariantInit(&vBinary);
ClearData();
//
// This qi ensures that this is a security descriptor
//
hr = pDNWithBinary->QueryInterface(
IID_IADsDNWithBinary,
(void **) &pDNBinary
);
BAIL_ON_FAILURE(hr);
//
// Convert to ADSVALUE and then to ldap representation.
// This way the code to and from LDAP lives in one place.
//
hr = pDNBinary->get_BinaryValue(&vBinary);
BAIL_ON_FAILURE(hr);
if ((vBinary.vt != (VT_ARRAY | VT_UI1))
&& vBinary.vt != VT_EMPTY) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
hr = pDNBinary->get_DNString(&bstrDN);
BAIL_ON_FAILURE(hr);
//
// Get the byte array in a usable format.
//
hr = SafeArrayGetLBound(
V_ARRAY(&vBinary),
1,
(long FAR *) &dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(
V_ARRAY(&vBinary),
1,
(long FAR *) &dwSUBound
);
BAIL_ON_FAILURE(hr);
dwLength = dwSUBound - dwSLBound + 1;
lpByte = (LPBYTE) AllocADsMem(dwLength);
if (dwLength && !lpByte) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
hr = SafeArrayAccessData(
V_ARRAY(&vBinary),
(void HUGEP * FAR *) &pArray
);
BAIL_ON_FAILURE(hr);
memcpy(lpByte, pArray, dwLength);
SafeArrayUnaccessData( V_ARRAY(&vBinary) );
pDNBin = (PADS_DN_WITH_BINARY) AllocADsMem(sizeof(ADS_DN_WITH_BINARY));
if (!pDNBin) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (bstrDN) {
pDNBin->pszDNString = AllocADsStr(bstrDN);
if (!pDNBin->pszDNString) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
_ADsValue.dwType = ADSTYPE_DN_WITH_BINARY;
_ADsValue.pDNWithBinary = pDNBin;
_ADsValue.pDNWithBinary->lpBinaryValue = lpByte;
_ADsValue.pDNWithBinary->dwLength = dwLength;
error:
if (pDNBinary) {
pDNBinary->Release();
}
if (FAILED(hr)) {
if (lpByte) {
FreeADsMem(lpByte);
}
if (pDNBin) {
if (pDNBin->pszDNString) {
FreeADsStr(pDNBin->pszDNString);
}
FreeADsMem(pDNBin);
}
}
if (bstrDN) {
ADsFreeString(bstrDN);
}
VariantClear(&vBinary);
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::putDNWithString(THIS_ IDispatch * pDNWithString)
{
HRESULT hr = S_OK;
IADsDNWithString *pDNString = NULL;
PADS_DN_WITH_STRING pDNStr = NULL;
BSTR bstrStringValue = NULL;
BSTR bstrDN = NULL;
ClearData();
hr = pDNWithString->QueryInterface(
IID_IADsDNWithString,
(void **)&pDNString
);
BAIL_ON_FAILURE(hr);
hr = pDNString->get_StringValue(&bstrStringValue);
BAIL_ON_FAILURE(hr);
hr = pDNString->get_DNString(&bstrDN);
BAIL_ON_FAILURE(hr);
_ADsValue.dwType = ADSTYPE_DN_WITH_STRING;
pDNStr = (PADS_DN_WITH_STRING) AllocADsMem(sizeof(ADS_DN_WITH_STRING));
if (!pDNStr) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Put String value in the DNString struct.
//
pDNStr->pszStringValue = AllocADsStr(bstrStringValue);
if (bstrStringValue && !pDNStr->pszStringValue) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pDNStr->pszDNString = AllocADsStr(bstrDN);
if (bstrDN && !pDNStr->pszDNString) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
_ADsValue.dwType = ADSTYPE_DN_WITH_STRING;
_ADsValue.pDNWithString = pDNStr;
error:
if (pDNString) {
pDNString->Release();
}
if (bstrStringValue) {
ADsFreeString(bstrStringValue);
}
if (bstrDN) {
ADsFreeString(bstrDN);
}
if (pDNStr && FAILED(hr)) {
if (pDNStr->pszDNString) {
FreeADsStr(pDNStr->pszDNString);
}
if (pDNStr->pszStringValue) {
FreeADsMem(pDNStr->pszStringValue);
}
FreeADsMem(pDNStr);
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::getDNWithString(THIS_ IDispatch FAR * FAR * ppDispatch)
{
HRESULT hr = S_OK;
ADSVALUE AdsValue;
IADsDNWithString *pDNWithString = NULL;
IDispatch *pDispatch = NULL;
BSTR bstrStrVal = NULL;
BSTR bstrDNVal = NULL;
if (_ADsValue.dwType != ADSTYPE_DN_WITH_STRING) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = CoCreateInstance(
CLSID_DNWithString,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsDNWithString,
(void **) &pDNWithString
);
BAIL_ON_FAILURE(hr);
if (_ADsValue.pDNWithString->pszDNString) {
hr = ADsAllocString(_ADsValue.pDNWithString->pszDNString, &bstrDNVal);
BAIL_ON_FAILURE(hr);
hr = pDNWithString->put_DNString(bstrDNVal);
BAIL_ON_FAILURE(hr);
}
if (_ADsValue.pDNWithString->pszStringValue) {
hr = ADsAllocString(
_ADsValue.pDNWithString->pszStringValue,
&bstrStrVal
);
BAIL_ON_FAILURE(hr);
hr = pDNWithString->put_StringValue(bstrStrVal);
BAIL_ON_FAILURE(hr);
}
hr = pDNWithString->QueryInterface(
IID_IDispatch,
(void **) ppDispatch
);
BAIL_ON_FAILURE(hr);
error:
if (pDNWithString) {
pDNWithString->Release();
}
if (bstrDNVal) {
ADsFreeString(bstrDNVal);
}
if (bstrStrVal) {
ADsFreeString(bstrStrVal);
}
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::getProvSpecific(THIS_ VARIANT FAR *retval )
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
if (_ADsValue.dwType != ADSTYPE_PROV_SPECIFIC) {
RRETURN(E_ADS_CANT_CONVERT_DATATYPE);
}
aBound.lLbound = 0;
aBound.cElements = _ADsValue.ProviderSpecific.dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( pArray,
_ADsValue.ProviderSpecific.lpValue,
aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(retval) = VT_ARRAY | VT_UI1;
V_ARRAY(retval) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CPropertyValue::putProvSpecific(THIS_ VARIANT VarProvSpecific)
{
LONG dwSLBound = 0;
LONG dwSUBound = 0;
CHAR HUGEP *pArray = NULL;
HRESULT hr = S_OK;
ClearData();
_ADsValue.dwType = ADSTYPE_PROV_SPECIFIC;
if( VarProvSpecific.vt != (VT_ARRAY | VT_UI1)) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = SafeArrayGetLBound(V_ARRAY(&VarProvSpecific),
1,
(long FAR *) &dwSLBound );
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(&VarProvSpecific),
1,
(long FAR *) &dwSUBound );
BAIL_ON_FAILURE(hr);
_ADsValue.ProviderSpecific.lpValue = (LPBYTE)AllocADsMem(dwSUBound - dwSLBound + 1);
if ( _ADsValue.ProviderSpecific.lpValue == NULL) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_ADsValue.ProviderSpecific.dwLength = dwSUBound - dwSLBound + 1;
hr = SafeArrayAccessData( V_ARRAY(&VarProvSpecific),
(void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( _ADsValue.ProviderSpecific.lpValue,
pArray,
dwSUBound-dwSLBound+1);
SafeArrayUnaccessData( V_ARRAY(&VarProvSpecific) );
error:
RRETURN_EXP_IF_ERR(hr);
}
void
CPropertyValue::ClearData()
{
//
// For all the types - this works even if the adsvalue is null
// as adsvalue.dwType = 0 ---> invalid_type does nothing !!!
//
AdsClear(&_ADsValue);
if (_pDispatch) {
switch (_dwDataType) {
case VAL_IDISPATCH_SECDESC_ONLY:
case VAL_IDISPATCH_SECDESC_ALL:
_pDispatch->Release();
_pDispatch = NULL;
_dwDataType = VAL_IDISPATCH_UNKNOWN;
break;
default:
ADsAssert(!"Internal incosistency secdesc ptr but bad type.");
_pDispatch = NULL;
_dwDataType = VAL_IDISPATCH_UNKNOWN;
break;
} // end switch
}
}
//+------------------------------------------------------------------------
//
// Function: CPropertyValue::GetObjectProperty
//
// Synopsis: Gets the values stored in this PropertyValue object. The
// value returned is determined by the value requested in lnContorlCode.
// For now though we will only support ADSTYPE_UNKNOWN in which case we
// get the info from the object itself. Alternatively the type should match
// that which is in the object.
//
//
// Arguments: lnControlCode - ADSTYPE_INVALID implies whatever we have
// - anything else implies we return the type.
// pvProp - the output value goes into this.
//
//
//-------------------------------------------------------------------------
STDMETHODIMP
CPropertyValue::GetObjectProperty(
THIS_ long *lnControlCode,
VARIANT *pvProp
)
{
HRESULT hr = S_OK;
ADSTYPE dwTypeAsked = ADSTYPE_INVALID;
ADsAssert(pvProp);
ADsAssert(lnControlCode);
if (*lnControlCode == ADSTYPE_UNKNOWN) {
dwTypeAsked = _ADsValue.dwType;
} else {
dwTypeAsked = (ADSTYPE)*lnControlCode;
}
*lnControlCode = dwTypeAsked;
switch (dwTypeAsked) {
case ADSTYPE_INVALID:
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
break;
case ADSTYPE_DN_STRING :
pvProp->vt = VT_BSTR;
hr = get_DNString(&(pvProp->bstrVal));
break;
case ADSTYPE_CASE_EXACT_STRING :
pvProp->vt = VT_BSTR;
hr = get_CaseExactString(&(pvProp->bstrVal));
break;
case ADSTYPE_CASE_IGNORE_STRING :
pvProp->vt = VT_BSTR;
hr = get_CaseIgnoreString(&(pvProp->bstrVal));
break;
case ADSTYPE_PRINTABLE_STRING :
pvProp->vt = VT_BSTR;
hr = get_PrintableString(&(pvProp->bstrVal));
break;
case ADSTYPE_NUMERIC_STRING :
pvProp->vt = VT_BSTR;
hr = get_NumericString(&(pvProp->bstrVal));
break;
case ADSTYPE_BOOLEAN :
{
LONG lnVal = 0;
pvProp->vt = VT_BOOL;
hr = get_Boolean(&(lnVal));
if (SUCCEEDED(hr)) {
pvProp->boolVal = lnVal ? VARIANT_TRUE : VARIANT_FALSE;
}
}
break;
case ADSTYPE_INTEGER :
pvProp->vt = VT_I4;
hr = get_Integer(&(pvProp->lVal));
break;
case ADSTYPE_OCTET_STRING :
hr = get_OctetString(pvProp);
if (hr == E_ADS_CANT_CONVERT_DATATYPE) {
//
// Try and see if it is a SD and convert
//
if (_ADsValue.dwType == ADSTYPE_NT_SECURITY_DESCRIPTOR) {
hr = getOctetStringFromSecDesc(pvProp);
}
}
break;
case ADSTYPE_PROV_SPECIFIC :
hr = getProvSpecific(pvProp);
break;
case ADSTYPE_UTC_TIME :
pvProp->vt = VT_DATE;
hr = get_UTCTime(&(pvProp->date));
break;
case ADSTYPE_LARGE_INTEGER :
pvProp->vt = VT_DISPATCH;
hr = get_LargeInteger(&(pvProp->pdispVal));
break;
case ADSTYPE_OBJECT_CLASS :
pvProp->vt = VT_DISPATCH;
hr = E_ADS_CANT_CONVERT_DATATYPE;
break;
case ADSTYPE_CASEIGNORE_LIST :
pvProp->vt = VT_DISPATCH;
hr = get_CaseIgnoreList(&(pvProp->pdispVal));
break;
case ADSTYPE_OCTET_LIST :
pvProp->vt = VT_DISPATCH;
hr = get_OctetList(&(pvProp->pdispVal));
break;
case ADSTYPE_PATH :
pvProp->vt = VT_DISPATCH;
hr = get_Path(&(pvProp->pdispVal));
break;
case ADSTYPE_POSTALADDRESS :
pvProp->vt = VT_DISPATCH;
hr = get_PostalAddress(&(pvProp->pdispVal));
break;
case ADSTYPE_TIMESTAMP :
pvProp->vt = VT_DISPATCH;
hr = get_Timestamp(&(pvProp->pdispVal));
break;
case ADSTYPE_BACKLINK :
pvProp->vt = VT_DISPATCH;
hr = get_BackLink(&(pvProp->pdispVal));
break;
case ADSTYPE_TYPEDNAME :
pvProp->vt = VT_DISPATCH;
hr = get_TypedName(&(pvProp->pdispVal));
break;
case ADSTYPE_HOLD :
pvProp->vt = VT_DISPATCH;
hr = get_Hold(&(pvProp->pdispVal));
break;
case ADSTYPE_NETADDRESS :
pvProp->vt = VT_DISPATCH;
hr = get_NetAddress(&(pvProp->pdispVal));
break;
case ADSTYPE_REPLICAPOINTER :
pvProp->vt = VT_DISPATCH;
hr = get_ReplicaPointer(&(pvProp->pdispVal));
break;
case ADSTYPE_FAXNUMBER :
pvProp->vt = VT_DISPATCH;
hr = get_FaxNumber(&(pvProp->pdispVal));
break;
case ADSTYPE_EMAIL :
pvProp->vt = VT_DISPATCH;
hr = get_Email(&(pvProp->pdispVal));
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR :
pvProp->vt = VT_DISPATCH;
hr = get_SecurityDescriptor(&(pvProp->pdispVal));
if (hr == E_ADS_CANT_CONVERT_DATATYPE) {
//
// Try and see if it is an OctetString needed as SecDesc
//
if (_ADsValue.dwType == ADSTYPE_OCTET_STRING) {
hr = getSecurityDescriptorFromOctStr(pvProp);
}
}
break;
case ADSTYPE_DN_WITH_BINARY:
pvProp->vt = VT_DISPATCH;
hr = getDNWithBinary(&(pvProp->pdispVal));
break;
case ADSTYPE_DN_WITH_STRING:
pvProp->vt = VT_DISPATCH;
hr = getDNWithString(&(pvProp->pdispVal));
break;
case ADSTYPE_UNKNOWN :
hr = E_ADS_CANT_CONVERT_DATATYPE;
break;
default:
// We should never be here
hr = E_ADS_BAD_PARAMETER;
break;
}
error:
RRETURN(hr);
}
STDMETHODIMP
CPropertyValue::PutObjectProperty(
THIS_ long lnControlCode,
VARIANT varObj
)
{
HRESULT hr = S_OK;
VARIANT *pvVar = &varObj;
if (lnControlCode == ADSTYPE_UNKNOWN
|| lnControlCode == ADSTYPE_INVALID) {
BAIL_ON_FAILURE(hr=E_ADS_BAD_PARAMETER);
}
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(&varObj);
}
switch (lnControlCode) {
case ADSTYPE_INVALID:
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
break;
case ADSTYPE_DN_STRING :
if (pvVar->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_DNString(pvVar->bstrVal);
break;
case ADSTYPE_CASE_EXACT_STRING :
if (pvVar->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_CaseExactString(pvVar->bstrVal);
break;
case ADSTYPE_CASE_IGNORE_STRING :
if (pvVar->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_CaseIgnoreString(pvVar->bstrVal);
break;
case ADSTYPE_PRINTABLE_STRING :
if (pvVar->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_PrintableString(pvVar->bstrVal);
break;
case ADSTYPE_NUMERIC_STRING :
if (pvVar->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_NumericString(pvVar->bstrVal);
break;
case ADSTYPE_BOOLEAN :
if (pvVar->vt != VT_BOOL) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Boolean((pvVar->boolVal == VARIANT_TRUE) ? TRUE : FALSE);
break;
case ADSTYPE_INTEGER :
if (pvVar->vt != VT_I4) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Integer(pvVar->lVal);
break;
case ADSTYPE_OCTET_STRING :
hr = put_OctetString(*pvVar);
break;
case ADSTYPE_PROV_SPECIFIC :
hr = putProvSpecific(varObj);
break;
case ADSTYPE_UTC_TIME :
if (pvVar->vt != VT_DATE) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_UTCTime(pvVar->date);
break;
case ADSTYPE_LARGE_INTEGER :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_LargeInteger(pvVar->pdispVal);
break;
case ADSTYPE_OBJECT_CLASS :
hr = E_ADS_CANT_CONVERT_DATATYPE;
break;
case ADSTYPE_CASEIGNORE_LIST :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_CaseIgnoreList(pvVar->pdispVal);
break;
case ADSTYPE_OCTET_LIST :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_OctetList(pvVar->pdispVal);
break;
case ADSTYPE_PATH :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Path(pvVar->pdispVal);
break;
case ADSTYPE_POSTALADDRESS :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_PostalAddress(pvVar->pdispVal);
break;
case ADSTYPE_TIMESTAMP :
if (pvVar->vt != VT_DISPATCH){
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Timestamp(pvVar->pdispVal);
break;
case ADSTYPE_BACKLINK :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_BackLink(pvVar->pdispVal);
break;
case ADSTYPE_TYPEDNAME :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_TypedName(pvVar->pdispVal);
break;
case ADSTYPE_HOLD :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Hold(pvVar->pdispVal);
break;
case ADSTYPE_NETADDRESS :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_NetAddress(pvVar->pdispVal);
break;
case ADSTYPE_REPLICAPOINTER :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_ReplicaPointer(pvVar->pdispVal);
break;
case ADSTYPE_FAXNUMBER :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_FaxNumber(pvVar->pdispVal);
break;
case ADSTYPE_EMAIL :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_Email(pvVar->pdispVal);
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = put_SecurityDescriptor(pvVar->pdispVal);
break;
case ADSTYPE_DN_WITH_BINARY :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = putDNWithBinary(pvVar->pdispVal);
break;
case ADSTYPE_DN_WITH_STRING :
if (pvVar->vt != VT_DISPATCH) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = putDNWithString(pvVar->pdispVal);
break;
case ADSTYPE_UNKNOWN :
hr = E_ADS_CANT_CONVERT_DATATYPE;
break;
default:
hr = E_ADS_BAD_PARAMETER;
break;
}
error:
RRETURN (hr);
}