Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/ds/adsi/ldap/cpropmgr.cxx

3562 lines
95 KiB
C++
Raw Permalink Blame History

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: cpropmgr.cxx
//
// Contents: Property manager - object that implements/helps implement
// IUMIPropList functions.
// The property manager needs to be initialized in one of 2 modes
// 1) PropertyCache mode in which case it uses the objects existing
// to provide IUMIPropList support and
// 2) Interface property mode in which case ???
//
// Functions: TBD.
//
// History: 02-07-00 AjayR Created.
//
//----------------------------------------------------------------------------
#include "ldap.hxx"
//
// These are global utility fucntions. Might be worth moving to a
// better location subsequently.
//
//+---------------------------------------------------------------------------
// Function: FreeOneUmiProperty -- Global scope.
//
// Synopsis: Walk through and free all information being pointed to
// including the values.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT FreeOneUmiProperty(UMI_PROPERTY umiProperty)
{
//
// Free the name now if we can
//
if (umiProperty.pszPropertyName) {
FreeADsStr(umiProperty.pszPropertyName);
umiProperty.pszPropertyName = NULL;
}
if (!umiProperty.pUmiValue) {
//
// We are done if count is 0
//
if (umiProperty.uCount == 0) {
RRETURN(S_OK);
}
else {
RRETURN(E_ADS_BAD_PARAMETER);
}
}
//
// Must have valid umiValues at this point.
//
for (ULONG ulCtr = 0; ulCtr < umiProperty.uCount; ulCtr++) {
switch (umiProperty.uType) {
case UMI_TYPE_LPWSTR:
//
// Go through and free each of the values.
//
if (umiProperty.pUmiValue->pszStrValue[ulCtr]) {
FreeADsStr(umiProperty.pUmiValue->pszStrValue[ulCtr]);
umiProperty.pUmiValue->pszStrValue[ulCtr] = NULL;
}
break;
case UMI_TYPE_BOOL:
case UMI_TYPE_I4:
case UMI_TYPE_FILETIME:
case UMI_TYPE_SYSTEMTIME:
case UMI_TYPE_I8:
//
// In all these cases nothing much to free except the value array
//
break;
case UMI_TYPE_OCTETSTRING:
//
// Go through and free each of the values.
//
if (umiProperty.pUmiValue->octetStr[ulCtr].lpValue) {
FreeADsMem(umiProperty.pUmiValue->octetStr[ulCtr].lpValue);
umiProperty.pUmiValue->octetStr[ulCtr].lpValue = NULL;
}
break;
case UMI_TYPE_IUNKNOWN:
//
// Need to release the ptr and Free the riid.
//
UMI_COM_OBJECT ComObject;
if (umiProperty.pUmiValue->comObject) {
ComObject = umiProperty.pUmiValue->comObject[ulCtr];
if (ComObject.pInterface) {
((IUnknown*)ComObject.pInterface)->Release();
ComObject.pInterface = NULL;
}
if (ComObject.priid) {
FreeADsMem((void *)ComObject.priid);
ComObject.priid = NULL;
}
}
break;
default:
//
// UmiType that we do not know anything about ??
//
ADsAssert(!"Unknown umitype in free memory");
RRETURN(E_ADS_BAD_PARAMETER);
break;
} // end of case
} // end of for
//
// Free the array of values now
//
if (umiProperty.pUmiValue) {
FreeADsMem( (void *)umiProperty.pUmiValue);
umiProperty.pUmiValue = NULL;
}
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
// Function: FreeUmiPropertyValues -- Global scope.
//
// Synopsis: Walk through and free all information being pointed to
// including the values.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT FreeUmiPropertyValues(UMI_PROPERTY_VALUES *pUmiProps)
{
HRESULT hr = S_OK;
if (pUmiProps) {
__try {
//
// Go through and free each property in the list
//
for (ULONG ulCtr = 0; ulCtr < pUmiProps->uCount; ulCtr++) {
hr = FreeOneUmiProperty(pUmiProps->pPropArray[ulCtr]);
}
//
// Free the inner array.
//
if (pUmiProps->pPropArray) {
FreeADsMem(pUmiProps->pPropArray);
}
//
// Free the array itself.
//
FreeADsMem( (LPVOID) pUmiProps);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
hr = E_INVALIDARG;
}
}
else {
hr = E_INVALIDARG;
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertUmiPropCodeToLdapCode -- Global scope.
//
// Synopsis: Convert the property code appropriately.
//
// Arguments: umiFlags - the umiPropCode,
// dwLdapOpCode& - byRef return value.
//
// Returns: HRESULT - S_OK or E_ADS_BAD_PARAMETER
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT ConvertUmiPropCodeToLdapCode(ULONG umiFlags, DWORD& dwLdapOpCode)
{
HRESULT hr = S_OK;
switch (umiFlags) {
case UMI_OPERATION_APPEND:
dwLdapOpCode = PROPERTY_ADD;
break;
case UMI_OPERATION_UPDATE:
dwLdapOpCode = PROPERTY_UPDATE;
break;
case UMI_OPERATION_EMPTY:
dwLdapOpCode = PROPERTY_DELETE;
break;
case UMI_OPERATION_DELETE_ALL_MATCHES:
dwLdapOpCode = PROPERTY_DELETE_VALUE;
break;
default:
//
// we do not handle these values.
// UMI_OPERATION_INSERT_AT
// UMI_OPERATION_REMOVE_AT
// UMI_OPERATION_DELETE_AT
// UMI_OPERATION_DELETE_FIRST_MATCH
// UMI_OPERATION_DELETE_ALL_MATCHES
//
hr = UMI_E_UNSUPPORTED_OPERATION;
break;
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertLdapCodeToUmiPropCode -- Global scope.
//
// Synopsis: Convert the property code appropriately.
//
// Arguments: dwLdapOpCode& - property cache operation code.
// umiFlags& - byRef return value.
//
// Returns: HRESULT - S_OK or E_ADS_BAD_PARAMETER
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
ConvertLdapCodeToUmiPropCode(
DWORD dwLdapCode,
ULONG &uUmiFlags
)
{
HRESULT hr = S_OK;
switch (dwLdapCode) {
case PROPERTY_ADD:
uUmiFlags = UMI_OPERATION_APPEND;
break;
case PROPERTY_UPDATE:
uUmiFlags = UMI_OPERATION_UPDATE;
break;
case PROPERTY_DELETE:
uUmiFlags = UMI_OPERATION_EMPTY;
break;
case PROPERTY_DELETE_VALUE:
uUmiFlags = UMI_OPERATION_DELETE_ALL_MATCHES;
break;
case 0:
//
// special case values that are just in the cache.
//
uUmiFlags = 0;
break;
default:
hr = E_ADS_BAD_PARAMETER;
break;
}
RRETURN(hr);
}
//****************************************************************************
//
//Internal helpers - restricted scope
//
//****************************************************************************
//+---------------------------------------------------------------------------
// Function: ConvertVariantLongToUmiProp.
//
// Synopsis: Convert the variant to a corresponding UmiProp.
//
// Arguments: vVariant - variant containg long val to convert.
// ppProp - Output UmiPropertyValues.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *pProp to point to valid UMI_PROPERTY_VALUES.
//
//----------------------------------------------------------------------------
HRESULT
ConvertVariantLongToUmiProp(
VARIANT vVariant,
UMI_PROPERTY_VALUES **ppProp
)
{
HRESULT hr = S_OK;
LONG *pLArray = NULL;
*ppProp = (PUMI_PROPERTY_VALUES) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
if (!*ppProp) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->pPropArray =
(UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
if (!((*ppProp)->pPropArray)) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->uCount = 1;
(*ppProp)->pPropArray[0].uType = UMI_TYPE_I4;
(*ppProp)->pPropArray[0].uCount = 1;
pLArray = (LONG *) AllocADsMem(sizeof(LONG) * 1);
if (!pLArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pLArray[0] = vVariant.lVal;
(*ppProp)->pPropArray[0].pUmiValue = (UMI_VALUE *)(void *)pLArray;
error :
if (FAILED(hr)) {
if (pLArray) {
FreeADsMem( (void*) pLArray);
}
FreeUmiPropertyValues(*ppProp);
}
RRETURN(hr);
}
HRESULT
GetEmptyLPWSTRProp(UMI_PROPERTY_VALUES **ppProp)
{
HRESULT hr = S_OK;
*ppProp = (PUMI_PROPERTY_VALUES) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
if (!*ppProp) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->pPropArray =
(UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
if (!((*ppProp)->pPropArray)) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->uCount = 1;
(*ppProp)->pPropArray[0].uType = UMI_TYPE_LPWSTR;
(*ppProp)->pPropArray[0].uCount = 0;
(*ppProp)->pPropArray[0].pUmiValue = NULL;
error :
if (FAILED(hr)) {
FreeUmiPropertyValues(*ppProp);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertBSTRToUmiProp.
//
// Synopsis: Convert the bstr to a corresponding UmiProp.
//
// Arguments: bstrStringVal - String to convert to umi values.
// ppProp - Output UmiPropertyValues.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *pProp to point to valid UMI_PROPERTY_VALUES.
//
//----------------------------------------------------------------------------
HRESULT
ConvertBSTRToUmiProp(
BSTR bstrStringVal,
UMI_PROPERTY_VALUES **ppProp
)
{
HRESULT hr = S_OK;
LPWSTR * pszStrArray = NULL;
LPWSTR pszTmpStr = NULL;
*ppProp = (PUMI_PROPERTY_VALUES) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
if (!*ppProp) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->pPropArray =
(UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
if (!((*ppProp)->pPropArray)) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->uCount = 1;
(*ppProp)->pPropArray[0].uType = UMI_TYPE_LPWSTR;
(*ppProp)->pPropArray[0].uCount = 1;
pszStrArray = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * 1);
if (!pszStrArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// If the value is NULL, then we return an array with a NULL
// value as the result.
//
if (bstrStringVal) {
pszStrArray[0] = AllocADsStr(bstrStringVal);
if (!pszStrArray[0]) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
(*ppProp)->pPropArray[0].pUmiValue = (UMI_VALUE *)(void *)pszStrArray;
error :
if (FAILED(hr)) {
if (pszStrArray) {
FreeADsMem( (void*) pszStrArray);
}
FreeUmiPropertyValues(*ppProp);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertIUnkToUmiProp.
//
// Synopsis: Convert the IUnk to a corresponding UmiProp.
//
// Arguments: pUnk - IUnk ptr.
// iid - iid of the ptr.
// ppProp - Output UmiPropertyValues.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *pProp to point to valid UMI_PROPERTY_VALUES.
//
//----------------------------------------------------------------------------
HRESULT
ConvertIUnkToUmiProp(
IUnknown * pUnk,
IID iid,
UMI_PROPERTY_VALUES **ppProp
)
{
HRESULT hr = S_OK;
PUMI_COM_OBJECT pComObjArray = NULL;
*ppProp = (PUMI_PROPERTY_VALUES) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
if (!*ppProp) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->pPropArray =
(UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
if (!((*ppProp)->pPropArray)) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->uCount = 1;
(*ppProp)->pPropArray[0].uType = UMI_TYPE_IUNKNOWN;
(*ppProp)->pPropArray[0].uCount = 1;
pComObjArray = (PUMI_COM_OBJECT) AllocADsMem(sizeof(UMI_COM_OBJECT) * 1);
if (!pComObjArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
hr = pUnk->QueryInterface(
iid,
(void **) &(pComObjArray[0].pInterface)
);
BAIL_ON_FAILURE(hr);
pComObjArray[0].priid = (IID *) AllocADsMem(sizeof(IID));
if (!pComObjArray[0].priid) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(pComObjArray[0].priid, &iid, sizeof(IID));
(*ppProp)->pPropArray[0].pUmiValue = (UMI_VALUE *)(void *)pComObjArray;
error :
if (FAILED(hr)) {
if (pComObjArray) {
if (pComObjArray[0].pInterface) {
((IUnknown *)pComObjArray[0].pInterface)->Release();
}
FreeADsMem( (void*) pComObjArray);
}
FreeUmiPropertyValues(*ppProp);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperGetUmiRelUrl.
//
// Synopsis: Gets the __RELURL property for the object. This routine
// combines the IADs::get_Name and IADs::get_Class
//
// Arguments: pIADs - Pointer to obj implementing IADs.
// bstrRetVal - Pointer for retrun bstr value.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *pProp to point to valid UMI_PROPERTY_VALUES.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetUmiRelUrl(
IADs * pIADs,
BSTR * bstrRetVal
)
{
HRESULT hr = S_OK;
BSTR bstrName = NULL, bstrClass = NULL;
LPWSTR pszTempVal = NULL;
BOOL fSchemaObject = FALSE;
hr = pIADs->get_Name(&bstrName);
BAIL_ON_FAILURE(hr);
hr = pIADs->get_Class(&bstrClass);
BAIL_ON_FAILURE(hr);
//
// See if this is a schema object.
//
if (!_wcsicmp(bstrClass, L"Schema")
|| !_wcsicmp(bstrClass, L"Class")
|| !_wcsicmp(bstrClass, L"Property")
)
{
LPWSTR pszTemp;
//
// If this is indeed a schema object then the name
// wont have any = sign in it. Equal is not allowed
// in the names of schema objects.
//
if ((pszTemp = wcschr(bstrName, L'=')) == NULL)
fSchemaObject = TRUE;
}
//
// Add 2 as we need 1 for the \0 and the other for the .
// in class.name
//
DWORD dwLen;
dwLen = wcslen(bstrName) + wcslen(bstrClass) + 2;
if (fSchemaObject) {
//
// Need to add space for .Name
//
dwLen = dwLen + 6;
}
pszTempVal = (LPWSTR) AllocADsMem(dwLen * sizeof(WCHAR));
if (!pszTempVal) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (!fSchemaObject) {
wsprintf(pszTempVal, L"%s.%s", bstrClass, bstrName);
}
else {
wsprintf(pszTempVal, L"%s.Name=%s", bstrClass, bstrName);
}
hr = ADsAllocString(pszTempVal, bstrRetVal);
BAIL_ON_FAILURE(hr);
error:
if (bstrName) {
SysFreeString(bstrName);
}
if (bstrClass) {
SysFreeString(bstrClass);
}
if (pszTempVal) {
FreeADsStr(pszTempVal);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperGetUmiSchemaContainerPath.
//
// Synopsis: Gets the Umi path to the schema container for this object.
//
// Arguments: pIADs - Pointer to obj implementing IADs.
// bstrRetVal - Pointer for retrun bstr value.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *bstrRetVal points to the correct schema path.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetUmiSchemaContainerPath(
IADs * pIADs,
BSTR * bstrRetVal
)
{
HRESULT hr = S_OK;
BSTR bstrSchema = NULL;
LPWSTR pszParent = NULL, pszCN = NULL, pszUmiSchema = NULL;
//
// First we need the path of the schema object itslef.
//
hr = pIADs->get_Schema(&bstrSchema);
BAIL_ON_FAILURE(hr);
//
// Now we can build the path to the schema container from the path.
//
hr = BuildADsParentPath(
bstrSchema,
&pszParent,
&pszCN
);
BAIL_ON_FAILURE(hr);
hr = ADsPathToUmiURL(pszParent, &pszUmiSchema);
BAIL_ON_FAILURE(hr);
hr = ADsAllocString(pszUmiSchema, bstrRetVal);
BAIL_ON_FAILURE(hr);
error:
if (bstrSchema) {
SysFreeString(bstrSchema);
}
if (pszCN) {
FreeADsStr(pszCN);
}
if (pszParent) {
FreeADsStr(pszParent);
}
if (pszUmiSchema) {
FreeADsStr(pszUmiSchema);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperGetUmiDerivedFrom.
//
// Synopsis: Gets the value of the class that the current class object
// is derived from.
//
// Arguments: pIADs - Pointer to obj implementing IADs.
// bstrRetVal - Pointer for retrun bstr value.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *bstrRetVal points to the correct schema path.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetUmiDerivedFrom(
IADs * pIADs,
BSTR * pbstrRetVal
)
{
HRESULT hr = S_OK;
IADsClass *pClass = NULL;
BSTR bstrName = NULL;
VARIANT vVariant;
VariantInit(&vVariant);
*pbstrRetVal = NULL;
hr = pIADs->get_Name(&bstrName);
BAIL_ON_FAILURE(hr);
//
// If the class is Top then we just return NULL.
//
if (_wcsicmp(bstrName, L"Top")) {
//
// Get the IADsClass interface, this is done because IADs::Get
// will need to ask for different attributes based on the server.
// IADsClass encapsulates this difference for us.
//
hr = pIADs->QueryInterface(IID_IADsClass, (void **) &pClass);
if (FAILED(hr)) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
hr = pClass->get_DerivedFrom(&vVariant);
BAIL_ON_FAILURE(hr);
ADsAssert(vVariant.vt == VT_BSTR);
hr = ADsAllocString(vVariant.bstrVal, pbstrRetVal);
}
BAIL_ON_FAILURE(hr);
error:
VariantClear(&vVariant);
if (bstrName) {
SysFreeString(bstrName);
}
if (pClass) {
pClass->Release();
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperConvertNameToKey.
//
// Synopsis: Converts the value of the BSTR (of the form cn=test) to cn
// as required by UMI.
//
// Arguments: bstrName - Value to get the key from.
// pszUmiKey - Return value for the key.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *pszUmiUrl points to the key.
//
//----------------------------------------------------------------------------
HRESULT
HelperConvertNameToKey(
BSTR bstrName,
LPWSTR * pszUmiUrl
)
{
HRESULT hr = S_OK;
LPWSTR pszTemp = bstrName;
BOOL fEqualFound = FALSE;
DWORD dwCount = 0;
ADsAssert(bstrName && pszTemp && *pszTemp);
while (pszTemp
&& *pszTemp
&& (!fEqualFound)
) {
if (*pszTemp == L'=') {
fEqualFound = TRUE;
}
dwCount++;
pszTemp++;
}
if (!fEqualFound) {
BAIL_ON_FAILURE(hr = E_ADS_PROPERTY_NOT_FOUND);
}
*pszUmiUrl = (LPWSTR) AllocADsMem(dwCount * sizeof(WCHAR));
if (!*pszUmiUrl) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
wcsncpy(*pszUmiUrl, bstrName, (dwCount-1));
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperUpdateSDFlags.
//
// Synopsis: On put/get calls updates the security flags appropriately.
//
// Arguments: pIADs - IADs pointer to use to update sd.
// uFlags - Flags to use for getting SD.
// pfUpdated - Return boolean value.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: Underlying property cache and pfUpdated to TRUE if the
// flags on the object had to be changed and FALSE otherwise.
//
//----------------------------------------------------------------------------
HRESULT
HelperUpdateSDFlags(
IADs *pIADs,
ULONG uFlags,
BOOL *pfUpdated = NULL
)
{
HRESULT hr = S_OK;
IADsObjOptPrivate *pPrivOpt = NULL;
SECURITY_INFORMATION secInfo;
ADsAssert(pIADs);
if (pfUpdated) {
*pfUpdated = FALSE;
}
//
// Get the objOpt intf and make sure the flags are right.
//
hr = pIADs->QueryInterface(IID_IADsObjOptPrivate, (void **) &pPrivOpt);
BAIL_ON_FAILURE(hr);
hr = pPrivOpt->GetOption(
LDAP_SECURITY_MASK,
(void *) &secInfo
);
BAIL_ON_FAILURE(hr);
if (secInfo != uFlags) {
//
// We need to update the security mask on the object.
//
hr = pPrivOpt->SetOption(
LDAP_SECURITY_MASK,
(void **) &uFlags
);
BAIL_ON_FAILURE(hr);
//
// Need to let caller know that the flags have changed.
//
if (pfUpdated) {
*pfUpdated = TRUE;
}
}
error:
if (pPrivOpt) {
pPrivOpt->Release();
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperGetSDIntoCache.
//
// Synopsis: Reads the sd into the property cache using the appropriate
// flags as needed.
//
// Arguments: pIADs - IADs pointer to use to update sd.
// uFlags - Flags to use for getting SD.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: Underlying property cache.
//
//----------------------------------------------------------------------------
HRESULT HelperGetSDIntoCache(
IADs * pIADs,
ULONG uFlags
)
{
HRESULT hr = S_OK;
VARIANT vVar;
BOOL fUpdated = FALSE;
LPWSTR szSecDesc[] = {L"ntSecurityDescriptor"};
VariantInit(&vVar);
hr = HelperUpdateSDFlags(
pIADs,
(uFlags & UMI_SECURITY_MASK),
&fUpdated
);
BAIL_ON_FAILURE(hr);
if (fUpdated) {
//
// Update just the SD by calling GetInfoEx.
//
hr = ADsBuildVarArrayStr(
szSecDesc,
1,
&vVar
);
BAIL_ON_FAILURE(hr);
hr = pIADs->GetInfoEx(vVar, 0);
BAIL_ON_FAILURE(hr);
}
error :
VariantClear(&vVar);
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: HelperGetOrigin.
//
// Synopsis: Gets the originating class for the property in question.
//
// Arguments: pIADs - IADs pointer to backing object.
// pszName - Name of the property whose origin is needed.
// ppProp - Return value.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetOrigin(
IADs *pIADs,
LPCWSTR pszName,
UMI_PROPERTY_VALUES **ppProp
)
{
HRESULT hr = S_OK;
IADsUmiHelperPrivate *pHelper = NULL;
BSTR bstrVal = NULL;
hr = pIADs->QueryInterface(
IID_IADsUmiHelperPrivate,
(void **) &pHelper
);
if (FAILED(hr)) {
//
// This object does not support this property as it is not
// a class object.
//
BAIL_ON_FAILURE(hr = E_ADS_PROPERTY_NOT_FOUND);
}
hr = pHelper->GetOriginHelper(
pszName,
&bstrVal
);
BAIL_ON_FAILURE(hr);
hr = ConvertBSTRToUmiProp(
bstrVal,
ppProp
);
error:
if (bstrVal) {
SysFreeString(bstrVal);
}
if (pHelper) {
pHelper->Release();
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CopyUmiProperty.
//
// Synopsis: Copy the input value into a newly allocated output buffer.
// Note that since this is an internal routine assumptions are made
// as to the data. Currently handles only UMI_TYPE_LPWSTR,
// UMI_TYPE_I4 and UMI_TYPE_BOOL. If multivalued, we can only copy
// strings (things like filter on enum can be multi-valued).
//
// Arguments: umiProp - Umi property value to copy.
// ppUmiProp - Return value for new umi property.
//
// Returns: HRESULT - S_OK or any failure ecode.
//
// Modifies: *ppUmiProp to point to valid UMI_PROPERTY.
//
//----------------------------------------------------------------------------
HRESULT
CopyUmiProperty(
UMI_PROPERTY umiProp,
PUMI_PROPERTY *ppUmiProp
)
{
HRESULT hr = S_OK;
UMI_PROPERTY *pUmiPropLocal = NULL;
ULONG ulUmiType = umiProp.uType;
ULONG ulPropCount = umiProp.uCount;
*ppUmiProp = NULL;
//
// Multi valued has to be string.
//
if ((ulPropCount > 1) && (ulUmiType != UMI_TYPE_LPWSTR)) {
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
}
pUmiPropLocal = (UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
if (!pUmiPropLocal) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pUmiPropLocal->pszPropertyName = AllocADsStr(umiProp.pszPropertyName);
if (!pUmiPropLocal->pszPropertyName) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pUmiPropLocal->uOperationType = umiProp.uOperationType;
pUmiPropLocal->uType = umiProp.uType;
switch (umiProp.uType) {
case UMI_TYPE_LPWSTR :
LPWSTR *pszTmpArray;
pszTmpArray = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * ulPropCount);
if (!pszTmpArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (DWORD dwCtr = 0; dwCtr < ulPropCount; dwCtr++) {
pszTmpArray[dwCtr] = AllocADsStr(
umiProp.pUmiValue->pszStrValue[dwCtr]
);
if (!pszTmpArray[dwCtr]) {
//
// NULL is allowed as a value only if it is the
// only value being set.
//
if (ulPropCount != 1
|| umiProp.pUmiValue->pszStrValue[dwCtr]
) {
//
// Cleanup and exit.
//
for (DWORD dwCtr2 = 0; dwCtr2 < dwCtr; dwCtr2++) {
if (pszTmpArray[dwCtr2]) {
FreeADsStr(pszTmpArray[dwCtr2]);
pszTmpArray[dwCtr2] = NULL;
}
}
FreeADsMem(pszTmpArray);
pszTmpArray = NULL;
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
} // if alloc failed in middle of array.
}
pUmiPropLocal->pUmiValue = (PUMI_VALUE) (void *) pszTmpArray;
break;
case UMI_TYPE_I4:
LONG *pLongArray;
pLongArray = (LONG *) AllocADsMem(sizeof(LONG) * 1);
if (!pLongArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pLongArray[0] = umiProp.pUmiValue->lValue[0];
pUmiPropLocal->pUmiValue = (PUMI_VALUE) (void *) pLongArray;
break;
case UMI_TYPE_BOOL:
BOOL *pBoolArray;
pBoolArray = (BOOL *) AllocADsMem(sizeof(BOOL) * 1);
if (!pBoolArray) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pBoolArray[0] = umiProp.pUmiValue->bValue[0];
pUmiPropLocal->pUmiValue = (PUMI_VALUE) (void *) pBoolArray;
break;
default:
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
break;
}
pUmiPropLocal->uCount = ulPropCount;
*ppUmiProp = pUmiPropLocal;
RRETURN(hr);
error:
//
// Cleanup cause we hit an error.
//
if (pUmiPropLocal) {
FreeOneUmiProperty(*pUmiPropLocal);
FreeADsMem( (void*) pUmiPropLocal);
}
RRETURN(hr);
}
//****************************************************************************
//
//CPropertyManager Methods.
//
//****************************************************************************
//+---------------------------------------------------------------------------
// Function: CPropertyManager::CPropertyManager
//
// Synopsis: Constructor
//
// Arguments: None
//
// Returns: N/A
//
// Modifies: N/A
//
//----------------------------------------------------------------------------
CPropertyManager::CPropertyManager():
_dwMaxProperties(0),
_pPropCache(NULL),
_pIntfProperties(NULL),
_dwMaxLimit(0),
_fPropCacheMode(TRUE),
_pStaticPropData(NULL),
_ulStatus(0),
_pIADs(NULL),
_pUnk(NULL),
_pCreds(NULL),
_pszServerName(NULL)
{
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::~CPropertyManager
//
// Synopsis: Destructor
//
// Arguments: None
//
// Returns: N/A
//
// Modifies: N/A
//
//----------------------------------------------------------------------------
CPropertyManager::~CPropertyManager()
{
//
// Need to cleanup inftProps table
//
if (_pIntfProperties) {
DWORD dwCtr;
for (dwCtr = 0; dwCtr < _dwMaxProperties; dwCtr++) {
//
// Free each of the entries and their contents.
//
PINTF_PROPERTY pIntfProp = &(_pIntfProperties[dwCtr]);
if (pIntfProp->pszPropertyName) {
FreeADsStr(pIntfProp->pszPropertyName);
pIntfProp->pszPropertyName = NULL;
}
if (pIntfProp->pUmiProperty) {
FreeOneUmiProperty(*(pIntfProp->pUmiProperty));
FreeADsMem(pIntfProp->pUmiProperty);
pIntfProp->pUmiProperty = NULL;
}
}
FreeADsMem(_pIntfProperties);
}
_pIntfProperties = NULL;
//
// The rest of the stuff is taken care of when the
// destructor to the IADs obj is called. This object
// itself will be released only in the destructor of the
// IADs object is called.
//
_pPropCache = NULL;
if (_pIADs) {
_pIADs->Release();
}
_pIADs = NULL;
_dwMaxProperties = 0;
//
// Do not free as these are owned by the owning object.
//
_pszServerName = NULL;
_pCreds = NULL;
_pUnk = NULL;
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::CreatePropertyManager (overloaded)
//
// Synopsis: Static allocation routine (property cache mode).
//
// Arguments: IADs* - pointer to IADs implementor object.
// pUnk - owning object unknown.
// pPropCache - pointer to propertyCache used by object.
// pCredentials - pointer to credentials.
// pszServerName - pointer to servername.
// ppPropertyManager - return ptr for new prop mgr.
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: CPropertyManager ** - ptr to newly created object.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::CreatePropertyManager(
IADs *pADsObj,
IUnknown *pUnk,
CPropertyCache *pPropCache,
CCredentials *pCredentials,
LPWSTR pszServerName,
CPropertyManager FAR * FAR * ppPropertyManager
)
{
CPropertyManager FAR * pPropMgr = NULL;
pPropMgr = new CPropertyManager();
if (!pPropMgr) {
RRETURN_EXP_IF_ERR(E_OUTOFMEMORY);
}
if (pADsObj) {
pADsObj->QueryInterface(IID_IADs, (void**) &(pPropMgr->_pIADs));
}
pPropMgr->_pUnk = pUnk;
pPropMgr->_pPropCache = pPropCache;
pPropMgr->_fPropCacheMode = TRUE;
pPropMgr->_pIntfProperties = NULL;
pPropMgr->_pszServerName = pszServerName;
pPropMgr->_pCreds = pCredentials;
*ppPropertyManager = pPropMgr;
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::CreatePropertyManager (overloaded)
//
// Synopsis: Static allocation routine (interface properties mode).
//
// Arguments: pUnk - pointer to owner (umi) object.
// pIADs - pointer to IADs implementor.
// pCredentials - pointer to credentials.
// pTable - property table.
// ppPropertyManager - return value for new prop mgr.
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: CPropertyManager ** - ptr to newly created object.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::CreatePropertyManager(
IUnknown *pUnk,
IUnknown *pIADs,
CCredentials *pCredentials,
INTF_PROP_DATA pTable[],
CPropertyManager FAR * FAR * ppPropertyManager
)
{
CPropertyManager FAR * pPropMgr = NULL;
pPropMgr = new CPropertyManager();
if (!pPropMgr) {
RRETURN_EXP_IF_ERR(E_OUTOFMEMORY);
}
pPropMgr->_pUnk = pUnk;
//
// We can ignore any failures here.
//
if (pIADs) {
pIADs->QueryInterface(IID_IADs, (void**) &(pPropMgr->_pIADs));
}
pPropMgr->_pPropCache = NULL;
pPropMgr->_fPropCacheMode = FALSE;
pPropMgr->_pIntfProperties = NULL;
pPropMgr->_pCreds = pCredentials;
pPropMgr->_pStaticPropData = pTable;
*ppPropertyManager = pPropMgr;
RRETURN(S_OK);
}
STDMETHODIMP
CPropertyManager::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
HRESULT hr = S_OK;
SetLastStatus(0);
if (ppv == NULL) {
RRETURN(E_POINTER);
}
if (IsEqualIID(iid, IID_IUnknown)){
*ppv = (IUnknown FAR *) this;
}
else if (IsEqualIID(iid, IID_IUmiPropList)) {
*ppv = (IUmiPropList FAR *) this;
}
else {
*ppv = NULL;
SetLastStatus(E_NOINTERFACE);
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
//
// Methods defined on the proplist interface.
//
//+---------------------------------------------------------------------------
// Function: CPropertyManager::Put (IUmiPropList support).
//
// Synopsis: Sets the value for the attribute in the cache.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: PropertyCache or internal interface property list.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::Put(
IN LPCWSTR pszName,
IN ULONG uFlags,
IN UMI_PROPERTY_VALUES *pProp
)
{
HRESULT hr = S_OK;
LDAPOBJECTARRAY ldapDestObjects;
DWORD dwOperationFlags = 0;
BOOL fSecurityFlags = FALSE;
IUmiObject *pUmiObj = NULL;
BOOL fInternalPut = FALSE;
SetLastStatus(0);
//
// Initialize so that we are not trying to free junk.
//
if (_fPropCacheMode) {
LDAPOBJECTARRAY_INIT(ldapDestObjects);
}
//
// Pre process and pull out the highest flag, all these
// because we are not allowed to support Put with 0.
//
if (uFlags & 0x8000000) {
uFlags &= 0x4000000;
fInternalPut = TRUE;
}
if (uFlags > UMI_SECURITY_MASK) {
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
}
if (!pProp || !pszName) {
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
}
if (uFlags & UMI_SECURITY_MASK) {
fSecurityFlags = TRUE;
}
//
// We support only putting one property at a time.
//
if (pProp->uCount != 1) {
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
}
//
// Make sure that the data passed in is correct.
//
if (!pProp->pPropArray
|| !pProp->pPropArray[0].pszPropertyName) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
if (_fPropCacheMode) {
DWORD dwLdapSyntaxId = 1;
if (fInternalPut
&& pProp->pPropArray[0].uOperationType == 0) {
dwOperationFlags = 0;
}
else {
//
// Verify that the operationType is something we support.
//
hr = ConvertUmiPropCodeToLdapCode(
pProp->pPropArray[0].uOperationType,
dwOperationFlags
);
BAIL_ON_FAILURE(hr);
}
if (fSecurityFlags) {
//
// Only this ntSecurityDescriptor can use the security flags.
//
if (_wcsicmp(L"ntSecurityDescriptor", pszName)) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
hr = HelperUpdateSDFlags(
_pIADs,
uFlags & UMI_SECURITY_MASK
);
BAIL_ON_FAILURE(hr);
}
//
// In this case we need to convert data to ldap values and
// store in cache.
//
hr = UmiTypeToLdapTypeCopy(
*pProp,
uFlags,
&ldapDestObjects,
dwLdapSyntaxId, // byRef
_pCreds,
_pszServerName
);
BAIL_ON_FAILURE(hr);
//
// PutpropertyExt will add to the cache if needed.
//
hr = _pPropCache->putpropertyext(
(LPWSTR)pszName,
dwOperationFlags,
dwLdapSyntaxId,
ldapDestObjects
);
BAIL_ON_FAILURE(hr);
}
else {
//
// Local cache for interface properties. Verify property is
// legal and update the local information accordingly.
//
if (VerifyIfValidProperty(
pProp->pPropArray[0].pszPropertyName,
pProp->pPropArray[0]
)
) {
if (fSecurityFlags
|| !_wcsicmp(pszName, L"__SECURITY_DESCRIPTOR")
) {
//
// Make sure name is correct.
//
if (_wcsicmp(L"__SECURITY_DESCRIPTOR", pszName)) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
//
// We need turn around and call put on the owning object.
// This means we need to package the UMI_PROPERTY_VALUES
// accordingly.
//
UMI_PROPERTY pUmiProperty[] = {
pProp->pPropArray[0].uType,
pProp->pPropArray[0].uCount,
pProp->pPropArray[0].uOperationType,
L"ntSecurityDescriptor",
pProp->pPropArray[0].pUmiValue
};
UMI_PROPERTY_VALUES pUmiProp[] = {1, pUmiProperty};
hr = _pUnk->QueryInterface(
IID_IUmiObject,
(void **) &pUmiObj
);
BAIL_ON_FAILURE(hr);
hr = pUmiObj->Put(
L"ntSecurityDescriptor",
uFlags,
pUmiProp
);
BAIL_ON_FAILURE(hr);
}
else {
//
// We need to update this value in our cache
//
hr = AddProperty(
pszName,
pProp->pPropArray[0]
);
BAIL_ON_FAILURE(hr);
}
} // not valid property.
else {
BAIL_ON_FAILURE(hr = E_FAIL);
}
}
error :
//
// Free ldapDestObjects if applicable.
//
if (_fPropCacheMode) {
LdapTypeFreeLdapObjects( &ldapDestObjects );
}
if (pUmiObj) {
pUmiObj->Release();
}
if (FAILED(hr)) {
SetLastStatus(hr);
hr = MapHrToUmiError(hr);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::Get (IUmiPropList support).
//
// Synopsis: Gets the value for the attribute. This will read data
// from the server as needed.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: UMI_PROPERTY_VALUES* has the values of the attribute.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::Get(
IN LPCWSTR pszName,
IN ULONG uFlags,
OUT UMI_PROPERTY_VALUES **pProp
)
{
HRESULT hr = S_OK;
ULONG uUmiFlag;
LDAPOBJECTARRAY ldapSrcObjects;
BOOL fSecurityFlag = FALSE;
BOOL fSchemaFlag = FALSE;
IADsObjOptPrivate *pPrivOpt = NULL;
SetLastStatus(0);
LDAPOBJECTARRAY_INIT(ldapSrcObjects);
if (!pProp) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
*pProp = NULL;
//
// Currently this is the highest flag we support.
//
if (uFlags > UMI_FLAG_PROPERTY_ORIGIN) {
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
}
else if (uFlags & UMI_SECURITY_MASK) {
fSecurityFlag = TRUE;
}
else if (uFlags == UMI_FLAG_PROPERTY_ORIGIN) {
fSchemaFlag = TRUE;
}
if (fSchemaFlag && fSecurityFlag) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
//
// Name cannot be NULL.
//
if (!pszName) {
BAIL_ON_FAILURE(hr = E_INVALIDARG)
}
//
// If this is Property Manager is for server properties.
//
if (_fPropCacheMode) {
DWORD dwSyntaxId;
DWORD dwStatus;
DWORD dwSecOptions;
if (fSchemaFlag) {
BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
}
if (fSecurityFlag) {
if (_wcsicmp(L"ntSecurityDescriptor", pszName)) {
//
// Security flag used and attrib not securityDescriptor.
//
BAIL_ON_FAILURE(hr = E_FAIL);
}
else {
//
// Valid flag we need to process the flags.
//
hr = HelperGetSDIntoCache(
_pIADs,
uFlags
);
BAIL_ON_FAILURE(hr);
}
}
//
// Object maybe unbound, so we should return no such prop if
// we get back E_ADS_OBJECT_UNBOUND.
//
hr = _pPropCache->getproperty(
(LPWSTR)pszName,
&dwSyntaxId,
&dwStatus,
&ldapSrcObjects
);
if (hr == E_ADS_OBJECT_UNBOUND) {
hr = E_ADS_PROPERTY_NOT_FOUND;
}
BAIL_ON_FAILURE(hr);
hr = ConvertLdapCodeToUmiPropCode(dwStatus, uUmiFlag);
BAIL_ON_FAILURE(hr);
//
// Return error if provider cache is not set and
// the cache is dirty.
//
if (uUmiFlag && !(uFlags & UMI_FLAG_PROVIDER_CACHE)) {
BAIL_ON_FAILURE(hr = UMI_E_SYNCHRONIZATION_REQUIRED);
}
//
// At this point we might have ldapSrcObjects.pLdapObjects == NULL.
// Typically that would be for property delete operations.
//
hr = LdapTypeToUmiTypeCopy(
ldapSrcObjects,
pProp,
dwStatus,
dwSyntaxId,
_pCreds,
_pszServerName,
uUmiFlag
);
}
else {
//
// Property Manager is for interface properties.
//
DWORD dwIndex;
//
// If the schema flag is set then we need to get the origin
// and not the property itself.
//
if (fSchemaFlag) {
hr = HelperGetOrigin(
_pIADs,
pszName,
pProp
);
}
else {
//
// Make sure this property is valid.
//
hr = GetIndexInStaticTable(pszName, dwIndex); // dwIndex is byRef
BAIL_ON_FAILURE(hr);
hr = GetInterfaceProperty(
pszName,
uFlags,
pProp,
dwIndex
);
}
}
BAIL_ON_FAILURE(hr);
//
// Stuff the name in the return value.
//
if (pProp && *pProp) {
(*pProp)->pPropArray[0].pszPropertyName = AllocADsStr(pszName);
if (!(*pProp)->pPropArray[0].pszPropertyName) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
error:
if (_fPropCacheMode) {
LdapTypeFreeLdapObjects(&ldapSrcObjects);
}
if (FAILED(hr)) {
SetLastStatus(hr);
hr = MapHrToUmiError(hr);
if (pProp && *pProp) {
this->FreeMemory(0, (void *) *pProp);
*pProp = NULL;
}
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetAt (IUmiPropList support).
//
// Synopsis: Used to get the value by index ???
//
// Arguments: Not implemented
//
//
// Returns: E_NOTIMPL
//
// Modifies: Not implemented
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::GetAt(
IN LPCWSTR pszName,
IN ULONG uFlags,
IN ULONG uBufferLength,
OUT LPVOID pExisitingMem
)
{
SetLastStatus(E_NOTIMPL);
RRETURN(E_NOTIMPL);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetAs (IUmiPropList support).
//
// Synopsis: Gets the value for the attribute in the specified format.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: UMI_PROPERTY_VALUES* has the values of the attribute.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::GetAs(
IN LPCWSTR pszName,
IN ULONG uFlags,
IN ULONG uCoercionType,
IN OUT UMI_PROPERTY_VALUES **pProp
)
{
HRESULT hr = S_OK;
LDAPOBJECTARRAY ldapSrcObjects;
LDAPOBJECTARRAY ldapSrcObjectsTmp;
LDAPOBJECTARRAY * pldapObjects = NULL;
ULONG uUmiFlag;
DWORD dwSyntaxId, dwStatus, dwRequestedSyntax;
DWORD dwCachedSyntax, dwUserSyntax;
SetLastStatus(0);
LDAPOBJECTARRAY_INIT(ldapSrcObjects);
LDAPOBJECTARRAY_INIT(ldapSrcObjectsTmp);
if (!pszName || !pProp) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
//
// Has to be in prop cache mode.
//
if (!_fPropCacheMode || !_pPropCache) {
BAIL_ON_FAILURE(hr = E_NOTIMPL);
}
if (uFlags > UMI_SECURITY_MASK) {
BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
}
if (uFlags & UMI_SECURITY_MASK) {
//
// Make sure it is the SD they are interested in.
//
if (_wcsicmp(L"ntSecurityDescriptor", pszName)) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
//
// At this point we need to get the SD in the cache.
//
hr = HelperGetSDIntoCache(_pIADs, uFlags);
BAIL_ON_FAILURE(hr);
}
//
// Object maybe unbound, so we should return no such prop if
// we get back E_ADS_OBJECT_UNBOUND.
//
hr = _pPropCache->getproperty(
(LPWSTR)pszName,
&dwSyntaxId,
&dwStatus,
&ldapSrcObjects
);
if (hr == E_ADS_OBJECT_UNBOUND) {
hr = E_ADS_PROPERTY_NOT_FOUND;
}
BAIL_ON_FAILURE(hr);
//
// Get the appropriate umi code for the status.
//
hr = ConvertLdapCodeToUmiPropCode(dwStatus, uUmiFlag);
BAIL_ON_FAILURE(hr);
//
// At this point we need to see if we can convert the data
// to the format requested. This code is similar to that in
// proplist.cxx GetPropertyItem but there appears to be no
// easy way to avoid this duplication.
//
dwCachedSyntax = dwSyntaxId;
//
// Need to take the requested type to ADs types and from there to
// ldap types.
//
hr = UmiTypeToLdapTypeEnum(uCoercionType, &dwUserSyntax);
BAIL_ON_FAILURE(hr);
//
// We can convert to any requested type only if it is unknown.
//
if (dwCachedSyntax == LDAPTYPE_UNKNOWN) {
dwRequestedSyntax = dwUserSyntax;
}
else if (dwCachedSyntax == dwUserSyntax) {
//
// Easy one !
//
dwRequestedSyntax = dwCachedSyntax;
}
else {
//
// This means we already have a type. In this case the only
// coercion we allows is SD to binary blob and vice-versa.
//
if ((dwCachedSyntax == LDAPTYPE_SECURITY_DESCRIPTOR)
&& (dwUserSyntax == LDAPTYPE_OCTETSTRING)
) {
dwRequestedSyntax = dwUserSyntax;
}
else if ((dwCachedSyntax == LDAPTYPE_OCTETSTRING)
&& (dwUserSyntax == LDAPTYPE_SECURITY_DESCRIPTOR)
) {
dwRequestedSyntax = dwUserSyntax;
}
else {
BAIL_ON_FAILURE(hr = E_FAIL);
}
}
//
// If the data is in a state that needs conversion the fn will
// take care - note that if the source is already in the correct
// format then the HR will S_FALSE.
//
hr = LdapTypeBinaryToString(
dwRequestedSyntax,
&ldapSrcObjects,
&ldapSrcObjectsTmp
);
BAIL_ON_FAILURE(hr);
if (hr == S_OK) {
pldapObjects = &ldapSrcObjectsTmp;
}
else {
//
// We already have the data in the right format.
//
pldapObjects = &ldapSrcObjects;
hr = S_OK;
}
//
// Now that we have the correct data in pLdapObjects, we need
// to convert that to Umi Properties.
//
hr = LdapTypeToUmiTypeCopy(
*pldapObjects,
pProp,
dwStatus,
dwRequestedSyntax,
_pCreds,
_pszServerName,
uUmiFlag
);
BAIL_ON_FAILURE(hr);
//
// Stuff the name in the return value.
//
if (pProp) {
(*pProp)->pPropArray[0].pszPropertyName = AllocADsStr(pszName);
if (!(*pProp)->pPropArray[0].pszPropertyName) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
error:
if (_fPropCacheMode) {
LdapTypeFreeLdapObjects(&ldapSrcObjects);
LdapTypeFreeLdapObjects(&ldapSrcObjectsTmp);
}
if (FAILED(hr)) {
SetLastStatus(hr);
hr = MapHrToUmiError(hr);
if (pProp) {
this->FreeMemory(0, (void *)*pProp);
*pProp = NULL;
}
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::FreeMemory (IUmiPropList support).
//
// Synopsis: Free memory pointed to. Note that the pointer should have
// originally come from a Get/GetAs call.
//
// Arguments: Ptr to data to be freed.
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: *pMem is of course freed.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::FreeMemory(
ULONG uReserved,
LPVOID pMem
)
{
HRESULT hr = S_OK;
SetLastStatus(0);
if (uReserved) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
if (pMem) {
//
// At this time this has to be a pUmiProperty. Ideally we should
// tag this in some way so that we can check to make sure.
//
hr = FreeUmiPropertyValues((UMI_PROPERTY_VALUES *)pMem);
}
else {
hr = E_INVALIDARG;
}
error:
if (FAILED(hr)) {
SetLastStatus(hr);
hr = MapHrToUmiError(hr);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::Delete (IUmiPropList support).
//
// Synopsis: Delete the named property from the cache.
//
// Arguments: pszName - Name of property to delete.
// uFlags - Standard flags parameter.
//
// Returns: E_NOTIMPL.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::Delete(
IN LPCWSTR pszName,
IN ULONG uFlags
)
{
SetLastStatus(E_NOTIMPL);
RRETURN(E_NOTIMPL);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetProps (IUmiPropList support).
//
// Synopsis: Gets the values for the attributes. This will read data
// from the server as needed.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: UMI_PROPERTY_VALUES* has the an array of values for the
// attributes. Note that there is no ordering specified
// for the return values.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::GetProps(
IN LPCWSTR* pszNames,
IN ULONG uNameCount,
IN ULONG uFlags,
OUT UMI_PROPERTY_VALUES **pProps
)
{
HRESULT hr = S_OK;
if ((uFlags != UMI_FLAG_GETPROPS_NAMES)
&& (uFlags != UMI_FLAG_GETPROPS_SCHEMA)
) {
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
}
//
// Currently we support only getting the names of all the properties.
//
if (pszNames
|| uNameCount
|| !pProps
) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
*pProps = NULL;
if (_fPropCacheMode) {
//
// Only UMI_FLAG_GETPROPS_NAMES is valid in this case.
//
if (uFlags != UMI_FLAG_GETPROPS_NAMES) {
BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
}
hr = _pPropCache->GetPropertyNames(pProps);
}
else {
//
// Need to see what type of flag it is and extra check needed,
// if this is UMI_FLAGS_GETPROPS_SCHEMA.
//
if (uFlags == UMI_FLAG_GETPROPS_SCHEMA) {
LONG lVal;
hr = GetLongProperty(L"__GENUS", &lVal);
BAIL_ON_FAILURE(hr);
if (lVal != UMI_GENUS_CLASS) {
BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
}
hr = GetPropertyNamesSchema(pProps);
}
else {
//
// Need to do get our static list.
//
hr = this->GetPropertyNames(pProps);
}
} // else for !propertyCacheMode.
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::PutProps (IUmiPropList support).
//
// Synopsis: Puts the value for the attributes in the cache.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Property cache for the object.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::PutProps(
IN LPCWSTR* pszNames,
IN ULONG uNameCount,
IN ULONG uFlags,
IN UMI_PROPERTY_VALUES *pProps
)
{
HRESULT hr = S_OK;
//
// When done - should get and put multiple work directly of the server ?
// That would take care off problems like 5 can be put in the cache
// but sixth cannot ...
//
SetLastStatus(E_NOTIMPL);
RRETURN(E_NOTIMPL);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::PutFrom (IUmiPropList support).
//
// Synopsis: Clarify exactly what this is supposed to do ?
//
// Arguments: self explanatory
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Property cache for the object.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CPropertyManager::PutFrom(
IN LPCWSTR pszName,
IN ULONG uFlags,
IN ULONG uBufferLength,
IN LPVOID pExistingMem
)
{
SetLastStatus(E_NOTIMPL);
RRETURN(E_NOTIMPL);
}
//
// PropertyManager methods that are not part of the IUmiPropList interface.
//
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetLastStatus
//
// Synopsis: Returns the error from the last operation on this object.
// For now only the status code is supported.
//
// Arguments: uFlags - Must be 0 for now.
// puSpecificStatus - Status is returned in this value.
// riid - IID requested on status obj.
// pStatusObj - Must be NULL for now.
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: *puSpecificStatus with last status code.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetLastStatus(
ULONG uFlags,
ULONG *puSpecificStatus,
REFIID riid,
LPVOID *pStatusObj
)
{
if (!puSpecificStatus || pStatusObj) {
RRETURN(E_INVALIDARG);
}
if (uFlags) {
RRETURN(UMI_E_INVALID_FLAGS);
}
*puSpecificStatus = _ulStatus;
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::AddProperty.
//
// Synopsis: Updates the value of the property to the interface
// property cache. This fn is called only in interface mode.
// If necessary the property will be added to the cache.
//
// Arguments: self explanatory
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Changes the internal property table.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::AddProperty(
LPCWSTR szPropertyName,
UMI_PROPERTY umiProperty
)
{
HRESULT hr = S_OK;
DWORD dwIndex = (DWORD) -1;
BOOL fAddedName = FALSE;
//
// Make sure we do not have property in the cache.
//
hr = FindProperty(szPropertyName, &dwIndex);
if (FAILED(hr)) {
//
// We actually need to add this property in our list.
//
hr = AddToTable(szPropertyName, &dwIndex);
fAddedName = TRUE;
}
BAIL_ON_FAILURE(hr);
//
// At this point we can just dump the value into the cache.
//
hr = UpdateProperty(
dwIndex,
umiProperty
);
BAIL_ON_FAILURE(hr);
error:
if (FAILED(hr) && fAddedName) {
//
// Do we delete the name from the cache.
//
DeleteProperty(dwIndex);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::UpdateProperty.
//
// Synopsis: Updates the value of an interface property in the local cache.
// The assumption is that this function is only called with from
// AddProperty (or anywhere else where we have the correct index).
//
// Arguments: dwIndex - index in our table of the property to update
// UMI_PROPERTY - the value to add to our table, note that
// if the operation is delete we should remove the element
// from our table (value returned if any will be default value
// for subsequent get calls).
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Underlying data in the cache is changed
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::UpdateProperty(
DWORD dwIndex,
UMI_PROPERTY umiProp
)
{
HRESULT hr = E_NOTIMPL;
DWORD dwFlags, dwCacheSyntaxId, dwNumElements;
PUMI_PROPERTY pUmiProperty = NULL;
if (!_pIntfProperties) {
//
// Should we check the index ? It is after all an internal
// value, so it should not be wrong.
//
BAIL_ON_FAILURE(hr = E_FAIL);
}
//
// Only update and delete are really supported.
//
if ((umiProp.uOperationType != UMI_OPERATION_UPDATE)
&& (umiProp.uOperationType != UMI_OPERATION_DELETE_ALL_MATCHES)) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
if (_pIntfProperties[dwIndex].pUmiProperty) {
//
// Free the current data in the table and set initial values.
//
hr = FreeOneUmiProperty(*(_pIntfProperties[dwIndex].pUmiProperty));
BAIL_ON_FAILURE(hr);
FreeADsMem(_pIntfProperties[dwIndex].pUmiProperty);
_pIntfProperties[dwIndex].pUmiProperty = NULL;
_pIntfProperties[dwIndex].dwFlags = 0;
_pIntfProperties[dwIndex].dwSyntaxId = 0;
}
//
// Copy the value to temp variable, so we can handle failures gracefully.
//
hr = CopyUmiProperty(
umiProp,
&pUmiProperty
);
BAIL_ON_FAILURE(hr);
_pIntfProperties[dwIndex].pUmiProperty = pUmiProperty;
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::FindProperty.
//
// Synopsis: Searches for the specified property in the local cache.
//
// Arguments: szPropertyName, name of property.
// pdwIndex - pointer to DWORD with index in table.
//
// Returns: HRESULT - S_OK or E_ADS_PROPERTY_NOT_FOUND.
//
// Modifies: *pdwIndex to.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::FindProperty(
LPCWSTR szPropertyName,
PDWORD pdwIndex
)
{
DWORD dwIndex;
if (!_pIntfProperties) {
RRETURN(E_ADS_PROPERTY_NOT_FOUND);
}
for (dwIndex = 0; dwIndex < _dwMaxProperties; dwIndex++) {
if (_wcsicmp(
_pIntfProperties[dwIndex].pszPropertyName,
szPropertyName
) == 0) {
*pdwIndex = dwIndex;
RRETURN(S_OK);
}
}
RRETURN(E_ADS_PROPERTY_NOT_FOUND);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::DeleteProperty.
//
// Synopsis: Deletes the property specified from the cahce.
//
// Arguments: Index to element to delete.
//
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Underlying data in the cache is changed.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::DeleteProperty(
DWORD dwIndex
)
{
HRESULT hr = S_OK;
INTF_PROPERTY* pIntfProp = NULL;
if (_pIntfProperties && ((_dwMaxProperties-1) < dwIndex)) {
//
// Valid property in cache.
//
pIntfProp = _pIntfProperties + dwIndex;
ADsAssert(pIntfProp);
if (pIntfProp->pszPropertyName) {
FreeADsStr(pIntfProp->pszPropertyName);
pIntfProp->pszPropertyName = NULL;
}
//
// Now Copy over the rest of the data here.
//
}
else {
hr = E_FAIL;
}
RRETURN (hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::FlushPropertyCache.
//
// Synopsis: Clear all internal data in the property cache.
//
// Arguments:
//
// Returns: N/A
//
// Modifies: Underlying data in the cache is changed
//
//----------------------------------------------------------------------------
VOID
CPropertyManager::flushpropertycache()
{
//
// Free any data in our table
if (_pIntfProperties) {
for (DWORD dwCtr = 0; (dwCtr < _dwMaxProperties); dwCtr++) {
INTF_PROPERTY *pIntfProp = (PINTF_PROPERTY)_pIntfProperties+ dwCtr;
if (pIntfProp) {
if (pIntfProp->pszPropertyName) {
FreeADsStr(pIntfProp->pszPropertyName);
pIntfProp->pszPropertyName = NULL;
}
}
}
//
// Now free the array of pointers.
//
FreeADsMem((void *) _pIntfProperties);
_pIntfProperties = NULL;
}
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::ClearAllPropertyFlags.
//
// Synopsis: Resets all property flags to zero.
//
// Arguments: None.
//
// Returns: HRESULT - S_OK or any failure error code.
//
// Modifies: Underlying data in the cache is changed.
//
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::ClearAllPropertyFlags(
VOID
)
{
RRETURN(E_NOTIMPL);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetPropertyNames.
//
// Synopsis: Returns list of names of interface properties available.
//
// Arguments: out params only
//
// Returns: HRESULT - S_OK or any failure error code
//
// Modifies: ppStringsNames to point to valid array of strings.
// pUlCount to point to number of strings in the array.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetPropertyNames(
PUMI_PROPERTY_VALUES *pUmiProps
)
{
HRESULT hr = S_OK;
PUMI_PROPERTY_VALUES pUmiPropVals = NULL;
PUMI_PROPERTY pUmiProperties = NULL;
DWORD dwCtr, dwPropCount = 0;
pUmiPropVals = (PUMI_PROPERTY_VALUES) AllocADsMem(
sizeof(UMI_PROPERTY_VALUES)
);
if (!pUmiPropVals) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Need to count the properties.
//
while (_pStaticPropData[dwPropCount].pszPropertyName) {
dwPropCount++;
}
if (!dwPropCount) {
*pUmiProps = pUmiPropVals;
RRETURN(S_OK);
}
pUmiProperties = (PUMI_PROPERTY) AllocADsMem(
sizeof(UMI_PROPERTY) * dwPropCount
);
if (!pUmiProperties) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Need to go through the table and alloc the values.
//
for (dwCtr = 0; dwCtr < dwPropCount; dwCtr++) {
pUmiProperties[dwCtr].pszPropertyName =
AllocADsStr(_pStaticPropData[dwCtr].pszPropertyName);
if (!pUmiProperties[dwCtr].pszPropertyName) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pUmiProperties[dwCtr].uType = UMI_TYPE_NULL;
}
pUmiPropVals->pPropArray = pUmiProperties;
pUmiPropVals->uCount = dwPropCount;
*pUmiProps = pUmiPropVals;
RRETURN(S_OK);
error :
if (pUmiProperties) {
for (dwCtr = 0; dwCtr < dwPropCount; dwCtr++) {
if (pUmiProperties[dwCtr].pszPropertyName) {
FreeADsStr(pUmiProperties[dwCtr].pszPropertyName);
}
}
FreeADsMem(pUmiProperties);
}
if (pUmiPropVals) {
FreeADsMem(pUmiPropVals);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetPropertyNamesSchema
//
// Synopsis: Returns list of the names and types of the properties this
// object can contain. Note that this method is valid only if the
// underlying object is an instance of class Class (schema class).
//
// Arguments: out params only
//
// Returns: HRESULT - S_OK or any failure error code
//
// Modifies:
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetPropertyNamesSchema(
PUMI_PROPERTY_VALUES *pUmiProps
)
{
HRESULT hr = S_OK;
IADsUmiHelperPrivate *pIADsUmiPriv = NULL;
// Array of ptr to PROPERTYINFO
PPROPERTYINFO *pPropArray = NULL;
DWORD dwPropCount = 0;
PUMI_PROPERTY_VALUES pUmiPropVals = NULL;
PUMI_PROPERTY pUmiProperties = NULL;
//
// Need a ptr to the helper routine.
//
hr = this->_pIADs->QueryInterface(
IID_IADsUmiHelperPrivate,
(void **) &pIADsUmiPriv
);
if (hr == E_NOINTERFACE) {
BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
}
hr = pIADsUmiPriv->GetPropertiesHelper(
(void**) &pPropArray,
&dwPropCount
);
BAIL_ON_FAILURE(hr);
//
// Need to prepare the return values.
//
pUmiPropVals = (PUMI_PROPERTY_VALUES) AllocADsMem(
sizeof(UMI_PROPERTY_VALUES)
);
if (!pUmiPropVals) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (!dwPropCount) {
*pUmiProps = pUmiPropVals;
RRETURN(S_OK);
}
pUmiProperties = (PUMI_PROPERTY) AllocADsMem(
sizeof(UMI_PROPERTY) * dwPropCount
);
if (!pUmiProperties) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (DWORD dwCtr = 0; dwCtr < dwPropCount; dwCtr++) {
DWORD dwSyntaxId = 0;
pUmiProperties[dwCtr].pszPropertyName =
AllocADsStr(pPropArray[dwCtr]->pszPropertyName);
if (!pUmiProperties[dwCtr].pszPropertyName) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Need to update the type with the type from the schema.
//
dwSyntaxId = LdapGetSyntaxIdOfAttribute(
pPropArray[dwCtr]->pszSyntax
);
//
// If we get dwSyntaxId == -1 we could not find the entry in
// our table.
//
if (dwSyntaxId == -1) {
pUmiProperties[dwCtr].uType = UMI_TYPE_UNDEFINED;
}
else {
hr = ConvertLdapSyntaxIdToUmiType(
dwSyntaxId,
(pUmiProperties[dwCtr].uType)
);
if (FAILED(hr)) {
hr = S_OK;
//
// Cannot do anything about this.
//
pUmiProperties[dwCtr].uType = UMI_TYPE_UNDEFINED;
}
//
// If this property is multivalued.
//
if (!pPropArray[dwCtr]->fSingleValued) {
pUmiProperties[dwCtr].uType |= UMI_TYPE_ARRAY_FLAG;
}
}
} // for each property.
pUmiPropVals->pPropArray = pUmiProperties;
pUmiPropVals->uCount = dwPropCount;
*pUmiProps = pUmiPropVals;
error:
if (pIADsUmiPriv) {
pIADsUmiPriv->Release();
}
//
// Need to free the array not the elements which are ptrs into
// the global parsed schema's we hold.
//
if (pPropArray) {
FreeADsMem(pPropArray);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetInterfaceProperty
//
// Synopsis: Gets the interface property from the owning object or the
// default value and packages the value as an UMI_PROPERTY_VALUE.
//
// Arguments: pszName - name of property to get.
// uFlags - flags has to be zero for now.
// ppProp - value is returned in this ptr.
// dwTableIndex - index to entry in table describing this item.
//
// Returns: HRESULT - S_OK or any failure error code
//
// Modifies: ppProp which will point to return value if the fn succeeds.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetInterfaceProperty(
LPCWSTR pszName,
ULONG uFlags,
UMI_PROPERTY_VALUES **ppProp,
DWORD dwTableIndex
)
{
HRESULT hr;
ULONG ulOperationAllowed = _pStaticPropData[dwTableIndex].ulOpCode;
ULONG ulVal;
LONG lGenus;
LPWSTR pszStringVal = NULL;
BSTR bstrRetVal = NULL, bstrTempVal = NULL;
LPWSTR pszUmiUrl = NULL;
IADsObjectOptions *pObjOpt = NULL;
VARIANT vVariant;
DWORD dwIndex;
PUMI_PROPERTY pUmiPropLocal = NULL;
IUnknown *pUnk = NULL;
IUmiObject *pUmiObj = NULL;
BOOL fUnkPtr = FALSE;
BOOL fClassInstance = FALSE;
VariantInit(&vVariant);
if (!_pUnk) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
//
// If the property is READ/WRITE, we need to see if there is a value
// in the propCache. If yes, return that. If not return the default
// value.
//
if (ulOperationAllowed == OPERATION_CODE_READWRITE) {
hr = FindProperty(pszName, &dwIndex);
//
// If it succeeded it was updated in the cache.
//
if (SUCCEEDED(hr)) {
hr = CopyUmiProperty(
*(_pIntfProperties[dwIndex].pUmiProperty),
&pUmiPropLocal
);
BAIL_ON_FAILURE(hr);
//
// We need to free the name of the first property cause
// that is allocated again by the Get call.
//
if (pUmiPropLocal && pUmiPropLocal->pszPropertyName) {
FreeADsStr(pUmiPropLocal->pszPropertyName);
pUmiPropLocal->pszPropertyName = NULL;
}
//
// Got the property need to package in umi property values.
//
*ppProp = (PUMI_PROPERTY_VALUES) AllocADsMem(
sizeof(UMI_PROPERTY_VALUES)
);
if (!*ppProp) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
(*ppProp)->pPropArray = pUmiPropLocal;
(*ppProp)->uCount = 1;
RRETURN(hr);
} // value found in cache
else {
//
// Setting this should trigger a read of the default
// value for this property.
//
ulOperationAllowed = OPERATION_CODE_READABLE;
}
}
//
// We need to check for the securityDescriptor as that needs
// some special handling.
//
if (!_wcsicmp(pszName, L"__SECURITY_DESCRIPTOR")) {
//
// Need to read this from the actual object.
//
hr = _pUnk->QueryInterface(IID_IUmiObject, (void **) &pUmiObj);
BAIL_ON_FAILURE(hr);
hr = pUmiObj->GetAs(
L"ntSecurityDescriptor",
uFlags,
UMI_TYPE_OCTETSTRING,
ppProp
);
if (SUCCEEDED(hr)) {
//
// Need to make sure that we do not set name twice.
//
if (*ppProp
&& (*ppProp)[0].pPropArray
&& (*ppProp)[0].pPropArray[0].pszPropertyName
) {
FreeADsStr((*ppProp)[0].pPropArray[0].pszPropertyName);
(*ppProp)[0].pPropArray[0].pszPropertyName = NULL;
}
}
//
// This seems the cleanest ...
//
goto error;
}
//
// If the property is only readable, then get it from owning object.
// If not get the value from cache or use defualt value as appropriate.
//
if (ulOperationAllowed == OPERATION_CODE_READABLE) {
hr = GetLongProperty(L"__GENUS", &lGenus);
if (FAILED(hr)) {
//
// There was no genus property = connection for example.
//
fClassInstance = FALSE;
}
else if (lGenus == UMI_GENUS_CLASS) {
fClassInstance = TRUE;
}
//
// The value can be a string/long for now and it has to
// be either the default value or the value from the owning object.
//
switch (_pStaticPropData[dwTableIndex].ulDataType) {
case UMI_TYPE_I4:
//
// Use default value from the static table.
//
vVariant.lVal = _pStaticPropData[dwTableIndex].umiVal.lValue[0];
hr = ConvertVariantLongToUmiProp(vVariant, ppProp);
break;
case UMI_TYPE_BOOL:
//
// Use default value from table.
//
vVariant.lVal = _pStaticPropData[dwTableIndex].umiVal.bValue[0];
hr = ConvertVariantLongToUmiProp(vVariant, ppProp);
(*ppProp)[0].pPropArray[0].uType = UMI_TYPE_BOOL;
break;
case UMI_TYPE_LPWSTR:
//
// In this case it has to be NULL.
//
hr = GetEmptyLPWSTRProp(ppProp);
break;
case 9999:
if (!_pIADs) {
//
// Nothing we can do here !
//
BAIL_ON_FAILURE(hr = E_FAIL);
}
if (!_wcsicmp(pszName, L"__Path")) {
hr = _pIADs->get_ADsPath(&bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__Class")) {
if (fClassInstance) {
//
// For classes, the class is the name,
// not "class" itself.
//
hr = _pIADs->get_Name(&bstrRetVal);
}
else {
hr = _pIADs->get_Class(&bstrRetVal);
}
}
else if (!_wcsicmp(pszName, L"__KEY")) {
hr = _pIADs->get_Name(&bstrRetVal);
BAIL_ON_FAILURE(hr);
if (SUCCEEDED(hr)) {
hr = HelperConvertNameToKey(bstrRetVal, &pszUmiUrl);
}
}
else if (!_wcsicmp(pszName, L"__GUID")) {
hr = _pIADs->get_GUID(&bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__Parent")) {
hr = _pIADs->get_Parent(&bstrRetVal);
if (SUCCEEDED(hr)) {
hr = ADsPathToUmiURL(bstrRetVal, &pszUmiUrl);
}
}
else if (!_wcsicmp(pszName, L"__Schema")) {
hr = _pIADs->get_Schema(&bstrRetVal);
//
// Now need to bind to this object.
//
if (SUCCEEDED(hr)) {
hr = GetObject(
bstrRetVal,
*_pCreds,
(void **) &pUnk
);
BAIL_ON_FAILURE(hr);
fUnkPtr = TRUE;
}
}
else if (!_wcsicmp(pszName, L"__URL")) {
hr = _pIADs->get_ADsPath(&bstrTempVal);
if (SUCCEEDED(hr)) {
hr = ADsPathToUmiURL(bstrTempVal, &pszUmiUrl);
}
}
else if (!_wcsicmp(pszName, L"__Name")) {
if (fClassInstance) {
hr = _pIADs->get_Name(&bstrRetVal);
} else {
hr = HelperGetUmiRelUrl(_pIADs, &bstrRetVal);
}
}
else if (!_wcsicmp(pszName, L"__RELURL")) {
hr = HelperGetUmiRelUrl(_pIADs, &bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__RELPATH")) {
hr = HelperGetUmiRelUrl(_pIADs, &bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__FULLRELURL")) {
//
// Same as __RELURL, __NAME and __RELPATH
//
hr = HelperGetUmiRelUrl(_pIADs, &bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__PADS_SCHEMA_CONTAINER_PATH")) {
hr = HelperGetUmiSchemaContainerPath(_pIADs, &bstrRetVal);
}
else if (!_wcsicmp(pszName, L"__SUPERCLASS")) {
if (!fClassInstance) {
//
// Only supported if this is a class.
//
hr = E_FAIL;
}
else {
hr = HelperGetUmiDerivedFrom(_pIADs, &bstrRetVal);
}
}
else {
hr = E_FAIL;
}
BAIL_ON_FAILURE(hr);
//
// If not schema then it has to be a string.
//
if (!fUnkPtr) {
hr = ConvertBSTRToUmiProp(
pszUmiUrl ? pszUmiUrl:bstrRetVal,
ppProp
);
}
else {
hr = ConvertIUnkToUmiProp(
pUnk,
IID_IUmiObject,
ppProp
);
}
break;
default:
hr = E_FAIL;
} // end of switch
BAIL_ON_FAILURE(hr);
} // opeartion code is READABLE.
else {
hr = E_FAIL;
}
error:
if (pObjOpt) {
pObjOpt->Release();
}
VariantClear(&vVariant);
if (bstrRetVal) {
SysFreeString(bstrRetVal);
}
if (bstrTempVal) {
SysFreeString(bstrTempVal);
}
if (pszUmiUrl) {
FreeADsStr(pszUmiUrl);
}
if (pUnk) {
pUnk->Release();
}
if (pUmiObj) {
pUmiObj->Release();
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::DeleteSDIfPresent --- Helper method.
//
// Synopsis: Helps remove the SD from the property cache so that we do not
// set it when we Commit the changes.
//
// Arguments: N/A.
//
// Returns: HRESULT - S_OK or any failure error code
//
// Modifies: Underlying property cache.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::DeleteSDIfPresent()
{
HRESULT hr = S_OK;
DWORD dwIndex = 0;
if (!_fPropCacheMode) {
//
// Sanity check, should never be here.
//
RRETURN(S_OK);
}
if (!_pPropCache) {
//
// Want to delete SD when we do not have a cache - weird.
//
RRETURN(S_OK);
}
hr = _pPropCache->findproperty(L"ntSecurityDescriptor", &dwIndex);
if (FAILED(hr)) {
RRETURN(S_OK);
}
else {
//
// Get rid of this from the cache.
//
_pPropCache->deleteproperty(dwIndex);
}
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetIndexInStaticTable
//
// Synopsis: Verifies that the named property can be found in the list of
// valid properties and returns the index.
//
// Arguments: Self explanatory.
//
// Returns: S_OK or E_ADS_PROPERTY_NOT_FOUND as appropriate.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetIndexInStaticTable(
LPCWSTR pszName,
DWORD &dwIndex
)
{
for (DWORD dwCtr = 0;
_pStaticPropData[dwCtr].pszPropertyName;
dwCtr++ ) {
if (!_wcsicmp(
pszName,
_pStaticPropData[dwCtr].pszPropertyName
)) {
dwIndex = dwCtr;
RRETURN(S_OK);
}
}
RRETURN(E_ADS_PROPERTY_NOT_FOUND);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::VerifyIfValidProperty.
//
// Synopsis: Makes sure that a valid interface property is being set. This
// function is called internally if we know we are not in the
// property cache mode. The internal static table pointer is used to
// verify the property.
//
// Arguments: Self explanatory.
//
// Returns: Bool - True or False as appropriate.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
BOOL
CPropertyManager::VerifyIfValidProperty(
LPCWSTR pszPropertyName,
UMI_PROPERTY umiProperty
)
{
DWORD dwIndex;
//
// if _pStaticPropData is NULL then there are no interface properties.
// If the count is zero, then the only operation is delete.
//
if ((!_pStaticPropData)
|| ((umiProperty.uCount == 0)
&& (umiProperty.uOperationType != UMI_OPERATION_DELETE_ALL_MATCHES)
)
)
{
return FALSE;
}
if (SUCCEEDED(GetIndexInStaticTable(
pszPropertyName,
dwIndex
))
) {
//
// Verify type and if property can be changed.
// If the types do not match we should still allow 9999 for
// things like __SECURITY_DESCRIPTOR that can be changed.
// If the attribute cannot be written, then the next part of
// the check will fail, so you still wont be able to write
// things the __URL property.
//
if (((_pStaticPropData[dwIndex].ulDataType == umiProperty.uType)
|| (_pStaticPropData[dwIndex].ulDataType == 9999))
&& (_pStaticPropData[dwIndex].ulOpCode
!= OPERATION_CODE_READABLE)
) {
//
// Need to make sure count is correct.
//
if ((umiProperty.uCount > 1)
&& (!_pStaticPropData[dwIndex].fMultiValued)
) {
return FALSE;
}
return TRUE;
}
}
//
// Either we did not satisfy requirements or not found
//
return FALSE;
}
HRESULT
CPropertyManager::AddToTable(
LPCWSTR pszPropertyName,
PDWORD pdwIndex
)
{
HRESULT hr = S_OK;
PINTF_PROPERTY pNewProperty = NULL;
//
// Check to see if the table is already there. If not create
// the table with potential to store upto 10 entries. This should
// suffice unless we have more properties. Set the current pointer
// and current top appropriately.
//
if (!_pIntfProperties) {
_pIntfProperties = (PINTF_PROPERTY) AllocADsMem(
sizeof(INTF_PROPERTY) * MAX_PROPMGR_PROP_COUNT
);
if (!_pIntfProperties) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
_dwMaxProperties = 0;
_dwMaxLimit = MAX_PROPMGR_PROP_COUNT;
}
if ((_dwMaxProperties+1) < _dwMaxLimit) {
//
// We can add this property to the table.
//
DWORD dwTop;
dwTop = _dwMaxProperties++;
_pIntfProperties[dwTop].pszPropertyName =
AllocADsStr(pszPropertyName);
if (!_pIntfProperties[dwTop].pszPropertyName) {
//
// Reset the count.
//
_dwMaxProperties--;
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
*pdwIndex = dwTop;
}
else {
//
// We do not have space in the table - return an error.
//
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetStringProperty.
//
// Synopsis: Retrieves the string property if one is set in the cache or
// returns NULL if the property is not in the cache. The assumption
// here is that string properties are defaulted to NULL always.
//
// Arguments: Self explanatory.
//
// Returns: S_OK, UMI_E_NOT_FOUND, E_FAIL.
//
// Modifies: pszRetVal to point to the appropriate value.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetStringProperty(
LPCWSTR pszPropName,
LPWSTR *ppszRetStrVal
)
{
DWORD dwIndex;
HRESULT hr = FindProperty(pszPropName, &dwIndex);
PUMI_PROPERTY pUmiProp;
if (FAILED(hr)) {
//
// Do we lookup the static table ? The table wont have strings in
// it though cause the union assumes chars.
//
*ppszRetStrVal = NULL;
RRETURN(S_OK);
}
pUmiProp = _pIntfProperties[dwIndex].pUmiProperty;
//
// Make sure that this is a string.
//
if (pUmiProp->uType != UMI_TYPE_LPWSTR) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
if (pUmiProp->pUmiValue
&& pUmiProp->pUmiValue->pszStrValue[0]) {
*ppszRetStrVal = AllocADsStr(pUmiProp->pUmiValue->pszStrValue[0]);
if (!*ppszRetStrVal) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetLongProperty - Helper method.
//
// Synopsis: Retrieves the long property if one is set in the cache or
// returns the defaulted value if the property is not in the cache.
//
// Arguments: pszPropName --- Name of property being retrieved.
// plVal --- Ptr for return value.
//
// Returns: S_OK, UMI_E_NOT_FOUND or E_FAIL.
//
// Modifies: *plVal with appropriate value.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetLongProperty(
LPCWSTR pszPropName,
LONG *plVal
)
{
DWORD dwIndex;
HRESULT hr = FindProperty(pszPropName, &dwIndex);
PUMI_PROPERTY pUmiProp;
*plVal = 0;
if (FAILED(hr)) {
//
// We need to look for the property in the static table.
//
hr = GetIndexInStaticTable(pszPropName, dwIndex);
if (SUCCEEDED(hr)
&& (_pStaticPropData[dwIndex].ulDataType == UMI_TYPE_I4)
) {
//
// Get the correct value from the table.
//
*plVal = _pStaticPropData[dwIndex].umiVal.lValue[0];
}
else {
hr = UMI_E_NOT_FOUND;
}
RRETURN(hr);
}
pUmiProp = _pIntfProperties[dwIndex].pUmiProperty;
//
// Make sure that this is a long.
//
if (pUmiProp->uType != UMI_TYPE_I4) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
if (pUmiProp->pUmiValue) {
*plVal = pUmiProp->pUmiValue->lValue[0];
}
error:
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CPropertyManager::GetBoolProperty - Helper method.
//
// Synopsis: Retrieves the bool property if one is set in the cache or
// returns the defaulted value if the property is not in the cache.
//
// Arguments: pszPropName --- Name of property being retrieved.
// pfFlag --- Ptr for return value.
//
// Returns: S_OK, UMI_E_NOT_FOUND or E_FAIL.
//
// Modifies: ofFlag with appropriate value of the property.
//
//----------------------------------------------------------------------------
HRESULT
CPropertyManager::GetBoolProperty(
LPCWSTR pszPropName,
BOOL *pfFlag
)
{
DWORD dwIndex;
HRESULT hr = FindProperty(pszPropName, &dwIndex);
PUMI_PROPERTY pUmiProp;
*pfFlag = FALSE;
if (FAILED(hr)) {
//
// We need to look for the property in the static table.
//
hr = GetIndexInStaticTable(pszPropName, dwIndex);
if (SUCCEEDED(hr)
&& (_pStaticPropData[dwIndex].ulDataType == UMI_TYPE_BOOL)
) {
//
// Get the correct value from the table.
//
*pfFlag = _pStaticPropData[dwIndex].umiVal.bValue[0];
}
else {
hr = E_FAIL;
}
RRETURN(hr);
}
pUmiProp = _pIntfProperties[dwIndex].pUmiProperty;
//
// Make sure that this is a long.
//
if (pUmiProp->uType != UMI_TYPE_BOOL) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
if (pUmiProp->pUmiValue) {
*pfFlag = pUmiProp->pUmiValue->bValue[0];
}
error:
RRETURN(hr);
}
Reference in New Issue View Git Blame Copy Permalink