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.
 
 
 
 
 
 

1934 lines
44 KiB

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995.
//
// File: adscopy.cxx
//
// Contents: NDS Object to Variant Copy Routines
//
// Functions:
//
// History: 25-Apr-96 KrishnaG Created.
//
//----------------------------------------------------------------------------
#include "oleds.hxx"
HRESULT
AdsClear(
PADSVALUE lpAdsValue
)
{
HRESULT hr = S_OK;
switch (lpAdsValue->dwType){
case ADSTYPE_DN_STRING:
FreeADsStr(lpAdsValue->DNString);
break;
case ADSTYPE_CASE_EXACT_STRING:
FreeADsStr(lpAdsValue->CaseExactString);
break;
case ADSTYPE_CASE_IGNORE_STRING:
FreeADsStr(lpAdsValue->CaseIgnoreString);
break;
case ADSTYPE_PRINTABLE_STRING:
FreeADsStr(lpAdsValue->PrintableString);
break;
case ADSTYPE_NUMERIC_STRING:
FreeADsStr(lpAdsValue->NumericString);
break;
case ADSTYPE_BOOLEAN:
break;
case ADSTYPE_INTEGER:
break;
case ADSTYPE_OCTET_STRING:
if (lpAdsValue->OctetString.lpValue) {
FreeADsMem(lpAdsValue->OctetString.lpValue);
}
break;
case ADSTYPE_PROV_SPECIFIC:
if (lpAdsValue->ProviderSpecific.lpValue) {
FreeADsMem(lpAdsValue->ProviderSpecific.lpValue);
}
break;
case ADSTYPE_UTC_TIME:
break;
case ADSTYPE_CASEIGNORE_LIST:
{
PADS_CASEIGNORE_LIST pCurrent = NULL;
PADS_CASEIGNORE_LIST pNext = NULL;
pNext = lpAdsValue->pCaseIgnoreList;
while (pNext) {
pCurrent = pNext;
pNext = pCurrent->Next;
if (pCurrent->String) {
FreeADsStr(pCurrent->String);
}
FreeADsMem(pCurrent);
}
break;
}
case ADSTYPE_FAXNUMBER:
if (lpAdsValue->pFaxNumber) {
if (lpAdsValue->pFaxNumber->Parameters) {
FreeADsMem(lpAdsValue->pFaxNumber->Parameters);
}
if (lpAdsValue->pFaxNumber->TelephoneNumber) {
FreeADsMem(lpAdsValue->pFaxNumber->TelephoneNumber);
}
FreeADsMem(lpAdsValue->pFaxNumber);
}
break;
case ADSTYPE_NETADDRESS:
if (lpAdsValue->pNetAddress) {
if (lpAdsValue->pNetAddress->Address) {
FreeADsMem(lpAdsValue->pNetAddress->Address);
}
FreeADsMem(lpAdsValue->pNetAddress);
}
break;
case ADSTYPE_OCTET_LIST:
{
PADS_OCTET_LIST pCurrent = NULL;
PADS_OCTET_LIST pNext = NULL;
pNext = lpAdsValue->pOctetList;
while (pNext) {
pCurrent = pNext;
pNext = pCurrent->Next;
if (pCurrent->Data) {
FreeADsMem(pCurrent->Data);
}
FreeADsMem(pCurrent);
}
break;
}
case ADSTYPE_EMAIL:
if (lpAdsValue->Email.Address) {
FreeADsStr(lpAdsValue->Email.Address);
}
break;
case ADSTYPE_PATH:
if (lpAdsValue->pPath) {
if (lpAdsValue->pPath->VolumeName) {
FreeADsStr(lpAdsValue->pPath->VolumeName);
}
if (lpAdsValue->pPath->Path) {
FreeADsStr(lpAdsValue->pPath->Path);
}
FreeADsMem(lpAdsValue->pPath);
}
break;
case ADSTYPE_REPLICAPOINTER:
if (lpAdsValue->pReplicaPointer) {
if (lpAdsValue->pReplicaPointer->ServerName) {
FreeADsStr(lpAdsValue->pReplicaPointer->ServerName );
}
if (lpAdsValue->pReplicaPointer->ReplicaAddressHints->Address) {
FreeADsMem(lpAdsValue->pReplicaPointer->ReplicaAddressHints->Address);
}
FreeADsMem(lpAdsValue->pReplicaPointer);
}
break;
case ADSTYPE_TIMESTAMP:
break;
case ADSTYPE_POSTALADDRESS:
{
long i;
if (lpAdsValue->pPostalAddress) {
for (i=0;i<6;i++) {
if (lpAdsValue->pPostalAddress->PostalAddress[i]) {
FreeADsStr(lpAdsValue->pPostalAddress->PostalAddress[i]);
}
}
FreeADsMem(lpAdsValue->pPostalAddress);
}
break;
}
case ADSTYPE_BACKLINK:
if (lpAdsValue->BackLink.ObjectName) {
FreeADsStr(lpAdsValue->BackLink.ObjectName);
}
break;
case ADSTYPE_TYPEDNAME:
if (lpAdsValue->pTypedName) {
if (lpAdsValue->pTypedName->ObjectName) {
FreeADsStr(lpAdsValue->pTypedName->ObjectName);
}
FreeADsMem(lpAdsValue->pTypedName);
}
break;
case ADSTYPE_HOLD:
if (lpAdsValue->Hold.ObjectName) {
FreeADsStr(lpAdsValue->Hold.ObjectName);
}
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR:
if (lpAdsValue->SecurityDescriptor.lpValue) {
FreeADsMem(lpAdsValue->SecurityDescriptor.lpValue);
}
break;
case ADSTYPE_OBJECT_CLASS:
FreeADsStr(lpAdsValue->ClassName);
break;
case ADSTYPE_DN_WITH_BINARY:
if (lpAdsValue->pDNWithBinary) {
if (lpAdsValue->pDNWithBinary->lpBinaryValue) {
FreeADsMem(lpAdsValue->pDNWithBinary->lpBinaryValue);
}
if (lpAdsValue->pDNWithBinary->pszDNString) {
FreeADsStr(lpAdsValue->pDNWithBinary->pszDNString);
}
FreeADsMem(lpAdsValue->pDNWithBinary);
}
break;
case ADSTYPE_DN_WITH_STRING:
if (lpAdsValue->pDNWithString) {
if (lpAdsValue->pDNWithString->pszStringValue) {
FreeADsMem(lpAdsValue->pDNWithString->pszStringValue);
}
if (lpAdsValue->pDNWithString->pszDNString) {
FreeADsStr(lpAdsValue->pDNWithString->pszDNString);
}
FreeADsMem(lpAdsValue->pDNWithString);
}
break;
default:
break;
}
memset(lpAdsValue, 0, sizeof(ADSVALUE));
RRETURN(S_OK);
}
HRESULT
AdsCopyDNString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_DN_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_DN_STRING;
lpAdsDestValue->DNString =
AllocADsStr(
lpAdsSrcValue->DNString
);
if (lpAdsSrcValue->DNString
&& !lpAdsDestValue->DNString) {
hr = E_OUTOFMEMORY;
}
RRETURN(hr);
}
HRESULT
AdsCopyCaseExactString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_CASE_EXACT_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_CASE_EXACT_STRING;
lpAdsDestValue->CaseExactString =
AllocADsStr(
lpAdsSrcValue->CaseExactString
);
if (lpAdsSrcValue->CaseExactString
&& !lpAdsDestValue->CaseExactString) {
hr = E_OUTOFMEMORY;
}
RRETURN(hr);
}
HRESULT
AdsCopyCaseIgnoreString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_CASE_IGNORE_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_CASE_IGNORE_STRING;
lpAdsDestValue->CaseIgnoreString =
AllocADsStr(
lpAdsSrcValue->CaseIgnoreString
);
if (lpAdsSrcValue->CaseIgnoreString
&& !lpAdsDestValue->CaseIgnoreString) {
hr = E_OUTOFMEMORY;
}
RRETURN(hr);
}
HRESULT
AdsCopyPrintableString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_PRINTABLE_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_PRINTABLE_STRING;
lpAdsDestValue->PrintableString =
AllocADsStr(
lpAdsSrcValue->PrintableString
);
if (lpAdsSrcValue->PrintableString
&& !lpAdsDestValue->PrintableString) {
hr = E_OUTOFMEMORY;
}
RRETURN(hr);
}
HRESULT
AdsCopyNumericString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_NUMERIC_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_NUMERIC_STRING;
lpAdsDestValue->NumericString =
AllocADsStr(
lpAdsSrcValue->NumericString
);
if (lpAdsSrcValue->NumericString
&& !lpAdsDestValue->NumericString) {
hr = E_OUTOFMEMORY;
}
RRETURN(hr);
}
HRESULT
AdsCopyBoolean(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_BOOLEAN){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_BOOLEAN;
lpAdsDestValue->Boolean =
lpAdsSrcValue->Boolean;
RRETURN(hr);
}
HRESULT
AdsCopyInteger(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_INTEGER){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_INTEGER;
lpAdsDestValue->Integer =
lpAdsSrcValue->Integer;
RRETURN(hr);
}
HRESULT
AdsCopyLargeInteger(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_LARGE_INTEGER){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_LARGE_INTEGER;
lpAdsDestValue->LargeInteger =
lpAdsSrcValue->LargeInteger;
RRETURN(hr);
}
HRESULT
AdsCopyOctetString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_OCTET_STRING){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_OCTET_STRING;
dwNumBytes = lpAdsSrcValue->OctetString.dwLength;
lpByteStream = (LPBYTE)AllocADsMem(dwNumBytes);
if (dwNumBytes && !lpByteStream) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(
lpByteStream,
lpAdsSrcValue->OctetString.lpValue,
dwNumBytes
);
lpAdsDestValue->OctetString.dwLength = dwNumBytes;
lpAdsDestValue->OctetString.lpValue = lpByteStream;
error :
RRETURN(hr);
}
HRESULT
AdsCopyProvSpecific(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_PROV_SPECIFIC){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_PROV_SPECIFIC;
dwNumBytes = lpAdsSrcValue->ProviderSpecific.dwLength;
lpByteStream = (LPBYTE)AllocADsMem(dwNumBytes);
if (!lpByteStream) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(
lpByteStream,
lpAdsSrcValue->ProviderSpecific.lpValue,
dwNumBytes
);
lpAdsDestValue->ProviderSpecific.dwLength = dwNumBytes;
lpAdsDestValue->ProviderSpecific.lpValue = lpByteStream;
RRETURN(hr);
error:
RRETURN(hr);
}
//
// Was overloaded to handle IDispatch.
// Removed overloading during code cleanup.
//
HRESULT
AdsCopyNTSecurityDescriptor(
PADSVALUE lpAdsSrcValue,
CPropertyValue * lpPropValue,
LPWSTR pszServerName,
CCredentials& Credentials,
BOOL fNTDSType
)
{
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
HRESULT hr = S_OK;
PADSVALUE lpAdsDestValue = lpPropValue->getADsValue();
VARIANT vVarSec;
VariantInit(&vVarSec);
if(lpAdsSrcValue->dwType != ADSTYPE_NT_SECURITY_DESCRIPTOR){
VariantClear(&vVarSec);
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_NT_SECURITY_DESCRIPTOR;
dwNumBytes = lpAdsSrcValue->OctetString.dwLength;
lpByteStream = (LPBYTE)AllocADsMem(dwNumBytes);
if (!lpByteStream) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(
lpByteStream,
lpAdsSrcValue->OctetString.lpValue,
dwNumBytes
);
lpAdsDestValue->OctetString.dwLength = dwNumBytes;
lpAdsDestValue->OctetString.lpValue = lpByteStream;
//
// Now attempt to conver to security descriptor
//
hr = ConvertSecDescriptorToVariant(
pszServerName,
Credentials,
lpAdsSrcValue->OctetString.lpValue,
&vVarSec,
fNTDSType
);
BAIL_ON_FAILURE(hr);
hr = lpPropValue->put_SecurityDescriptor(V_DISPATCH(&vVarSec));
BAIL_ON_FAILURE(hr);
VariantClear(&vVarSec);
RRETURN(hr);
error:
if(lpByteStream){
FreeADsMem(lpByteStream);
}
VariantClear(&vVarSec);
RRETURN(hr);
}
HRESULT
AdsCopyTime(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_UTC_TIME){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_UTC_TIME;
lpAdsDestValue->UTCTime = lpAdsSrcValue->UTCTime;
RRETURN(hr);
}
HRESULT
AdsCopyEmail(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_EMAIL){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_EMAIL;
lpAdsDestValue->Email.Type = lpAdsSrcValue->Email.Type;
lpAdsDestValue->Email.Address = AllocADsStr(lpAdsSrcValue->Email.Address);
if (!lpAdsDestValue->Email.Address) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
RRETURN(hr);
}
HRESULT
AdsCopyNetAddress(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
if(lpAdsSrcValue->dwType != ADSTYPE_NETADDRESS){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pNetAddress) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->dwType = ADSTYPE_NETADDRESS;
lpAdsDestValue->pNetAddress = (PADS_NETADDRESS)AllocADsMem(sizeof(ADS_NETADDRESS));
if (!lpAdsDestValue->pNetAddress) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pNetAddress->AddressType = lpAdsSrcValue->pNetAddress->AddressType;
dwNumBytes = lpAdsSrcValue->pNetAddress->AddressLength;
lpByteStream = (LPBYTE)AllocADsMem(dwNumBytes);
if (!lpByteStream) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
memcpy(
lpByteStream,
lpAdsSrcValue->pNetAddress->Address,
dwNumBytes
);
lpAdsDestValue->pNetAddress->AddressLength = dwNumBytes;
lpAdsDestValue->pNetAddress->Address = lpByteStream;
RRETURN(hr);
error:
if(lpAdsDestValue->pNetAddress) {
FreeADsMem(lpAdsDestValue->pNetAddress);
}
RRETURN(hr);
}
HRESULT
AdsCopyOctetList(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
PADS_OCTET_LIST pCurrent = NULL;
PADS_OCTET_LIST pResult = NULL;
PADS_OCTET_LIST pNext = NULL;
if(lpAdsSrcValue->dwType != ADSTYPE_OCTET_LIST){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pOctetList) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->dwType = ADSTYPE_OCTET_LIST;
lpAdsDestValue->pOctetList = (PADS_OCTET_LIST)AllocADsMem(sizeof(ADS_OCTET_LIST));
if (!lpAdsDestValue->pOctetList) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pCurrent = lpAdsSrcValue->pOctetList;
pResult = lpAdsDestValue->pOctetList;
hr = CopyOctetString(
pCurrent->Length,
pCurrent->Data,
&pResult->Length,
&pResult->Data);
BAIL_ON_FAILURE(hr);
while (pCurrent->Next) {
pResult->Next = (PADS_OCTET_LIST)AllocADsMem(
sizeof(ADS_OCTET_LIST));
if (!pResult->Next) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pResult = pResult->Next;
pCurrent = pCurrent->Next;
hr = CopyOctetString(
pCurrent->Length,
pCurrent->Data,
&pResult->Length,
&pResult->Data);
BAIL_ON_FAILURE(hr);
}
pResult->Next = NULL;
RRETURN(hr);
error:
pResult = lpAdsDestValue->pOctetList;
while ( pResult) {
pNext = pResult->Next;
FreeADsMem(pResult);
pResult = pNext;
}
RRETURN(hr);
}
HRESULT
AdsCopyCaseIgnoreList(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
PADS_CASEIGNORE_LIST pCurrent = NULL;
PADS_CASEIGNORE_LIST pResult = NULL;
PADS_CASEIGNORE_LIST pNext = NULL;
if(lpAdsSrcValue->dwType != ADSTYPE_CASEIGNORE_LIST){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pCaseIgnoreList) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->pCaseIgnoreList = (PADS_CASEIGNORE_LIST)AllocADsMem(sizeof(ADS_CASEIGNORE_LIST));
if (!lpAdsDestValue->pCaseIgnoreList) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->dwType = ADSTYPE_CASEIGNORE_LIST;
pCurrent = lpAdsSrcValue->pCaseIgnoreList;
pResult = lpAdsDestValue->pCaseIgnoreList;
pResult->String = AllocADsStr(pCurrent->String);
if (!pResult->String) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
while (pCurrent->Next) {
pResult->Next = (PADS_CASEIGNORE_LIST)AllocADsMem(
sizeof(ADS_CASEIGNORE_LIST));
if (!pResult->Next) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pResult = pResult->Next;
pCurrent = pCurrent->Next;
pResult->String = AllocADsStr(pCurrent->String);
if (!pResult->String) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
}
pResult->Next = NULL;
RRETURN(hr);
error:
pResult = lpAdsDestValue->pCaseIgnoreList;
while ( pResult) {
pNext = pResult->Next;
if (pResult->String) {
FreeADsStr(pResult->String);
}
FreeADsMem(pResult);
pResult = pNext;
}
RRETURN(hr);
}
HRESULT
AdsCopyPath(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_PATH){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pPath) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->dwType = ADSTYPE_PATH;
lpAdsDestValue->pPath = (PADS_PATH)AllocADsMem(sizeof(ADS_PATH));
if (!lpAdsDestValue->pPath) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pPath->Type = lpAdsSrcValue->pPath->Type;
lpAdsDestValue->pPath->VolumeName = AllocADsStr(lpAdsSrcValue->pPath->VolumeName);
if (!lpAdsDestValue->pPath->VolumeName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pPath->Path = AllocADsStr(lpAdsSrcValue->pPath->Path);
if (!lpAdsDestValue->pPath->Path) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
RRETURN(hr);
error:
if (lpAdsDestValue->pPath) {
if (lpAdsDestValue->pPath->VolumeName) {
FreeADsStr(lpAdsDestValue->pPath->VolumeName);
}
FreeADsMem(lpAdsDestValue->pPath);
}
RRETURN(hr);
}
HRESULT
AdsCopyPostalAddress(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
long i;
if(lpAdsSrcValue->dwType != ADSTYPE_POSTALADDRESS){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pPostalAddress) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->pPostalAddress = (PADS_POSTALADDRESS)AllocADsMem(sizeof(ADS_POSTALADDRESS));
if (!lpAdsDestValue->pPostalAddress) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->dwType = ADSTYPE_POSTALADDRESS;
for (i=0;i<6;i++) {
lpAdsDestValue->pPostalAddress->PostalAddress[i] = AllocADsStr(lpAdsSrcValue->pPostalAddress->PostalAddress[i]);
if (!lpAdsDestValue->pPostalAddress->PostalAddress[i]) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
}
RRETURN(hr);
error:
if (lpAdsDestValue->pPostalAddress) {
//
// Ideally I would need to loop only until i<5
// Being extra cautious over here in case some other code gets
// added after the for loop that returns an error which would
// bring us over here
//
for (i=0;i<6;i++) {
if (lpAdsDestValue->pPostalAddress->PostalAddress[i]) {
FreeADsStr(lpAdsDestValue->pPostalAddress->PostalAddress[i]);
}
}
FreeADsMem(lpAdsDestValue->pPostalAddress);
}
RRETURN(hr);
}
HRESULT
AdsCopyBackLink(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_BACKLINK){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_BACKLINK;
lpAdsDestValue->BackLink.RemoteID = lpAdsSrcValue->BackLink.RemoteID;
lpAdsDestValue->BackLink.ObjectName = AllocADsStr(lpAdsSrcValue->BackLink.ObjectName);
if (!lpAdsDestValue->BackLink.ObjectName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
RRETURN(hr);
}
HRESULT
AdsCopyTypedName(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
LPWSTR ObjectName;
DWORD Level;
DWORD Interval;
if(lpAdsSrcValue->dwType != ADSTYPE_TYPEDNAME){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pTypedName) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->dwType = ADSTYPE_TYPEDNAME;
lpAdsDestValue->pTypedName = (PADS_TYPEDNAME)AllocADsMem(sizeof(ADS_TYPEDNAME));
if (!lpAdsDestValue->pTypedName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pTypedName->Level = lpAdsSrcValue->pTypedName->Level;
lpAdsDestValue->pTypedName->Interval = lpAdsSrcValue->pTypedName->Interval;
lpAdsDestValue->pTypedName->ObjectName = AllocADsStr(lpAdsSrcValue->pTypedName->ObjectName);
if (!lpAdsDestValue->pTypedName->ObjectName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
RRETURN(hr);
error:
if (lpAdsDestValue->pTypedName) {
FreeADsMem(lpAdsDestValue->pTypedName);
}
RRETURN(hr);
}
HRESULT
AdsCopyHold(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_HOLD){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_HOLD;
lpAdsDestValue->Hold.Amount = lpAdsSrcValue->Hold.Amount;
lpAdsDestValue->Hold.ObjectName = AllocADsStr(lpAdsSrcValue->Hold.ObjectName);
if (!lpAdsDestValue->Hold.ObjectName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
error:
RRETURN(hr);
}
HRESULT
AdsCopyReplicaPointer(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
if(lpAdsSrcValue->dwType != ADSTYPE_REPLICAPOINTER){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pReplicaPointer) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->dwType = ADSTYPE_REPLICAPOINTER;
lpAdsDestValue->pReplicaPointer = (PADS_REPLICAPOINTER)AllocADsMem(sizeof(ADS_REPLICAPOINTER));
if (!lpAdsDestValue->pReplicaPointer) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pReplicaPointer->ReplicaType = lpAdsSrcValue->pReplicaPointer->ReplicaType;
lpAdsDestValue->pReplicaPointer->ReplicaNumber = lpAdsSrcValue->pReplicaPointer->ReplicaNumber;
lpAdsDestValue->pReplicaPointer->Count = lpAdsSrcValue->pReplicaPointer->Count;
lpAdsDestValue->pReplicaPointer->ServerName = AllocADsStr(lpAdsSrcValue->pReplicaPointer->ServerName);
if (!lpAdsDestValue->pReplicaPointer->ServerName) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
//
// Doing NetAddress
//
lpAdsDestValue->pReplicaPointer->ReplicaAddressHints = (PADS_NETADDRESS)AllocADsMem(sizeof(ADS_NETADDRESS));
if (!lpAdsDestValue->pReplicaPointer->ReplicaAddressHints) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->pReplicaPointer->ReplicaAddressHints->AddressType = lpAdsSrcValue->pReplicaPointer->ReplicaAddressHints->AddressType;
hr = CopyOctetString(
lpAdsSrcValue->pReplicaPointer->ReplicaAddressHints->AddressLength,
lpAdsSrcValue->pReplicaPointer->ReplicaAddressHints->Address,
&lpAdsDestValue->pReplicaPointer->ReplicaAddressHints->AddressLength,
&lpAdsDestValue->pReplicaPointer->ReplicaAddressHints->Address);
BAIL_ON_FAILURE(hr);
RRETURN(hr);
error:
if (lpAdsDestValue->pReplicaPointer) {
if (lpAdsDestValue->pReplicaPointer->ServerName) {
FreeADsStr(lpAdsDestValue->pReplicaPointer->ServerName);
}
if (lpAdsDestValue->pReplicaPointer->ReplicaAddressHints) {
FreeADsMem(lpAdsDestValue->pReplicaPointer->ReplicaAddressHints);
}
FreeADsMem(lpAdsDestValue->pReplicaPointer);
}
RRETURN(hr);
}
HRESULT
AdsCopyFaxNumber(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
LPBYTE lpByteStream = NULL;
DWORD dwNumBytes = 0;
if(lpAdsSrcValue->dwType != ADSTYPE_FAXNUMBER){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pFaxNumber) {
RRETURN(hr = E_FAIL);
}
lpAdsDestValue->pFaxNumber = (PADS_FAXNUMBER)AllocADsMem(sizeof(ADS_FAXNUMBER));
if (!lpAdsDestValue->pFaxNumber) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
lpAdsDestValue->dwType = ADSTYPE_FAXNUMBER;
dwNumBytes = lpAdsSrcValue->pFaxNumber->NumberOfBits;
lpByteStream = (LPBYTE)AllocADsMem(dwNumBytes);
if (!lpByteStream) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
memcpy(
lpByteStream,
lpAdsSrcValue->pFaxNumber->Parameters,
dwNumBytes
);
lpAdsDestValue->pFaxNumber->NumberOfBits = dwNumBytes;
lpAdsDestValue->pFaxNumber->Parameters = lpByteStream;
lpAdsDestValue->pFaxNumber->TelephoneNumber = AllocADsStr(lpAdsSrcValue->pFaxNumber->TelephoneNumber);
if (!lpAdsDestValue->pFaxNumber->TelephoneNumber) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
RRETURN(hr);
error:
if (lpAdsDestValue->pFaxNumber) {
FreeADsMem(lpAdsDestValue->pFaxNumber);
}
if (lpByteStream) {
FreeADsMem(lpByteStream);
}
RRETURN(hr);
}
HRESULT
AdsCopyNDSTimestamp(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
if(lpAdsSrcValue->dwType != ADSTYPE_TIMESTAMP){
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
lpAdsDestValue->dwType = ADSTYPE_TIMESTAMP;
lpAdsDestValue->Timestamp.WholeSeconds = lpAdsSrcValue->Timestamp.WholeSeconds;
lpAdsDestValue->Timestamp.EventID = lpAdsSrcValue->Timestamp.EventID;
RRETURN(hr);
}
HRESULT
AdsCopyDNWithBinary(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
PADS_DN_WITH_BINARY pDestDNBin = NULL;
PADS_DN_WITH_BINARY pSrcDNBin = NULL;
if (lpAdsSrcValue->dwType != ADSTYPE_DN_WITH_BINARY) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pDNWithBinary) {
//
// No source object so return
//
RRETURN(hr);
}
pSrcDNBin = lpAdsSrcValue->pDNWithBinary;
pDestDNBin = (PADS_DN_WITH_BINARY)
AllocADsMem(sizeof(ADS_DN_WITH_BINARY));
if (!pDestDNBin) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (pSrcDNBin->dwLength) {
//
// Copy the octet string over.
//
pDestDNBin->lpBinaryValue = (LPBYTE) AllocADsMem(pSrcDNBin->dwLength);
if (!pDestDNBin->lpBinaryValue) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pDestDNBin->dwLength = pSrcDNBin->dwLength;
memcpy(
pDestDNBin->lpBinaryValue,
pSrcDNBin->lpBinaryValue,
pSrcDNBin->dwLength
);
}
if (pSrcDNBin->pszDNString) {
//
// Copy the DNString value over
//
pDestDNBin->pszDNString = AllocADsStr(pSrcDNBin->pszDNString);
if (!pDestDNBin->pszDNString) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
lpAdsDestValue->pDNWithBinary = pDestDNBin;
lpAdsDestValue->dwType = ADSTYPE_DN_WITH_BINARY;
RRETURN(hr);
error:
if (pDestDNBin) {
//
// Clean up the mem for string and byte array
//
if (pDestDNBin->pszDNString) {
FreeADsStr(pDestDNBin->pszDNString);
}
if (pDestDNBin->lpBinaryValue) {
FreeADsMem(pDestDNBin->lpBinaryValue);
}
FreeADsMem(pDestDNBin);
}
RRETURN(hr);
}
HRESULT
AdsCopyDNWithString(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = S_OK;
PADS_DN_WITH_STRING pDestDNStr = NULL;
PADS_DN_WITH_STRING pSrcDNStr = NULL;
if (lpAdsSrcValue->dwType != ADSTYPE_DN_WITH_STRING) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
if (!lpAdsSrcValue->pDNWithString) {
//
// No source object so return
//
RRETURN(hr);
}
pSrcDNStr = lpAdsSrcValue->pDNWithString;
pDestDNStr = (PADS_DN_WITH_STRING)
AllocADsMem(sizeof(ADS_DN_WITH_STRING));
if (!pDestDNStr) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (pSrcDNStr->pszStringValue) {
//
// Copy the string over.
//
pDestDNStr->pszStringValue = AllocADsStr(pSrcDNStr->pszStringValue);
if (!pDestDNStr->pszStringValue) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
if (pSrcDNStr->pszDNString) {
//
// Copy the DNString value over
//
pDestDNStr->pszDNString = AllocADsStr(pSrcDNStr->pszDNString);
if (!pDestDNStr->pszDNString) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
lpAdsDestValue->pDNWithString = pDestDNStr;
lpAdsDestValue->dwType = ADSTYPE_DN_WITH_STRING;
RRETURN(hr);
error:
if (pDestDNStr) {
//
// Clean up the mem for string and byte array
//
if (pDestDNStr->pszDNString) {
FreeADsStr(pDestDNStr->pszDNString);
}
if (pDestDNStr->pszStringValue) {
FreeADsMem(pDestDNStr->pszStringValue);
}
FreeADsMem(pDestDNStr);
}
RRETURN(hr);
}
HRESULT
AdsCopy(
PADSVALUE lpAdsSrcValue,
PADSVALUE lpAdsDestValue
)
{
HRESULT hr = E_FAIL;
switch (lpAdsSrcValue->dwType){
case ADSTYPE_DN_STRING:
hr = AdsCopyDNString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_CASE_EXACT_STRING:
hr = AdsCopyCaseExactString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_CASE_IGNORE_STRING:
hr = AdsCopyCaseIgnoreString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_PRINTABLE_STRING:
hr = AdsCopyPrintableString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_NUMERIC_STRING:
hr = AdsCopyNumericString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_BOOLEAN:
hr = AdsCopyBoolean(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_INTEGER:
hr = AdsCopyInteger(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_LARGE_INTEGER:
hr = AdsCopyLargeInteger(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_OCTET_STRING:
hr = AdsCopyOctetString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_PROV_SPECIFIC:
hr = AdsCopyProvSpecific(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_UTC_TIME:
hr = AdsCopyTime(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_CASEIGNORE_LIST:
hr = AdsCopyCaseIgnoreList(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_FAXNUMBER:
hr = AdsCopyFaxNumber(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_NETADDRESS:
hr = AdsCopyNetAddress(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_OCTET_LIST:
hr = AdsCopyOctetList(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_EMAIL:
hr = AdsCopyEmail(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_PATH:
hr = AdsCopyPath(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_REPLICAPOINTER:
hr = AdsCopyReplicaPointer(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_TIMESTAMP:
hr = AdsCopyNDSTimestamp(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_POSTALADDRESS:
hr = AdsCopyPostalAddress(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_BACKLINK:
hr = AdsCopyBackLink(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_TYPEDNAME:
hr = AdsCopyTypedName(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_HOLD:
hr = AdsCopyHold(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_DN_WITH_BINARY:
hr = AdsCopyDNWithBinary(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_DN_WITH_STRING:
hr = AdsCopyDNWithString(
lpAdsSrcValue,
lpAdsDestValue
);
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR:
//
// This should be handled elsewhere not here !
//
ADsAssert(!"Invalid option to adscopy");
break;
default:
hr = E_FAIL;
break;
}
RRETURN(hr);
}
//
// This routine is typically used by GetPropertyItem calls.
//
HRESULT
AdsCopyADsValueToPropObj(
PADSVALUE lpAdsSrcValue,
CPropertyValue* lpPropObj,
LPWSTR pszServerName,
CCredentials* pCredentials,
BOOL fNTDSType
)
{
HRESULT hr = S_OK;
PADSVALUE lpAdsDestValue = lpPropObj->getADsValue();
CCredentials localCredentials(NULL, NULL, 0);
switch (lpAdsSrcValue->dwType){
case ADSTYPE_NT_SECURITY_DESCRIPTOR:
if (pCredentials) {
localCredentials = *pCredentials;
}
hr = AdsCopyNTSecurityDescriptor(
lpAdsSrcValue,
lpPropObj,
pszServerName,
localCredentials,
fNTDSType
);
break;
default:
hr = AdsCopy(
lpAdsSrcValue,
lpAdsDestValue
);
break;
}
RRETURN(hr);
}
//
// This routine is typically used from PutPropertyItem.
//
HRESULT
AdsCopyPropObjToADsValue(
CPropertyValue *lpPropObj,
PADSVALUE lpAdsDestValue,
LPWSTR pszServerName,
CCredentials* pCredentials,
BOOL fNTDSType
)
{
HRESULT hr = E_FAIL;
PADSVALUE lpAdsSrcValue = lpPropObj->getADsValue();
DWORD dwDataType = 0;
DWORD dwSDLength = 0;
PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
CCredentials locCredentials(NULL, NULL, 0);
IDispatch *pIDispatch = NULL;
IADsSecurityDescriptor *pIADsSecDesc = NULL;
switch (lpAdsSrcValue->dwType) {
case ADSTYPE_NT_SECURITY_DESCRIPTOR :
dwDataType = lpPropObj->getExtendedDataTypeInfo();
//
// if we have the octet blob send it back
//
if (dwDataType == CPropertyValue::VAL_IDISPATCH_SECDESC_ALL) {
hr = AdsCopyOctetString(
lpAdsSrcValue,
lpAdsDestValue
);
BAIL_ON_FAILURE(hr);
}
else if (dwDataType == CPropertyValue::VAL_IDISPATCH_SECDESC_ONLY) {
if (pCredentials) {
locCredentials = *pCredentials;
}
pIDispatch = lpPropObj->getDispatchPointer();
if (pIDispatch) {
hr = pIDispatch->QueryInterface(
IID_IADsSecurityDescriptor,
(void **) &pIADsSecDesc
);
BAIL_ON_FAILURE(hr);
}
hr = ConvertSecurityDescriptorToSecDes(
pszServerName,
locCredentials,
pIADsSecDesc,
&pSecurityDescriptor,
&dwSDLength,
fNTDSType
);
BAIL_ON_FAILURE(hr);
lpAdsDestValue->OctetString.lpValue
= (LPBYTE) AllocADsMem(dwSDLength);
if (!(lpAdsDestValue->OctetString.lpValue)) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(
lpAdsDestValue->OctetString.lpValue,
pSecurityDescriptor,
dwSDLength
);
lpAdsDestValue->dwType = ADSTYPE_OCTET_STRING;
lpAdsDestValue->OctetString.dwLength = dwSDLength;
} // secdesc idispatch only
break;
default:
hr = AdsCopy(
lpAdsSrcValue,
lpAdsDestValue
);
break;
} // end case
error :
//
// Needs to be executed in all cases, currently only ret is below
//
if (pIADsSecDesc) {
pIADsSecDesc->Release();
}
if (pSecurityDescriptor) {
FreeADsMem(pSecurityDescriptor);
}
RRETURN(hr);
}
HRESULT
PropVariantToAdsType(
PVARIANT pVariant,
DWORD dwNumVariant,
PADSVALUE *ppAdsValues,
PDWORD pdwNumValues
)
{
return(PropVariantToAdsType2(
pVariant,
dwNumVariant,
ppAdsValues,
pdwNumValues,
NULL, // serverName,
NULL, // pCredentials
TRUE // NTDS Type
));
}
HRESULT
PropVariantToAdsType2(
PVARIANT pVariant,
DWORD dwNumVariant,
PADSVALUE *ppAdsValues,
PDWORD pdwNumValues,
LPWSTR pszServerName,
CCredentials* pCredentials,
BOOL fNTDSType
)
{
DWORD i = 0;
VARIANT * pVar = NULL;
DWORD dwCount = 0;
IDispatch FAR * pDispatch = NULL;
IADsValue FAR * pPropValue = NULL;
PADSVALUE pADsValues = NULL;
HRESULT hr = S_OK;
LPWSTR pszUserName = NULL;
LPWSTR pszPassWord = NULL;
DWORD dwFlags = 0;
pADsValues = (PADSVALUE)AllocADsMem(dwNumVariant * sizeof(ADSVALUE));
if (!pADsValues) {
RRETURN(E_OUTOFMEMORY);
}
//
// If !pCredentials, use the initialized values as they
// represent an object with CCredentials(NULL, NULL, 0)
//
if (pCredentials) {
hr = pCredentials->GetUserName(&pszUserName);
BAIL_ON_FAILURE(hr);
hr = pCredentials->GetPassword(&pszPassWord);
BAIL_ON_FAILURE(hr);
dwFlags = pCredentials->GetAuthFlags();
}
for (i = 0; i < dwNumVariant; i++ ) {
pVar = pVariant + i;
pDispatch = V_DISPATCH(pVar);
hr = pDispatch->QueryInterface(
IID_IADsValue,
(void **)&pPropValue
);
CONTINUE_ON_FAILURE(hr);
hr = pPropValue->ConvertPropertyValueToADsValue2(
(pADsValues + dwCount),
pszServerName,
pszUserName,
pszPassWord,
dwFlags,
fNTDSType
);
pPropValue->Release();
BAIL_ON_FAILURE(hr);
dwCount++;
}
*ppAdsValues = pADsValues;
*pdwNumValues = dwCount;
error:
if (pszUserName) {
FreeADsStr(pszUserName);
}
if (pszPassWord) {
FreeADsStr(pszPassWord);
}
if (FAILED(hr) && pADsValues) {
FreeADsMem(pADsValues);
}
RRETURN(hr);
}
HRESULT
AdsTypeToPropVariant2(
PADSVALUE pAdsValues,
DWORD dwNumValues,
PVARIANT pVarDestObjects,
LPWSTR pszServerName,
CCredentials* pCredentials,
BOOL fNTDSType
)
{
long i = 0;
HRESULT hr = S_OK;
CPropertyValue * pAdsValue = NULL;
VariantInit( pVarDestObjects );
//
// The following are for handling are multi-value properties
//
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
aBound.lLbound = 0;
aBound.cElements = dwNumValues;
aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
for ( i = 0; i < (long)dwNumValues; i++ )
{
VARIANT v;
IDispatch FAR * pDispatch = NULL;
VariantInit(&v);
hr = CPropertyValue::AllocatePropertyValueObject(&pAdsValue);
BAIL_ON_FAILURE(hr);
hr = pAdsValue->ConvertADsValueToPropertyValue2(
pAdsValues + i,
pszServerName,
pCredentials,
fNTDSType
);
BAIL_ON_FAILURE(hr);
pAdsValue->QueryInterface(
IID_IDispatch,
(void **)&pDispatch
);
BAIL_ON_FAILURE(hr);
V_DISPATCH(&v) = pDispatch;
V_VT(&v) = VT_DISPATCH;
if (pAdsValue) {
pAdsValue->Release();
}
hr = SafeArrayPutElement( aList, &i, &v );
VariantClear(&v);
pDispatch = NULL;
BAIL_ON_FAILURE(hr);
}
V_VT(pVarDestObjects) = VT_ARRAY | VT_VARIANT;
V_ARRAY(pVarDestObjects) = aList;
RRETURN(S_OK);
error:
if ( aList )
SafeArrayDestroy( aList );
RRETURN(hr);
}
HRESULT
AdsTypeToPropVariant(
PADSVALUE pAdsValues,
DWORD dwNumValues,
PVARIANT pVarDestObjects
)
{
RRETURN( AdsTypeToPropVariant2(
pAdsValues,
dwNumValues,
pVarDestObjects,
NULL, // serverName
NULL, // pCredentials
TRUE // serverType
)
);
}
void
AdsFreeAdsValues(
PADSVALUE pAdsValues,
DWORD dwNumValues
)
{
LPBYTE pMem = NULL;
for ( DWORD i = 0; i < dwNumValues; i++ )
{
AdsClear(&pAdsValues[i]);
}
}