425 lines
10 KiB
C++
425 lines
10 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: helpers.cxx
|
|
//
|
|
// Contents: ADs C Wrappers (Helper functions)
|
|
//
|
|
// ADsBuildEnumerator
|
|
// ADsFreeEnumerator
|
|
// ADsEnumerateNext
|
|
// ADsBuildVarArrayStr
|
|
// ADsBuildVarArrayInt
|
|
//
|
|
// History:
|
|
// 1-March-1995 KrishnaG -- Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include "oleds.hxx"
|
|
#pragma hdrstop
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ADsBuildEnumerator
|
|
//
|
|
// Synopsis: C wrapper code to create an Enumerator object.
|
|
//
|
|
// Arguments: [pNetOleCollection] -- The input Collection object.
|
|
//
|
|
// [ppEnumVariant] -- The created Enumerator object.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
ADsBuildEnumerator(
|
|
IADsContainer *pADsContainer,
|
|
IEnumVARIANT * * ppEnumVariant
|
|
)
|
|
{
|
|
|
|
HRESULT hr;
|
|
IUnknown *pUnk = NULL;
|
|
|
|
//
|
|
// Get a new enumerator object.
|
|
//
|
|
|
|
hr = pADsContainer->get__NewEnum( &pUnk );
|
|
if (FAILED(hr)) {
|
|
|
|
goto Fail;
|
|
}
|
|
|
|
//
|
|
// QueryInterface the IUnknown pointer for an IEnumVARIANT interface,
|
|
//
|
|
|
|
hr = pUnk->QueryInterface(
|
|
IID_IEnumVARIANT,
|
|
(void FAR* FAR*)ppEnumVariant
|
|
);
|
|
if (FAILED(hr)) {
|
|
|
|
goto Fail;
|
|
}
|
|
|
|
//
|
|
// Release the IUnknown pointer.
|
|
//
|
|
|
|
pUnk->Release();
|
|
|
|
return(hr);
|
|
|
|
|
|
Fail:
|
|
|
|
if (pUnk) {
|
|
pUnk->Release();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ADsFreeEnumerator
|
|
//
|
|
// Synopsis: Frees an Enumerator object.
|
|
//
|
|
// Arguments: [pEnumerator] -- The Enumerator object to be freed.
|
|
//
|
|
// Returns: HRESULT
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
ADsFreeEnumerator(
|
|
IEnumVARIANT *pEnumVariant
|
|
)
|
|
{
|
|
|
|
HRESULT hr = E_ADS_BAD_PARAMETER;
|
|
|
|
ULONG uRefCount = 0;
|
|
|
|
if (pEnumVariant) {
|
|
uRefCount = pEnumVariant->Release();
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ADsEnumerateNext
|
|
//
|
|
// Synopsis: C wrapper code for IEnumVARIANT::Next
|
|
//
|
|
// Arguments: [pEnumVariant] -- Input enumerator object.
|
|
//
|
|
// [cElements] -- Number of elements to retrieve.
|
|
//
|
|
// [pvar] -- VARIANT array.
|
|
//
|
|
// [pcElementFetched] -- Number of elements fetched.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
ADsEnumerateNext(
|
|
IEnumVARIANT *pEnumVariant,
|
|
ULONG cElements,
|
|
VARIANT * pvar,
|
|
ULONG * pcElementsFetched
|
|
)
|
|
{
|
|
|
|
return(pEnumVariant->Next(cElements, pvar, pcElementsFetched));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ADsBuildVarArrayStr
|
|
//
|
|
// Synopsis: Build a variant array of strings
|
|
//
|
|
// Arguments: [lppPathNames] -- List of pathnames to be put in the array.
|
|
//
|
|
// [dwPathNames] -- Number of pathnames in the list.
|
|
//
|
|
// [ppvar] -- Pointer to a pointer of a Variant array.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
ADsBuildVarArrayStr(
|
|
LPWSTR * lppPathNames,
|
|
DWORD dwPathNames,
|
|
VARIANT * pVar
|
|
)
|
|
{
|
|
|
|
VARIANT v;
|
|
SAFEARRAYBOUND sabNewArray;
|
|
DWORD i;
|
|
SAFEARRAY *psa = NULL;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
|
|
if (!pVar) {
|
|
hr = E_ADS_BAD_PARAMETER;
|
|
goto Fail;
|
|
}
|
|
VariantInit(pVar);
|
|
|
|
sabNewArray.cElements = dwPathNames;
|
|
sabNewArray.lLbound = 0;
|
|
psa = SafeArrayCreate(VT_VARIANT, 1, &sabNewArray);
|
|
|
|
if (!psa) {
|
|
goto Fail;
|
|
}
|
|
|
|
for (i = 0; i < dwPathNames; i++) {
|
|
|
|
VariantInit(&v);
|
|
V_VT(&v) = VT_BSTR;
|
|
V_BSTR(&v) = SysAllocString(*(lppPathNames + i));
|
|
hr = SafeArrayPutElement(psa,
|
|
(long FAR *)&i,
|
|
&v
|
|
);
|
|
VariantClear( &v );
|
|
if (FAILED(hr)) {
|
|
goto Fail;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
V_VT(pVar) = VT_ARRAY | VT_VARIANT;
|
|
|
|
V_ARRAY(pVar) = psa;
|
|
|
|
return(ResultFromScode(S_OK));
|
|
|
|
|
|
Fail:
|
|
|
|
if (psa) {
|
|
SafeArrayDestroy(psa);
|
|
}
|
|
|
|
|
|
|
|
return(E_FAIL);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ADsBuildVarArrayInt
|
|
//
|
|
// Synopsis: Build a variant array of integers
|
|
//
|
|
// Arguments: [lppObjectTypes] -- List of object types to be put in the array.
|
|
//
|
|
// [dwObjectTypes] -- Number of object types in the list.
|
|
//
|
|
// [ppvar] -- Pointer to a pointer of a Variant array.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
ADsBuildVarArrayInt(
|
|
LPDWORD lpdwObjectTypes,
|
|
DWORD dwObjectTypes,
|
|
VARIANT * pVar
|
|
)
|
|
{
|
|
|
|
VARIANT v;
|
|
SAFEARRAYBOUND sabNewArray;
|
|
DWORD i;
|
|
SAFEARRAY *psa = NULL;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (!pVar) {
|
|
hr = E_ADS_BAD_PARAMETER;
|
|
goto Fail;
|
|
}
|
|
VariantInit(pVar);
|
|
|
|
sabNewArray.cElements = dwObjectTypes;
|
|
sabNewArray.lLbound = 0;
|
|
psa = SafeArrayCreate(VT_VARIANT, 1, &sabNewArray);
|
|
|
|
if (!psa) {
|
|
goto Fail;
|
|
}
|
|
|
|
for (i = 0; i < dwObjectTypes; i++) {
|
|
|
|
VariantInit(&v);
|
|
V_VT(&v) = VT_I4;
|
|
V_I4(&v) = *(lpdwObjectTypes + i);
|
|
hr = SafeArrayPutElement(psa,
|
|
(long FAR *)&i,
|
|
&v
|
|
);
|
|
VariantClear( &v );
|
|
if (FAILED(hr)) {
|
|
goto Fail;
|
|
}
|
|
}
|
|
|
|
|
|
V_VT(pVar) = VT_VARIANT | VT_ARRAY;
|
|
|
|
V_ARRAY(pVar) = psa;
|
|
|
|
return(ResultFromScode(S_OK));
|
|
|
|
|
|
Fail:
|
|
|
|
if (psa) {
|
|
SafeArrayDestroy(psa);
|
|
}
|
|
|
|
return(E_FAIL);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: BinarySDToSecurityDescriptor.
|
|
//
|
|
// Synopsis: Convert the given binary blob to an equivalent object
|
|
// implementing the IADsSecurityDescriptor interface.
|
|
//
|
|
// Arguments: pSecurityDescriptor - the binary SD to convert.
|
|
// pVarsec - return value.
|
|
// pszServerName - serverName the SD was
|
|
// retrieved from (optional).
|
|
// userName - not used, optional.
|
|
// passWord - not used, optional.
|
|
// dwFlags - not used, optional.
|
|
//
|
|
// Returns: HRESULT - S_OK or any failure error code
|
|
//
|
|
// Modifies: pVarsec to contain a VT_DISPATCH if successful.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
BinarySDToSecurityDescriptor(
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
VARIANT *pVarsec,
|
|
LPCWSTR pszServerName, // defaulted to NULL
|
|
LPCWSTR userName, // defaulted to NULL
|
|
LPCWSTR passWord, // defaulted to NULL
|
|
DWORD dwFlags // defaulted to 0
|
|
)
|
|
{
|
|
CCredentials creds((LPWSTR)userName, (LPWSTR)passWord, dwFlags);
|
|
|
|
//
|
|
// Call internal routine in sec2var.cxx that does all the work.
|
|
//
|
|
RRETURN(ConvertSecDescriptorToVariant(
|
|
(LPWSTR)pszServerName,
|
|
creds,
|
|
pSecurityDescriptor,
|
|
pVarsec,
|
|
TRUE // we will always expect NT format.
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: SecurityDescriptorToBinarySD.
|
|
//
|
|
// Synopsis: Convert the given IADsSecurityDescriptor to (in the variant
|
|
// to a binary security descriptor blob.
|
|
//
|
|
// Arguments: vVarSecDes - the binary SD to convert.
|
|
// ppSecurityDescriptor - ptr to output binary blob.
|
|
// pszServerName - serverName the SD
|
|
// is being put on, optional.
|
|
// userName - not used, optional.
|
|
// passWord - not used, optional.
|
|
// dwFlags - not used, optional.
|
|
//
|
|
// Returns: HRESULT - S_OK or any failure error code
|
|
//
|
|
// Modifies: pVarsec to contain a VT_DISPATCH if successful.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
SecurityDescriptorToBinarySD(
|
|
VARIANT vVarSecDes,
|
|
PSECURITY_DESCRIPTOR * ppSecurityDescriptor,
|
|
PDWORD pdwSDLength,
|
|
LPCWSTR pszServerName, // defaulted to NULL
|
|
LPCWSTR userName, // defaulted to NULL
|
|
LPCWSTR passWord, // defaulted to NULL
|
|
DWORD dwFlags // defaulted to 0
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
IADsSecurityDescriptor *pIADsSecDesc = NULL;
|
|
CCredentials creds((LPWSTR)userName, (LPWSTR)passWord, dwFlags);
|
|
|
|
//
|
|
// Verify it is a VT_DISPATCH and also that ptr is valid.
|
|
//
|
|
if ((vVarSecDes.vt != VT_DISPATCH)
|
|
|| (!V_DISPATCH(&vVarSecDes))
|
|
) {
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
//
|
|
// Get the interface ptr from the variant (it has to be IDispatch)
|
|
//
|
|
hr = vVarSecDes.pdispVal->QueryInterface(
|
|
IID_IADsSecurityDescriptor,
|
|
(void **) &pIADsSecDesc
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// Call the helper routine in sec2var.cxx
|
|
//
|
|
hr = ConvertSecurityDescriptorToSecDes(
|
|
(LPWSTR)pszServerName,
|
|
creds,
|
|
pIADsSecDesc,
|
|
ppSecurityDescriptor,
|
|
pdwSDLength,
|
|
TRUE // always NT Sec desc mode
|
|
);
|
|
|
|
error:
|
|
|
|
if (pIADsSecDesc) {
|
|
pIADsSecDesc->Release();
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
|
|
|
|
// end of helpers.cxx
|