able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/nwnds/cexsyn.cxx

2541 lines
47 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "nds.hxx"
#pragma hdrstop
//////////////////////////////////////////////////////////////////////////
HRESULT
ConvertStringArrayToSafeBstrArray(
LPWSTR *prgszArray,
DWORD dwNumElement,
VARIANT *pvarSafeArray
)
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
long i;
BSTR bstrAddress;
if ((!prgszArray) || (!pvarSafeArray)) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
aBound.lLbound = 0;
aBound.cElements = dwNumElement;
aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
if ( aList == NULL ) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
for ( i = 0; i < (long)dwNumElement; i++ ) {
VARIANT v;
VariantInit(&v);
v.vt = VT_BSTR;
hr = ADsAllocString(
prgszArray[i],
&v.bstrVal
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayPutElement( aList, &i, &v);
BAIL_ON_FAILURE(hr);
VariantClear(&v);
}
V_VT(pvarSafeArray) = VT_ARRAY | VT_VARIANT;
V_ARRAY(pvarSafeArray) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
HRESULT
ConvertSafeBstrArrayToStringArray(
VARIANT varSafeArray,
LPWSTR **prgszArray,
PDWORD pdwNumElement
)
{
HRESULT hr = S_OK;
DWORD dwSLBound = 0;
DWORD dwSUBound = 0;
DWORD dwNumVariants = 0;
DWORD i = 0;
LPWSTR* rgszArray = NULL;
SAFEARRAY * pArray = NULL;
if ((!prgszArray ) || (!pdwNumElement)) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
*pdwNumElement = 0;
*prgszArray = NULL;
if(!((V_VT(&varSafeArray) & VT_VARIANT) && V_ISARRAY(&varSafeArray)))
RRETURN(E_FAIL);
//
// This handles by-ref and regular SafeArrays.
//
if (V_VT(&varSafeArray) & VT_BYREF)
pArray = *(V_ARRAYREF(&varSafeArray));
else
pArray = V_ARRAY(&varSafeArray);
//
// Check that there is only one dimension in this array
//
if (pArray->cDims != 1) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
//
// Check that there is at least one element in this array
//
if (pArray->rgsabound[0].cElements == 0){
RRETURN(S_OK); // Return success and null array
}
//
// We know that this is a valid single dimension array
//
hr = SafeArrayGetLBound(pArray,
1,
(long FAR *)&dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(pArray,
1,
(long FAR *)&dwSUBound
);
BAIL_ON_FAILURE(hr);
dwNumVariants = dwSUBound - dwSLBound + 1;
rgszArray = (LPWSTR*)AllocADsMem(
sizeof(LPWSTR)*dwNumVariants
);
if (!rgszArray) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
if ((V_VT(&varSafeArray) & VT_VARIANT) == VT_BSTR) {
BSTR bstrElement;
for (i = dwSLBound; i <= dwSUBound; i++) {
hr = SafeArrayGetElement(pArray,
(long FAR *)&i,
&bstrElement
);
BAIL_ON_FAILURE(hr);
rgszArray[i-dwSLBound] = AllocADsStr(bstrElement);
if (!rgszArray[i-dwSLBound]) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
}
}
else {
VARIANT varElement;
for (i = dwSLBound; i <= dwSUBound; i++) {
VariantInit(&varElement);
hr = SafeArrayGetElement(pArray,
(long FAR *)&i,
&varElement
);
BAIL_ON_FAILURE(hr);
rgszArray[i-dwSLBound] = AllocADsStr(V_BSTR(&varElement));
if (!rgszArray[i-dwSLBound]) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
VariantClear(&varElement);
}
}
*prgszArray = rgszArray;
*pdwNumElement = dwNumVariants;
RRETURN(hr);
error:
if (rgszArray) {
FreeADsMem(rgszArray);
}
RRETURN(hr);
}
HRESULT
ConvertBinaryArrayToSafeVariantArray(
POctetString *prgArray,
DWORD dwNumElement,
VARIANT *pvarSafeArray
)
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
long i;
VARIANT var;
if ((!prgArray) || (!pvarSafeArray)) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
aBound.lLbound = 0;
aBound.cElements = dwNumElement;
aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
for ( i = 0; i < (long)dwNumElement; i++ )
{
hr = BinaryToVariant(
(prgArray[i])->Length,
(prgArray[i])->Value,
&var);
BAIL_ON_FAILURE(hr);
hr = SafeArrayPutElement( aList, &i, &var);
BAIL_ON_FAILURE(hr);
}
V_VT(pvarSafeArray) = VT_ARRAY | VT_VARIANT;
V_ARRAY(pvarSafeArray) = aList;
RRETURN(hr);
error:
if ( aList )
SafeArrayDestroy( aList );
RRETURN(hr);
}
HRESULT
ConvertSafeVariantArrayToBinaryArray(
VARIANT varSafeArray,
POctetString **prgArray,
PDWORD pdwNumElement
)
{
HRESULT hr = S_OK;
DWORD dwSLBound = 0;
DWORD dwSUBound = 0;
LONG cIterations = 0;
DWORD dwNumVariants = 0;
DWORD i = 0;
POctetString *rgArray = NULL;
SAFEARRAY * pArray = NULL;
VARIANT var;
if ((!prgArray ) || (!pdwNumElement)) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
*pdwNumElement = 0;
*prgArray = NULL;
if(!((V_VT(&varSafeArray) & VT_VARIANT) && V_ISARRAY(&varSafeArray)))
RRETURN(E_FAIL);
//
// This handles by-ref and regular SafeArrays.
//
if (V_VT(&varSafeArray) & VT_BYREF)
pArray = *(V_ARRAYREF(&varSafeArray));
else
pArray = V_ARRAY(&varSafeArray);
//
// Check that there is only one dimension in this array
//
if (pArray->cDims != 1) {
hr = E_FAIL;
BAIL_ON_FAILURE(hr);
}
//
// Check that there is at least one element in this array
//
if (pArray->rgsabound[0].cElements == 0){
RRETURN(S_OK); // Return success and null array
}
//
// We know that this is a valid single dimension array
//
hr = SafeArrayGetLBound(pArray,
1,
(long FAR *)&dwSLBound
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(pArray,
1,
(long FAR *)&dwSUBound
);
BAIL_ON_FAILURE(hr);
dwNumVariants = dwSUBound - dwSLBound + 1;
rgArray = (POctetString*)AllocADsMem(
sizeof(POctetString)*dwNumVariants
);
if (!rgArray) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
for (i = dwSLBound; i <= dwSUBound; i++) {
rgArray[i-dwSLBound] = (POctetString)AllocADsMem(sizeof(OctetString));
if (!rgArray[i-dwSLBound]) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
rgArray[i-dwSLBound]->Value = NULL;
cIterations++;
VariantInit(&var);
hr = SafeArrayGetElement(pArray,
(long FAR *)&i,
&var
);
BAIL_ON_FAILURE(hr);
hr = VariantToBinary(
&var,
&(rgArray[i-dwSLBound]->Length),
&(rgArray[i-dwSLBound]->Value));
BAIL_ON_FAILURE(hr);
}
*prgArray = rgArray;
*pdwNumElement = dwNumVariants;
RRETURN(hr);
error:
if (rgArray) {
for (i = dwSLBound; i < dwSLBound + cIterations; i++) {
if (rgArray[i-dwSLBound]) {
if (rgArray[i-dwSLBound]->Value)
FreeADsMem(rgArray[i-dwSLBound]->Value);
FreeADsMem(rgArray[i-dwSLBound]);
}
}
FreeADsMem(rgArray);
}
RRETURN(hr);
}
DEFINE_IDispatch_Implementation(CCaseIgnoreList)
CCaseIgnoreList::CCaseIgnoreList():
_pDispMgr(NULL),
_rgszCaseIgnoreList(NULL),
_dwNumElement(0)
{
ENLIST_TRACKING(CCaseIgnoreList);
}
HRESULT
CCaseIgnoreList::CreateCaseIgnoreList(
REFIID riid,
void **ppvObj
)
{
CCaseIgnoreList FAR * pCaseIgnoreList = NULL;
HRESULT hr = S_OK;
hr = AllocateCaseIgnoreListObject(&pCaseIgnoreList);
BAIL_ON_FAILURE(hr);
hr = pCaseIgnoreList->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pCaseIgnoreList->Release();
RRETURN(hr);
error:
delete pCaseIgnoreList;
RRETURN(hr);
}
CCaseIgnoreList::~CCaseIgnoreList( )
{
delete _pDispMgr;
if (_rgszCaseIgnoreList) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgszCaseIgnoreList[i]) {
FreeADsStr(_rgszCaseIgnoreList[i]);
}
}
FreeADsMem(_rgszCaseIgnoreList);
}
}
STDMETHODIMP
CCaseIgnoreList::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsCaseIgnoreList FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsCaseIgnoreList))
{
*ppv = (IADsCaseIgnoreList FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsCaseIgnoreList FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CCaseIgnoreList::AllocateCaseIgnoreListObject(
CCaseIgnoreList ** ppCaseIgnoreList
)
{
CCaseIgnoreList FAR * pCaseIgnoreList = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pCaseIgnoreList = new CCaseIgnoreList();
if (pCaseIgnoreList == 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_IADsCaseIgnoreList,
(IADsCaseIgnoreList *)pCaseIgnoreList,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pCaseIgnoreList->_pDispMgr = pDispMgr;
*ppCaseIgnoreList = pCaseIgnoreList;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CCaseIgnoreList::get_CaseIgnoreList(THIS_ VARIANT FAR * pVarDestObject)
{
HRESULT hr = S_OK;
hr = ConvertStringArrayToSafeBstrArray(
_rgszCaseIgnoreList,
_dwNumElement,
pVarDestObject);
RRETURN(hr);
}
STDMETHODIMP
CCaseIgnoreList::put_CaseIgnoreList(THIS_ VARIANT VarSrcObject)
{
HRESULT hr = S_OK;
if (_rgszCaseIgnoreList) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgszCaseIgnoreList[i]) {
FreeADsStr(_rgszCaseIgnoreList[i]);
}
}
FreeADsMem(_rgszCaseIgnoreList);
_rgszCaseIgnoreList = NULL;
_dwNumElement = 0;
}
hr = ConvertSafeBstrArrayToStringArray(
VarSrcObject,
&_rgszCaseIgnoreList,
&_dwNumElement);
RRETURN(hr);
}
DEFINE_IDispatch_Implementation(CFaxNumber)
CFaxNumber::CFaxNumber():
_pDispMgr(NULL),
_szTelephoneNumber(NULL),
_NumberOfBits(0),
_Parameters(NULL)
{
ENLIST_TRACKING(CFaxNumber);
}
HRESULT
CFaxNumber::CreateFaxNumber(
REFIID riid,
void **ppvObj
)
{
CFaxNumber FAR * pFaxNumber = NULL;
HRESULT hr = S_OK;
hr = AllocateFaxNumberObject(&pFaxNumber);
BAIL_ON_FAILURE(hr);
hr = pFaxNumber->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pFaxNumber->Release();
RRETURN(hr);
error:
delete pFaxNumber;
RRETURN(hr);
}
CFaxNumber::~CFaxNumber( )
{
delete _pDispMgr;
if (_szTelephoneNumber) {
FreeADsStr(_szTelephoneNumber);
}
if (_Parameters) {
FreeADsMem(_Parameters);
}
}
STDMETHODIMP
CFaxNumber::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsFaxNumber FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsFaxNumber))
{
*ppv = (IADsFaxNumber FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsFaxNumber FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CFaxNumber::AllocateFaxNumberObject(
CFaxNumber ** ppFaxNumber
)
{
CFaxNumber FAR * pFaxNumber = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pFaxNumber = new CFaxNumber();
if (pFaxNumber == 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_IADsFaxNumber,
(IADsFaxNumber *)pFaxNumber,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pFaxNumber->_pDispMgr = pDispMgr;
*ppFaxNumber = pFaxNumber;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CFaxNumber::get_Parameters(THIS_ VARIANT FAR * pVarDestObject)
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
aBound.lLbound = 0;
aBound.cElements = _NumberOfBits;
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,
_Parameters,
aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(pVarDestObject) = VT_ARRAY | VT_UI1;
V_ARRAY(pVarDestObject) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
STDMETHODIMP
CFaxNumber::put_Parameters(THIS_ VARIANT VarSrcObject)
{
HRESULT hr = S_OK;
LONG dwSLBound = 0;
LONG dwSUBound = 0;
CHAR HUGEP *pArray = NULL;
VARIANT *pVarSrcObject = &VarSrcObject;
if (_Parameters) {
FreeADsMem(_Parameters);
}
if( pVarSrcObject->vt != (VT_ARRAY | VT_UI1)) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = SafeArrayGetLBound(V_ARRAY(pVarSrcObject),
1,
(long FAR *) &dwSLBound );
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(pVarSrcObject),
1,
(long FAR *) &dwSUBound );
BAIL_ON_FAILURE(hr);
_Parameters =
(BYTE*) AllocADsMem( dwSUBound - dwSLBound + 1);
if ( _Parameters == NULL) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_NumberOfBits = dwSUBound - dwSLBound + 1;
hr = SafeArrayAccessData( V_ARRAY(pVarSrcObject),
(void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( _Parameters,
pArray,
_NumberOfBits);
SafeArrayUnaccessData( V_ARRAY(pVarSrcObject) );
error:
RRETURN(hr);
}
STDMETHODIMP
CFaxNumber::get_TelephoneNumber(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_szTelephoneNumber,
retval);
RRETURN(hr);
}
STDMETHODIMP
CFaxNumber::put_TelephoneNumber(THIS_ BSTR bstrTelephoneNumber)
{
if (_szTelephoneNumber) {
FreeADsStr(_szTelephoneNumber);
}
_szTelephoneNumber = AllocADsStr(bstrTelephoneNumber);
if (!_szTelephoneNumber) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
DEFINE_IDispatch_Implementation(CNetAddress)
CNetAddress::CNetAddress():
_pDispMgr(NULL),
_dwAddressType(0),
_dwAddressLength(0),
_pbAddress(NULL)
{
ENLIST_TRACKING(CNetAddress);
}
HRESULT
CNetAddress::CreateNetAddress(
REFIID riid,
void **ppvObj
)
{
CNetAddress FAR * pNetAddress = NULL;
HRESULT hr = S_OK;
hr = AllocateNetAddressObject(&pNetAddress);
BAIL_ON_FAILURE(hr);
hr = pNetAddress->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pNetAddress->Release();
RRETURN(hr);
error:
delete pNetAddress;
RRETURN(hr);
}
CNetAddress::~CNetAddress( )
{
delete _pDispMgr;
if (_pbAddress) {
FreeADsMem(_pbAddress);
}
}
STDMETHODIMP
CNetAddress::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsNetAddress FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsNetAddress))
{
*ppv = (IADsNetAddress FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsNetAddress FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CNetAddress::AllocateNetAddressObject(
CNetAddress ** ppNetAddress
)
{
CNetAddress FAR * pNetAddress = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pNetAddress = new CNetAddress();
if (pNetAddress == 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_IADsNetAddress,
(IADsNetAddress *)pNetAddress,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pNetAddress->_pDispMgr = pDispMgr;
*ppNetAddress = pNetAddress;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CNetAddress::get_AddressType(THIS_ long FAR * retval)
{
*retval = _dwAddressType;
RRETURN(S_OK);
}
STDMETHODIMP
CNetAddress::put_AddressType(THIS_ long lnAddressType)
{
_dwAddressType = lnAddressType;
RRETURN(S_OK);
}
STDMETHODIMP
CNetAddress::get_Address(THIS_ VARIANT FAR * pVarDestObject)
{
HRESULT hr = S_OK;
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
aBound.lLbound = 0;
aBound.cElements = _dwAddressLength;
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,
_pbAddress,
aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(pVarDestObject) = VT_ARRAY | VT_UI1;
V_ARRAY(pVarDestObject) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
STDMETHODIMP
CNetAddress::put_Address(THIS_ VARIANT VarSrcObject)
{
HRESULT hr = S_OK;
LONG dwSLBound = 0;
LONG dwSUBound = 0;
CHAR HUGEP *pArray = NULL;
VARIANT *pVarSrcObject = &VarSrcObject;
if (_pbAddress) {
FreeADsMem(_pbAddress);
}
if( pVarSrcObject->vt != (VT_ARRAY | VT_UI1)) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = SafeArrayGetLBound(V_ARRAY(pVarSrcObject),
1,
(long FAR *) &dwSLBound );
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(V_ARRAY(pVarSrcObject),
1,
(long FAR *) &dwSUBound );
BAIL_ON_FAILURE(hr);
_pbAddress =
(BYTE*) AllocADsMem( dwSUBound - dwSLBound + 1);
if ( _pbAddress == NULL)
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
_dwAddressLength = dwSUBound - dwSLBound + 1;
hr = SafeArrayAccessData( V_ARRAY(pVarSrcObject),
(void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( _pbAddress,
pArray,
_dwAddressLength );
SafeArrayUnaccessData( V_ARRAY(pVarSrcObject) );
error:
RRETURN(hr);
}
DEFINE_IDispatch_Implementation(COctetList)
COctetList::COctetList():
_pDispMgr(NULL),
_rgOctetList(NULL)
{
ENLIST_TRACKING(COctetList);
}
HRESULT
COctetList::CreateOctetList(
REFIID riid,
void **ppvObj
)
{
COctetList FAR * pOctetList = NULL;
HRESULT hr = S_OK;
hr = AllocateOctetListObject(&pOctetList);
BAIL_ON_FAILURE(hr);
hr = pOctetList->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pOctetList->Release();
RRETURN(hr);
error:
delete pOctetList;
RRETURN(hr);
}
COctetList::~COctetList( )
{
delete _pDispMgr;
if (_rgOctetList) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgOctetList[i]) {
FreeADsMem(_rgOctetList[i]);
}
}
FreeADsMem(_rgOctetList);
}
}
STDMETHODIMP
COctetList::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsOctetList FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsOctetList))
{
*ppv = (IADsOctetList FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsOctetList FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
COctetList::AllocateOctetListObject(
COctetList ** ppOctetList
)
{
COctetList FAR * pOctetList = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pOctetList = new COctetList();
if (pOctetList == 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_IADsOctetList,
(IADsOctetList *)pOctetList,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pOctetList->_pDispMgr = pDispMgr;
*ppOctetList = pOctetList;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
COctetList::get_OctetList(THIS_ VARIANT FAR * pVarDestObject)
{
HRESULT hr = S_OK;
hr = ConvertBinaryArrayToSafeVariantArray(
_rgOctetList,
_dwNumElement,
pVarDestObject);
RRETURN(hr);
}
STDMETHODIMP
COctetList::put_OctetList(THIS_ VARIANT VarSrcObject)
{
HRESULT hr = S_OK;
if (_rgOctetList) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgOctetList[i]) {
FreeADsMem(_rgOctetList[i]);
}
}
FreeADsMem(_rgOctetList);
}
hr = ConvertSafeVariantArrayToBinaryArray(
VarSrcObject,
&_rgOctetList,
&_dwNumElement);
RRETURN(hr);
}
DEFINE_IDispatch_Implementation(CEmail)
CEmail::CEmail():
_pDispMgr(NULL),
_szAddress(NULL),
_dwType(0)
{
ENLIST_TRACKING(CEmail);
}
HRESULT
CEmail::CreateEmail(
REFIID riid,
void **ppvObj
)
{
CEmail FAR * pEmail = NULL;
HRESULT hr = S_OK;
hr = AllocateEmailObject(&pEmail);
BAIL_ON_FAILURE(hr);
hr = pEmail->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pEmail->Release();
RRETURN(hr);
error:
delete pEmail;
RRETURN(hr);
}
CEmail::~CEmail( )
{
delete _pDispMgr;
if (_szAddress) {
FreeADsStr(_szAddress);
}
}
STDMETHODIMP
CEmail::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsEmail FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsEmail))
{
*ppv = (IADsEmail FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsEmail FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CEmail::AllocateEmailObject(
CEmail ** ppEmail
)
{
CEmail FAR * pEmail = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pEmail = new CEmail();
if (pEmail == 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_IADsEmail,
(IADsEmail *)pEmail,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pEmail->_pDispMgr = pDispMgr;
*ppEmail = pEmail;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CEmail::get_Address(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_szAddress, retval);
RRETURN(hr);
}
STDMETHODIMP
CEmail::put_Address(THIS_ BSTR bstrAddress)
{
if (!bstrAddress) {
RRETURN(E_FAIL);
}
if (_szAddress) {
FreeADsStr(_szAddress);
}
_szAddress = AllocADsStr(bstrAddress);
if (!_szAddress) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
STDMETHODIMP
CEmail::get_Type(THIS_ long FAR * retval)
{
*retval = _dwType;
RRETURN(S_OK);
}
STDMETHODIMP
CEmail::put_Type(THIS_ long lnType)
{
_dwType = lnType;
RRETURN(S_OK);
}
DEFINE_IDispatch_Implementation(CPath)
CPath::CPath():
_pDispMgr(NULL),
_dwType(0),
_lpVolumeName(NULL),
_lpPath(NULL)
{
ENLIST_TRACKING(CPath);
}
HRESULT
CPath::CreatePath(
REFIID riid,
void **ppvObj
)
{
CPath FAR * pPath = NULL;
HRESULT hr = S_OK;
hr = AllocatePathObject(&pPath);
BAIL_ON_FAILURE(hr);
hr = pPath->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pPath->Release();
RRETURN(hr);
error:
delete pPath;
RRETURN(hr);
}
CPath::~CPath( )
{
delete _pDispMgr;
if (_lpVolumeName) {
FreeADsStr(_lpVolumeName);
}
if (_lpPath) {
FreeADsStr(_lpPath);
}
}
STDMETHODIMP
CPath::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsPath FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsPath))
{
*ppv = (IADsPath FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsPath FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CPath::AllocatePathObject(
CPath ** ppPath
)
{
CPath FAR * pPath = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pPath = new CPath();
if (pPath == 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_IADsPath,
(IADsPath *)pPath,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pPath->_pDispMgr = pDispMgr;
*ppPath = pPath;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CPath::get_Type(THIS_ long FAR * retval)
{
*retval = _dwType;
RRETURN(S_OK);
}
STDMETHODIMP
CPath::put_Type(THIS_ long lnType)
{
_dwType = lnType;
RRETURN(S_OK);
}
STDMETHODIMP
CPath::get_VolumeName(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpVolumeName, retval);
RRETURN(hr);
}
STDMETHODIMP
CPath::put_VolumeName(THIS_ BSTR bstrVolumeName)
{
if (!bstrVolumeName) {
RRETURN(E_FAIL);
}
if (_lpVolumeName) {
FreeADsStr(_lpVolumeName);
}
_lpVolumeName= AllocADsStr(bstrVolumeName);
if (!_lpVolumeName) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
STDMETHODIMP
CPath::get_Path(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpPath, retval);
RRETURN(hr);
}
STDMETHODIMP
CPath::put_Path(THIS_ BSTR bstrPath)
{
if (!bstrPath) {
RRETURN(E_FAIL);
}
if (_lpPath) {
FreeADsStr(_lpPath);
}
_lpPath= AllocADsStr(bstrPath);
if (!_lpPath) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
//////////////////////////////////////////////////////////////////////////
DEFINE_IDispatch_Implementation(CReplicaPointer)
CReplicaPointer::CReplicaPointer():
_pDispMgr(NULL),
_lpServerName(NULL),
_dwReplicaType(0),
_dwReplicaNumber(0),
_dwCount(0)
{
ENLIST_TRACKING(CReplicaPointer);
_ReplicaAddressHints.AddressType = 0;
_ReplicaAddressHints.AddressLength = 0;
_ReplicaAddressHints.Address = NULL;
}
HRESULT
CReplicaPointer::CreateReplicaPointer(
REFIID riid,
void **ppvObj
)
{
CReplicaPointer FAR * pReplicaPointer = NULL;
HRESULT hr = S_OK;
hr = AllocateReplicaPointerObject(&pReplicaPointer);
BAIL_ON_FAILURE(hr);
hr = pReplicaPointer->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pReplicaPointer->Release();
RRETURN(hr);
error:
delete pReplicaPointer;
RRETURN(hr);
}
CReplicaPointer::~CReplicaPointer( )
{
delete _pDispMgr;
if (_lpServerName) {
FreeADsStr(_lpServerName);
}
if (_ReplicaAddressHints.Address) {
FreeADsMem(_ReplicaAddressHints.Address);
}
}
STDMETHODIMP
CReplicaPointer::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsReplicaPointer FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsReplicaPointer))
{
*ppv = (IADsReplicaPointer FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsReplicaPointer FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CReplicaPointer::AllocateReplicaPointerObject(
CReplicaPointer ** ppReplicaPointer
)
{
CReplicaPointer FAR * pReplicaPointer = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pReplicaPointer = new CReplicaPointer();
if (pReplicaPointer == 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_IADsReplicaPointer,
(IADsReplicaPointer *)pReplicaPointer,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pReplicaPointer->_pDispMgr = pDispMgr;
*ppReplicaPointer = pReplicaPointer;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CReplicaPointer::get_ReplicaType(THIS_ long FAR * retval)
{
*retval = _dwReplicaType;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::put_ReplicaType(THIS_ long lnReplicaType)
{
_dwReplicaType = lnReplicaType;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::get_ReplicaNumber(THIS_ long FAR * retval)
{
*retval = _dwReplicaNumber;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::put_ReplicaNumber(THIS_ long lnReplicaNumber)
{
_dwReplicaNumber = lnReplicaNumber;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::get_Count(THIS_ long FAR * retval)
{
*retval = _dwCount;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::put_Count(THIS_ long lnCount)
{
_dwCount = lnCount;
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::get_ServerName(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpServerName, retval);
RRETURN(hr);
}
STDMETHODIMP
CReplicaPointer::put_ServerName(THIS_ BSTR bstrServerName)
{
if (!bstrServerName) {
RRETURN(E_FAIL);
}
if (_lpServerName) {
FreeADsStr(_lpServerName);
}
_lpServerName= AllocADsStr(bstrServerName);
if (!_lpServerName) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
STDMETHODIMP
CReplicaPointer::get_ReplicaAddressHints(THIS_ VARIANT* pValAddress)
{
HRESULT hr = S_OK;
NDSOBJECT object;
memcpy(&object.NdsValue.value_12,
&_ReplicaAddressHints,
sizeof(NDS_ASN1_TYPE_12));
hr = NdsTypeToVarTypeCopyNDSSynId12(
&object,
pValAddress
);
RRETURN(hr);
}
STDMETHODIMP
CReplicaPointer::put_ReplicaAddressHints(THIS_ VARIANT ValAddress)
{
HRESULT hr;
NDSOBJECT object;
if (_ReplicaAddressHints.Address) {
FreeADsMem(_ReplicaAddressHints.Address);
}
hr = VarTypeToNdsTypeCopyNDSSynId12(
&ValAddress,
&object
);
BAIL_ON_FAILURE(hr);
memcpy(&_ReplicaAddressHints,
&object.NdsValue.value_12,
sizeof(NDS_ASN1_TYPE_12));
error:
RRETURN(hr);
}
DEFINE_IDispatch_Implementation(CTimestamp)
CTimestamp::CTimestamp():
_pDispMgr(NULL),
_dwWholeSeconds(0),
_dwEventID(0)
{
ENLIST_TRACKING(CTimestamp);
}
HRESULT
CTimestamp::CreateTimestamp(
REFIID riid,
void **ppvObj
)
{
CTimestamp FAR * pTime = NULL;
HRESULT hr = S_OK;
hr = AllocateTimestampObject(&pTime);
BAIL_ON_FAILURE(hr);
hr = pTime->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pTime->Release();
RRETURN(hr);
error:
delete pTime;
RRETURN(hr);
}
CTimestamp::~CTimestamp( )
{
delete _pDispMgr;
}
STDMETHODIMP
CTimestamp::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsTimestamp FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsTimestamp))
{
*ppv = (IADsTimestamp FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsTimestamp FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CTimestamp::AllocateTimestampObject(
CTimestamp ** ppTime
)
{
CTimestamp FAR * pTime = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pTime = new CTimestamp();
if (pTime == 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_IADsTimestamp,
(IADsTimestamp *)pTime,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pTime->_pDispMgr = pDispMgr;
*ppTime = pTime;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CTimestamp::get_WholeSeconds(THIS_ long FAR * retval)
{
*retval = _dwWholeSeconds;
RRETURN(S_OK);
}
STDMETHODIMP
CTimestamp::put_WholeSeconds(THIS_ long lnWholeSeconds)
{
_dwWholeSeconds = lnWholeSeconds;
RRETURN(S_OK);
}
STDMETHODIMP
CTimestamp::get_EventID(THIS_ long FAR * retval)
{
*retval = _dwEventID;
RRETURN(S_OK);
}
STDMETHODIMP
CTimestamp::put_EventID(THIS_ long lnEventID)
{
_dwEventID = lnEventID;
RRETURN(S_OK);
}
DEFINE_IDispatch_Implementation(CPostalAddress)
CPostalAddress::CPostalAddress():
_pDispMgr(NULL),
_rgszPostalAddress(NULL),
_dwNumElement(0)
{
ENLIST_TRACKING(CPostalAddress);
}
HRESULT
CPostalAddress::CreatePostalAddress(
REFIID riid,
void **ppvObj
)
{
CPostalAddress FAR * pPostalAddress = NULL;
HRESULT hr = S_OK;
hr = AllocatePostalAddressObject(&pPostalAddress);
BAIL_ON_FAILURE(hr);
hr = pPostalAddress->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pPostalAddress->Release();
RRETURN(hr);
error:
delete pPostalAddress;
RRETURN(hr);
}
CPostalAddress::~CPostalAddress( )
{
delete _pDispMgr;
if (_rgszPostalAddress) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgszPostalAddress[i]) {
FreeADsStr(_rgszPostalAddress[i]);
}
}
FreeADsMem(_rgszPostalAddress);
}
}
STDMETHODIMP
CPostalAddress::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsPostalAddress FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsPostalAddress))
{
*ppv = (IADsPostalAddress FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsPostalAddress FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CPostalAddress::AllocatePostalAddressObject(
CPostalAddress ** ppPostalAddress
)
{
CPostalAddress FAR * pPostalAddress = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pPostalAddress = new CPostalAddress();
if (pPostalAddress == 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_IADsPostalAddress,
(IADsPostalAddress *)pPostalAddress,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pPostalAddress->_pDispMgr = pDispMgr;
*ppPostalAddress = pPostalAddress;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CPostalAddress::get_PostalAddress(THIS_ VARIANT FAR * pVarDestObject)
{
HRESULT hr = S_OK;
hr = ConvertStringArrayToSafeBstrArray(
_rgszPostalAddress,
_dwNumElement,
pVarDestObject);
RRETURN(hr);
}
STDMETHODIMP
CPostalAddress::put_PostalAddress(THIS_ VARIANT VarSrcObject)
{
HRESULT hr = S_OK;
SAFEARRAY * pArray = NULL;
if (_rgszPostalAddress) {
long i;
for (i=0;i<(long)_dwNumElement;i++) {
if (_rgszPostalAddress[i]) {
FreeADsStr(_rgszPostalAddress[i]);
}
}
FreeADsMem(_rgszPostalAddress);
}
//
// Make sure it has 6 elements
//
if(!((V_VT(&VarSrcObject) & VT_VARIANT) && V_ISARRAY(&VarSrcObject)))
RRETURN(E_FAIL);
if (V_VT(&VarSrcObject) & VT_BYREF)
pArray = *(V_ARRAYREF(&VarSrcObject));
else
pArray = V_ARRAY(&VarSrcObject);
if ((pArray->rgsabound[0].cElements > 6) || (pArray->rgsabound[0].cElements <= 0)){
RRETURN(E_FAIL);
}
hr = ConvertSafeBstrArrayToStringArray(
VarSrcObject,
&_rgszPostalAddress,
&_dwNumElement);
RRETURN(hr);
}
//////////////////////////////////////////////////////////////////////////
DEFINE_IDispatch_Implementation(CBackLink)
CBackLink::CBackLink():
_pDispMgr(NULL),
_lpObjectName(NULL),
_dwRemoteID(0)
{
ENLIST_TRACKING(CBackLink);
}
HRESULT
CBackLink::CreateBackLink(
REFIID riid,
void **ppvObj
)
{
CBackLink FAR * pBackLink = NULL;
HRESULT hr = S_OK;
hr = AllocateBackLinkObject(&pBackLink);
BAIL_ON_FAILURE(hr);
hr = pBackLink->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pBackLink->Release();
RRETURN(hr);
error:
delete pBackLink;
RRETURN(hr);
}
CBackLink::~CBackLink( )
{
delete _pDispMgr;
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
}
STDMETHODIMP
CBackLink::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsBackLink FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsBackLink))
{
*ppv = (IADsBackLink FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsBackLink FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CBackLink::AllocateBackLinkObject(
CBackLink ** ppBackLink
)
{
CBackLink FAR * pBackLink = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pBackLink = new CBackLink();
if (pBackLink == 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_IADsBackLink,
(IADsBackLink *)pBackLink,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pBackLink->_pDispMgr = pDispMgr;
*ppBackLink = pBackLink;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CBackLink::get_RemoteID(THIS_ long FAR * retval)
{
*retval = _dwRemoteID;
RRETURN(S_OK);
}
STDMETHODIMP
CBackLink::put_RemoteID(THIS_ long lnRemoteID)
{
_dwRemoteID = lnRemoteID;
RRETURN(S_OK);
}
STDMETHODIMP
CBackLink::get_ObjectName(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpObjectName, retval);
RRETURN(hr);
}
STDMETHODIMP
CBackLink::put_ObjectName(THIS_ BSTR bstrObjectName)
{
if (!bstrObjectName) {
RRETURN(E_FAIL);
}
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
_lpObjectName= AllocADsStr(bstrObjectName);
if (!_lpObjectName) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
//////////////////////////////////////////////////////////////////////////
DEFINE_IDispatch_Implementation(CTypedName)
CTypedName::CTypedName():
_pDispMgr(NULL),
_lpObjectName(NULL),
_dwLevel(0),
_dwInterval(0)
{
ENLIST_TRACKING(CTypedName);
}
HRESULT
CTypedName::CreateTypedName(
REFIID riid,
void **ppvObj
)
{
CTypedName FAR * pTypedName = NULL;
HRESULT hr = S_OK;
hr = AllocateTypedNameObject(&pTypedName);
BAIL_ON_FAILURE(hr);
hr = pTypedName->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pTypedName->Release();
RRETURN(hr);
error:
delete pTypedName;
RRETURN(hr);
}
CTypedName::~CTypedName( )
{
delete _pDispMgr;
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
}
STDMETHODIMP
CTypedName::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsTypedName FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsTypedName))
{
*ppv = (IADsTypedName FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsTypedName FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CTypedName::AllocateTypedNameObject(
CTypedName ** ppTypedName
)
{
CTypedName FAR * pTypedName = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pTypedName = new CTypedName();
if (pTypedName == 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_IADsTypedName,
(IADsTypedName *)pTypedName,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pTypedName->_pDispMgr = pDispMgr;
*ppTypedName = pTypedName;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CTypedName::get_Interval(THIS_ long FAR * retval)
{
*retval = _dwInterval;
RRETURN(S_OK);
}
STDMETHODIMP
CTypedName::put_Interval(THIS_ long lnInterval)
{
_dwInterval = lnInterval;
RRETURN(S_OK);
}
STDMETHODIMP
CTypedName::get_Level(THIS_ long FAR * retval)
{
*retval = _dwLevel;
RRETURN(S_OK);
}
STDMETHODIMP
CTypedName::put_Level(THIS_ long lnLevel)
{
_dwLevel = lnLevel;
RRETURN(S_OK);
}
STDMETHODIMP
CTypedName::get_ObjectName(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpObjectName, retval);
RRETURN(hr);
}
STDMETHODIMP
CTypedName::put_ObjectName(THIS_ BSTR bstrObjectName)
{
if (!bstrObjectName) {
RRETURN(E_FAIL);
}
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
_lpObjectName= AllocADsStr(bstrObjectName);
if (!_lpObjectName) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
DEFINE_IDispatch_Implementation(CHold)
CHold::CHold():
_pDispMgr(NULL),
_lpObjectName(NULL),
_dwAmount(0)
{
ENLIST_TRACKING(CHold);
}
HRESULT
CHold::CreateHold(
REFIID riid,
void **ppvObj
)
{
CHold FAR * pHold = NULL;
HRESULT hr = S_OK;
hr = AllocateHoldObject(&pHold);
BAIL_ON_FAILURE(hr);
hr = pHold->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pHold->Release();
RRETURN(hr);
error:
delete pHold;
RRETURN(hr);
}
CHold::~CHold( )
{
delete _pDispMgr;
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
}
STDMETHODIMP
CHold::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsHold FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsHold))
{
*ppv = (IADsHold FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsHold FAR *) this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT
CHold::AllocateHoldObject(
CHold ** ppHold
)
{
CHold FAR * pHold = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
HRESULT hr = S_OK;
pHold = new CHold();
if (pHold == 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_IADsHold,
(IADsHold *)pHold,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pHold->_pDispMgr = pDispMgr;
*ppHold = pHold;
RRETURN(hr);
error:
delete pDispMgr;
RRETURN(hr);
}
STDMETHODIMP
CHold::get_Amount(THIS_ long FAR * retval)
{
*retval = _dwAmount;
RRETURN(S_OK);
}
STDMETHODIMP
CHold::put_Amount(THIS_ long lnAmount)
{
_dwAmount = lnAmount;
RRETURN(S_OK);
}
STDMETHODIMP
CHold::get_ObjectName(THIS_ BSTR FAR * retval)
{
HRESULT hr = S_OK;
hr = ADsAllocString(_lpObjectName, retval);
RRETURN(hr);
}
STDMETHODIMP
CHold::put_ObjectName(THIS_ BSTR bstrObjectName)
{
if (!bstrObjectName) {
RRETURN(E_FAIL);
}
if (_lpObjectName) {
FreeADsStr(_lpObjectName);
}
_lpObjectName= AllocADsStr(bstrObjectName);
if (!_lpObjectName) {
RRETURN(E_OUTOFMEMORY);
}
RRETURN(S_OK);
}
Reference in a new issue Copy permalink