windows-xp/Source/XPSP1/NT/ds/adsi/winnt/cumiprop.cxx

//----------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 2000.
//
//  File:     cumiprop.cxx
//
//  Contents: Contains the property list implementation for UMI. This will
//            be used for both interface properties and object properties. 
//
//  History:  02-28-00    SivaramR  Created.
//
//----------------------------------------------------------------------------

#include "winnt.hxx"

//----------------------------------------------------------------------------
// Function:   CUmiPropList 
//
// Synopsis:   Constructor. Stores off schema (list of available properties,
//             their types etc.) and the size of the schema. 
//
// Arguments:  Self explanatory
//
// Returns:    Nothing 
//
// Modifies:   Nothing 
//
//----------------------------------------------------------------------------
CUmiPropList::CUmiPropList(PPROPERTYINFO pSchema, DWORD dwSchemaSize)
{
    m_pSchema = pSchema;
    m_dwSchemaSize = dwSchemaSize;
    m_pPropCache = NULL;
    m_fIsIntfPropObj = TRUE; 
    m_ulErrorStatus = 0;
    m_pszSchema = NULL;
    m_pClassInfo = NULL;
    m_fIsNamespaceObj = FALSE;
    m_fIsClassObj = FALSE;
    m_fDisableWrites = FALSE;
    m_ppszUnImpl = NULL;
}

//----------------------------------------------------------------------------
// Function:   CUmiPropList
//
// Synopsis:   Constructor. Stores off schema (list of available properties,
//             their types etc.) and the size of the schema.
//
// Arguments:  Self explanatory
//
// Returns:    Nothing
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
CUmiPropList::~CUmiPropList(void)
{
    if( (m_pPropCache != NULL) && (TRUE == m_fIsIntfPropObj) )
        delete m_pPropCache;

    if(m_pszSchema != NULL)
        FreeADsStr(m_pszSchema);

    return;
}

//----------------------------------------------------------------------------
// Function:   QueryInterface
//
// Synopsis:   Queries property list object for supported interfaces. Only
//             IUmiPropList is supported.
//
// Arguments:
//
// iid         interface requested
// ppInterface Returns pointer to interface requested. NULL if interface
//             is not supported.
//
// Returns:    S_OK on success. Error code otherwise.
//
// Modifies:   *ppInterface to return interface pointer
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::QueryInterface(
    REFIID iid,
    LPVOID *ppInterface
    )
{
    if(NULL == ppInterface)
        RRETURN(E_INVALIDARG);

    *ppInterface = NULL;

    if(IsEqualIID(iid, IID_IUnknown))
        *ppInterface = (IUmiPropList *) this;
    else if(IsEqualIID(iid, IID_IUmiPropList))
        *ppInterface = (IUmiPropList *) this;
    else
         RRETURN(E_NOINTERFACE);

    AddRef();
    RRETURN(S_OK);
}

//----------------------------------------------------------------------------
// Function:   FInit
// 
// Synopsis:   Initializes the property list object. 
//
// Arguments:
//
// pPropCache  Pointer to the property cache object. This argument will be
//             NULL if this object is for interface properties. In this case,
//             a new property cache is allocated by this function. If this
//             object is for object properties, then this argument points
//             to the property cache of the WinNT object.
// ppszUnImpl  Array of standard property names that are not implemented.
//             This is used on an interface property object to return E_NOTIMPL
//             as the error code.
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::FInit(CPropertyCache *pPropCache, LPWSTR *ppszUnImpl)
{
    HRESULT hr = UMI_S_NO_ERROR;

    if(NULL == pPropCache) {
        hr = CPropertyCache::createpropertycache(
                m_pSchema,
                m_dwSchemaSize,
                NULL,    // this will ensure that the WinNT property cache
                         // won't do implicit GetInfo for interface properties
                &m_pPropCache);

        BAIL_ON_FAILURE(hr);

        m_ppszUnImpl = ppszUnImpl; 
    }
    else {
        m_fIsIntfPropObj = FALSE;
        m_pPropCache = pPropCache;
    }
       
    RRETURN(UMI_S_NO_ERROR);

error:

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   SetLastStatus
//
// Synopsis:   Sets the status of the last operation. 
//
// Arguments:
//
// ulStatus    Status to be set
//
// Returns:    Nothing
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
void CUmiPropList::SetLastStatus(ULONG ulStatus)
{
    m_ulErrorStatus = ulStatus;

    return;
}

//----------------------------------------------------------------------------
// Function:   GetLastStatus
//
// Synopsis:   Returns status or error code from the last operation. Currently
//             only numeric status is returned i.e, no error objects are
//             returned. 
//
// Arguments:
//
// uFlags           Reserved. Must be 0 for now.
// puSpecificStatus Returns status code
// riid             IID requested. Ignored currently.
// pStatusObj       Returns interface requested. Always returns NULL currently.
//
// Returns:         UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:        *puSpecificStatus to return status code.
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetLastStatus(
    ULONG uFlags,
    ULONG *puSpecificStatus,
    REFIID riid,
    LPVOID *pStatusObj
    )
{
    if(pStatusObj != NULL)
       *pStatusObj = NULL;

    if(puSpecificStatus != NULL)
        *puSpecificStatus = 0;

    if(uFlags != 0)
        RRETURN(UMI_E_INVALID_FLAGS);

    if(NULL == puSpecificStatus)
        RRETURN(UMI_E_INVALIDARG);

    *puSpecificStatus = m_ulErrorStatus;

    RRETURN(UMI_S_NO_ERROR);
}

//----------------------------------------------------------------------------
// Function:   Put 
//
// Synopsis:   Implements IUmiPropList::Put. Writes a property into the cache. 
//
// Arguments: 
//
// pszName     Name of the property
// uFlags      Flags for the Put operation. Unused currently.
// pProp       Pointer to the structure containing the value 
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise. 
//
// Modifies:   Nothing. 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::Put( 
    LPCWSTR pszName,
    ULONG uFlags,
    UMI_PROPERTY_VALUES *pProp
    )
{
    HRESULT      hr = UMI_S_NO_ERROR;
    DWORD        dwSyntaxId  = 0, dwIndex = 0;
    UMI_PROPERTY *pPropArray = NULL;
    LPNTOBJECT   pNtObject = NULL;
    BOOL         fMarkAsClean = FALSE;

    SetLastStatus(0);

    // fail if we have disabled writes
    if( (TRUE == m_fDisableWrites) && (TRUE == m_fIsIntfPropObj) )
        BAIL_ON_FAILURE(hr = UMI_E_READ_ONLY); 

    // check args
    hr = ValidatePutArgs(
            pszName,
            uFlags,
            pProp
            );
    BAIL_ON_FAILURE(hr);

    // is this a standard interface property that's not implemented?
    if(m_ppszUnImpl != NULL) {
        while(m_ppszUnImpl[dwIndex] != NULL) {
            if(0 == _wcsicmp(m_ppszUnImpl[dwIndex], pszName)) {
                BAIL_ON_FAILURE(hr = UMI_E_NOTIMPL);
            }
            dwIndex++;
        }
    }

    // check if the property is in the schema
    hr = ValidatePropertyinSchemaClass(
            m_pSchema,
            m_dwSchemaSize,
            (LPWSTR) pszName,
            &dwSyntaxId
            );
    BAIL_ON_FAILURE(hr);
    
    // check if the property is writeable. Do this only if the flags are not
    // set to UMI_INTERNAL_FLAG_MARK_AS_CLEAN. Otherwise, the call is from
    // Clone() and we want read-only attributes to be succesfully copied
    // into the cloned object's cache. This requires that the check below
    // for writeable properties should be skipped.
    if(uFlags != UMI_INTERNAL_FLAG_MARK_AS_CLEAN) {
        hr = ValidateIfWriteableProperty(
            m_pSchema,
            m_dwSchemaSize,
            (LPWSTR) pszName
            );
        BAIL_ON_FAILURE(hr);
    }

    pPropArray = pProp->pPropArray; 

    // convert UMI data into format that can be stored in the cache
    hr = UmiToWinNTType(
            dwSyntaxId,
            pPropArray,
            &pNtObject
            );
    BAIL_ON_FAILURE(hr);

    // Find the property in the cache. If it doesn't exist, add it.
    hr = m_pPropCache->findproperty((LPWSTR) pszName, &dwIndex);
    if(FAILED(hr))
    {
        hr = m_pPropCache->addproperty(
                 (LPWSTR) pszName,
                 dwSyntaxId,
                 pPropArray->uCount,
                 pNtObject
                 );
        BAIL_ON_FAILURE(hr);
    }

    if(UMI_INTERNAL_FLAG_MARK_AS_CLEAN == uFlags)
        fMarkAsClean = TRUE;

    // Update property in cache
    hr = m_pPropCache->putproperty(
                 (LPWSTR) pszName,
                 dwSyntaxId,
                 pPropArray->uCount,
                 pNtObject,
                 fMarkAsClean
                 );
    BAIL_ON_FAILURE(hr);

error:

    if(pNtObject)
        NTTypeFreeNTObjects(pNtObject, pPropArray->uCount);

    if(FAILED(hr))
        SetLastStatus(hr);

    RRETURN(MapHrToUmiError(hr));
}
    
//----------------------------------------------------------------------------
// Function:   ValidatePutArgs
//
// Synopsis:   Checks if the arguments to Put() are well-formed.
//
// Arguments:
//
// pszName     Name of the property
// uFlags      Flags for the Put operation. Unused currently.
// pProp       Pointer to the structure containing the value
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::ValidatePutArgs( 
    LPCWSTR pszName,
    ULONG uFlags,
    UMI_PROPERTY_VALUES *pProp
    )
{
    UMI_PROPERTY *pPropArray = NULL;

    if( (NULL == pszName) || (NULL == pProp) )
        RRETURN(UMI_E_INVALIDARG);

    if( (uFlags != 0) && (uFlags != UMI_INTERNAL_FLAG_MARK_AS_CLEAN) )
        RRETURN(UMI_E_INVALID_FLAGS);

    if(pProp->uCount != 1)    // cannot update multiple properties using Put()
        RRETURN(UMI_E_INVALIDARG);

    pPropArray = pProp->pPropArray;
    if(NULL == pPropArray)
        RRETURN(UMI_E_INVALIDARG);

    // WinNT provider supports only property update. Cannot append, clear etc.
    if(pPropArray->uOperationType != UMI_OPERATION_UPDATE)
        RRETURN(UMI_E_UNSUPPORTED_OPERATION);

    if(pPropArray->pszPropertyName &&
            _wcsicmp(pPropArray->pszPropertyName, pszName))
        RRETURN(UMI_E_INVALID_PROPERTY);

    if(NULL == pPropArray->pUmiValue)
        RRETURN(UMI_E_INVALIDARG);

    // all is well
    RRETURN(UMI_S_NO_ERROR);
}

//----------------------------------------------------------------------------
// Function:   Get
//
// Synopsis:   Implements IUmiPropList::Get. Reads a property from the cache.
//             Since the WinNT provider does not support incremental updates
//             using PutEx, Get() will never return
//             UMI_E_SYNCHRONIZATION_REQUIRED. If a property is modified in
//             cache, Get() returns the modified value from the cache, without
//             any error.
//
// Arguments:
//
// pszName     Name of the property
// uFlags      Flags for the Get operation. Unused currently.
// ppProp      Returns pointer to the structure containing the value
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *ppProp to return the address of UMI_PROPERT_VALUES structure.
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::Get(
    LPCWSTR pszName,
    ULONG uFlags,
    UMI_PROPERTY_VALUES **ppProp
    )
{
    RRETURN( GetHelper(
                pszName,
                uFlags,
                ppProp,
                UMI_TYPE_NULL, // no-op
                FALSE          // not an internal call to GetHelper()
                ));
}

//----------------------------------------------------------------------------
// Function:   GetAs
//
// Synopsis:   Implements IUmiPropList::GetAs. Reads a property from the cache.
//             The data is converted to the type requested by the caller.
//             Since the WinNT provider does not support incremental updates
//             using PutEx, GetAs() will never return
//             UMI_E_SYNCHRONIZATION_REQUIRED. If a property is modified in
//             cache, GetAs() returns the modified value from the cache, without
//             any error. This method is not supported for interface properties.
//
// Update:     This method will not be supported on WinNT provider.
//
// Arguments:
//
// pszName       Name of the property
// uFlags        Flags for the GetAs operation. Unused currently.
// uCoercionType UMI type to convert the data to.
// ppProp        Returns pointer to the structure containing the value
//
// Returns:      UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:     *ppProp to return the address of UMI_PROPERT_VALUES structure.
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetAs(
    LPCWSTR pszName,
    ULONG uFlags,
    ULONG uCoercionType,
    UMI_PROPERTY_VALUES **ppProp
    )
{
    SetLastStatus(UMI_E_NOTIMPL);
    RRETURN(UMI_E_NOTIMPL);

    SetLastStatus(0);

    if(TRUE == m_fIsIntfPropObj) 
    // GetAs is only supported for object properties

        RRETURN(UMI_E_UNSUPPORTED_OPERATION);

    RRETURN( GetHelper(
                pszName,
                uFlags,
                ppProp,
                (UMI_TYPE) uCoercionType,
                FALSE,     // not an internal call to GetHelper()
                TRUE 
                ));
}

//----------------------------------------------------------------------------
// Function:   GetHelper
//
// Synopsis:   Implements  a helper function for Get() and GetAs().
//             Since the WinNT provider does not support incremental updates
//             using PutEx, Get()/GetAs() will never return 
//             UMI_E_SYNCHRONIZATION_REQUIRED. If a property is modified in
//             cache, Get()/GetAs() returns the modified value from the cache,
//             wthout any error.
//
// Arguments:
//
// pszName     Name of the property
// uFlags      Flags for the Get operation.
// ppProp      Returns pointer to the structure containing the value
// UmiDstType  UMI type to convert the NT value to. Used only by GetAs()
// fInternal   Flag to indicate if the call is through Get()/GetAs() or if it
//             is an internal call to this function from UMI.  Difference is
//             that internal calls can read passwords from the cache.
// fIsGetAs    Flag to indicate if the caller is GetAs (in which case
//             UmiType is used). FALSE by default.
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *ppProp to return the address of UMI_PROPERT_VALUES structure. 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetHelper(
    LPCWSTR pszName,
    ULONG uFlags,
    UMI_PROPERTY_VALUES **ppProp,
    UMI_TYPE UmiDstType,
    BOOL fInternal,
    BOOL fIsGetAs
    )
{
    HRESULT    hr = UMI_S_NO_ERROR;
    DWORD      dwSyntaxId = 0, dwNumValues = 0, dwIndex = 0;
    LPNTOBJECT pNtObject = NULL;
    UMI_TYPE   UmiType = UMI_TYPE_NULL;
    UMI_PROPERTY_VALUES *pProp = NULL;
    BOOL       fModified = FALSE;

    SetLastStatus(0);

    hr = ValidateGetArgs(
            pszName,
            uFlags,
            ppProp
            );
    BAIL_ON_FAILURE(hr);

    if(UMI_FLAG_PROPERTY_ORIGIN == uFlags) {
        hr = GetPropertyOrigin(pszName, ppProp);
        if(FAILED(hr))
            goto error;
        else
            RRETURN(UMI_S_NO_ERROR);
    }

    // is this a standard interface property that's not implemented?
    if(m_ppszUnImpl != NULL) {
        while(m_ppszUnImpl[dwIndex] != NULL) {
            if(0 == _wcsicmp(m_ppszUnImpl[dwIndex], pszName)) {
                BAIL_ON_FAILURE(hr = UMI_E_NOTIMPL);
            }
            dwIndex++;
        }
    }

    *ppProp = NULL;

    // __SCHEMA should return a IUmiObject pointer. This property is treated as
    // a special case since it is not actually retrieved from the property 
    // cache. This property will be requested only on an interface property 
    // object.
    if( (TRUE == m_fIsIntfPropObj) && 
        (0 == _wcsicmp((LPWSTR) pszName, TEXT(UMIOBJ_INTF_PROP_SCHEMA))) ) {
            hr = GetSchemaObject((LPWSTR) pszName, ppProp);
            BAIL_ON_FAILURE(hr);

            RRETURN(hr);
    }

    // make sure that passwords cannot be read by a user
    if( (TRUE == m_fIsIntfPropObj) && (FALSE == fInternal) && 
        (0 == _wcsicmp((LPWSTR) pszName, TEXT(CONN_INTF_PROP_PASSWORD))) )
 
        BAIL_ON_FAILURE(hr = UMI_E_FAIL);

    // retrieve property from cache. This might result in an implicit GetInfo()
    // if this is for object properties. For, interface properties, there is
    // no implicit GetInfo().
    hr = m_pPropCache->getproperty(
            (LPWSTR) pszName,
            &dwSyntaxId,
            &dwNumValues,
            &pNtObject,
            &fModified
            ); 

    BAIL_ON_FAILURE(hr);

    // map the NT type to a UMI type
    if(dwSyntaxId >= g_dwNumNTTypes)
        BAIL_ON_FAILURE(hr = UMI_E_FAIL); // shouldn't happen

    if(FALSE == fIsGetAs) 
    // get the UMI type corresponding to this NT type
        UmiType = g_mapNTTypeToUmiType[dwSyntaxId];
    else
    // try to convert to the type specified by the caller
        UmiType = UmiDstType;

    // allocate structure to return values
    pProp = (UMI_PROPERTY_VALUES *) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
    if(NULL == pProp)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY); 
    memset(pProp, 0, sizeof(UMI_PROPERTY_VALUES));

    pProp->pPropArray = (UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
    if(NULL == pProp->pPropArray)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pProp->pPropArray, 0, sizeof(UMI_PROPERTY));

    hr = WinNTTypeToUmi(
            pNtObject,
            dwNumValues,
            pProp->pPropArray,
            NULL,   // provider should allocate memory
            0,
            UmiType
            );
    BAIL_ON_FAILURE(hr);

    // Get fetches only one property at a time
    pProp->uCount = 1;

    // Fill in remaining fields of UMI_PROPERTY
    if(TRUE == fModified) {
    // WinNT only allows updates
        if( (uFlags != UMI_FLAG_PROVIDER_CACHE) && 
            (FALSE == m_fIsIntfPropObj) ) {
        // need to return error since cache is dirty
            FreeMemory(0, pProp); // ignore error return
            pProp = NULL;
            BAIL_ON_FAILURE(hr = UMI_E_SYNCHRONIZATION_REQUIRED);
        }

        pProp->pPropArray->uOperationType = UMI_OPERATION_UPDATE;
    }
    else
        pProp->pPropArray->uOperationType = 0;

    // not critical if this memory allocation fails. Property name doesn't
    // have to be returned to the caller.
    pProp->pPropArray->pszPropertyName = AllocADsStr(pszName); 
   
    *ppProp = pProp;
 
error:

    if(pNtObject)
        NTTypeFreeNTObjects(pNtObject, dwNumValues);

    if(FAILED(hr)) {
        if(pProp != NULL) {
            if(pProp->pPropArray != NULL)
                FreeADsMem(pProp->pPropArray);

            FreeADsMem(pProp);
        }

        SetLastStatus(hr);
    }

    RRETURN(MapHrToUmiError(hr));
}

//----------------------------------------------------------------------------
// Function:   ValidateGetArgs
//
// Synopsis:   Checks if the arguments to Get() are well-formed.
//
// Arguments:
//
// pszName     Name of the property
// uFlags      Flags for the Put operation. 
// ppProp      Returns pointer to the structure containing the value
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::ValidateGetArgs(
    LPCWSTR pszName,
    ULONG uFlags,
    UMI_PROPERTY_VALUES **ppProp
    )
{
    if( (NULL == pszName) || (NULL == ppProp) )
        RRETURN(UMI_E_INVALIDARG);

    // cannot combine UMI_FLAG_PROVIDER_CACHE and UMI_FLAG_PROPERTY_ORIGIN
    // since they are on the object property list and interface property list
    // respectively. So, don't need to AND with bitmasks to see if those flags
    // are set.
    if( (uFlags != 0) && (uFlags != UMI_FLAG_PROVIDER_CACHE) && 
        (uFlags != UMI_FLAG_PROPERTY_ORIGIN) )
        RRETURN(UMI_E_INVALID_FLAGS);

    if( (UMI_FLAG_PROVIDER_CACHE == uFlags) && (TRUE == m_fIsIntfPropObj) )
        RRETURN(UMI_E_INVALID_FLAGS);

    if(UMI_FLAG_PROPERTY_ORIGIN == uFlags) { 
    // can set this flag only on the interface property object of a class 
    // object.
        if( (FALSE == m_fIsIntfPropObj) || (NULL == m_pClassInfo) )
            RRETURN(UMI_E_INVALID_FLAGS);
    }

    // all is well
    RRETURN(UMI_S_NO_ERROR);
}

//----------------------------------------------------------------------------
// Function:   FreeMemory 
//
// Synopsis:   Implements IUmiPropList::FreeMemory. Frees a UMI_PROPERTY_VALUES
//             structure previously returned to the user. 
//
// Arguments:
//
// uReserved   Unused currently. 
// pMem        Pointer to UMI_PROPERTY_VALUES structure to be freed.
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   Nothing
//
//---------------------------------------------------------------------------- 
HRESULT CUmiPropList::FreeMemory(
    ULONG uReserved,
    LPVOID pMem
    )
{
    UMI_PROPERTY_VALUES *pUmiPropVal = NULL;
    UMI_PROPERTY       *pPropArray = NULL;
    ULONG              i;
    LPWSTR             *pStrArray = NULL;
    UMI_OCTET_STRING   *pOctetStrArray = NULL;
    PUMI_COM_OBJECT    pUmiComObj = NULL;

    SetLastStatus(0);

    if( (NULL == pMem) || (uReserved != 0) ) {
        SetLastStatus(UMI_E_INVALIDARG);
        RRETURN(UMI_E_INVALIDARG);
    }

    // enclose in try/except to handle bad pointers sent in by caller
    __try {
        pUmiPropVal = (UMI_PROPERTY_VALUES *) pMem;

        for(i = 0; i < pUmiPropVal->uCount; i++) {
            pPropArray = pUmiPropVal->pPropArray + i;

            if(NULL == pPropArray)
                RRETURN(UMI_E_INVALID_POINTER);

            // GetProps returns a UMI_PROPERTY structure with just the
            // property name filled in and all other fields 0, when asked
            // for only property names.
            if(pPropArray->pszPropertyName != NULL)
            {
                FreeADsStr(pPropArray->pszPropertyName);
                pPropArray->pszPropertyName = NULL;
            }

            if(0 == pPropArray->uCount)
                continue;

            if(NULL == pPropArray->pUmiValue)
                RRETURN(UMI_E_INVALID_POINTER);
      
            // Free individual string values 
            if(UMI_TYPE_LPWSTR == pPropArray->uType) {
                pStrArray = pPropArray->pUmiValue->pszStrValue;
                for(i = 0; i < pPropArray->uCount; i++) {
                    if(pStrArray[i] != NULL) {
                        FreeADsStr(pStrArray[i]);                
                        pStrArray[i] = NULL;
                    }
                }
            }
            else if(UMI_TYPE_OCTETSTRING ==  pPropArray->uType) {
                pOctetStrArray = pPropArray->pUmiValue->octetStr;
                for(i = 0; i < pPropArray->uCount; i++) {
                    if(pOctetStrArray[i].lpValue != NULL) {
                        FreeADsMem(pOctetStrArray[i].lpValue);
                        pOctetStrArray[i].lpValue = NULL;
                    }
                }
            }
            else if(UMI_TYPE_IUNKNOWN == pPropArray->uType) {
                pUmiComObj = pPropArray->pUmiValue->comObject;
                for(i = 0; i < pPropArray->uCount; i++) {
                    if(pUmiComObj[i].priid != NULL) {
                        FreeADsMem(pUmiComObj[i].priid);
                        pUmiComObj[i].priid = NULL;
                    }
                    if(pUmiComObj[i].pInterface != NULL){
                        ((IUnknown *) pUmiComObj[i].pInterface)->Release();
                        pUmiComObj[i].pInterface = NULL;
                    }
                }
            }

            // Now free the UMI_VALUE structure
            FreeADsMem(pPropArray->pUmiValue);
            pPropArray->pUmiValue = NULL;
        } // for

        if(pUmiPropVal->pPropArray != NULL)
            FreeADsMem(pUmiPropVal->pPropArray);
        pUmiPropVal->pPropArray = NULL;

        FreeADsMem(pUmiPropVal);

    } __except( EXCEPTION_EXECUTE_HANDLER ) 

    {
        SetLastStatus(UMI_E_INTERNAL_EXCEPTION);

        RRETURN(UMI_E_INTERNAL_EXCEPTION);
    }

    RRETURN(UMI_S_NO_ERROR);
}

//----------------------------------------------------------------------------
// Function:   GetInterfacePropNames
//
// Synopsis:   Returns the names of all interface properties supported. 
//
// Arguments:
//
// pProps      Returns the names of the properties, without any data
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *pProps to return the property names 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetInterfacePropNames(
    UMI_PROPERTY_VALUES **pProps
    )
{
    UMI_PROPERTY_VALUES *pUmiPropVals = NULL;
    UMI_PROPERTY        *pUmiProps = NULL;
    HRESULT             hr = UMI_S_NO_ERROR;
    ULONG               ulIndex = 0, ulCount = 0;

    ADsAssert(pProps != NULL);
    ADsAssert(TRUE == m_fIsIntfPropObj);

    pUmiPropVals = (UMI_PROPERTY_VALUES *) AllocADsMem(
                          sizeof(UMI_PROPERTY_VALUES));
    if(NULL == pUmiPropVals)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    memset(pUmiPropVals, 0, sizeof(UMI_PROPERTY_VALUES));

    if(0 == m_dwSchemaSize) {
    // no properties in cache
        *pProps = pUmiPropVals;
        RRETURN(UMI_S_NO_ERROR);
    }

    pUmiProps = (UMI_PROPERTY *) AllocADsMem(
                          m_dwSchemaSize * sizeof(UMI_PROPERTY));
    if(NULL == pUmiProps)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    memset(pUmiProps, 0, m_dwSchemaSize * sizeof(UMI_PROPERTY));

    for(ulIndex = 0; ulIndex < m_dwSchemaSize; ulIndex++) {
        if( (0 == _wcsicmp((LPWSTR) m_pSchema[ulIndex].szPropertyName, 
                         TEXT(UMIOBJ_INTF_PROP_SCHEMA))) ||
            (0 == _wcsicmp((LPWSTR) m_pSchema[ulIndex].szPropertyName,
                         TEXT(UMIOBJ_INTF_PROP_SCHEMAPATH))) ) {
            if(NULL == m_pszSchema)
            // must be a schema object, so don't return __SCHEMA and
            // __PADS_SCHEMA_CONTAINER_PATH.
                continue;
        }

        if(0 == _wcsicmp((LPWSTR) m_pSchema[ulIndex].szPropertyName,
                          TEXT(UMIOBJ_INTF_PROP_SUPERCLASS))) {
            if(FALSE == m_fIsClassObj)
            // not a class object. Hence __SUPERCLASS is not exposed.
                continue;
        } 

        if( (0 == _wcsicmp((LPWSTR) m_pSchema[ulIndex].szPropertyName,
                          TEXT(UMIOBJ_INTF_PROP_KEY))) ||
            (0 == _wcsicmp((LPWSTR) m_pSchema[ulIndex].szPropertyName,
                          TEXT(UMIOBJ_INTF_PROP_PARENT))) )
            if(TRUE == m_fIsNamespaceObj)
            // namespace objects have no key and parent
                continue;
        
        pUmiProps[ulCount].pszPropertyName = 
            (LPWSTR) AllocADsStr(m_pSchema[ulIndex].szPropertyName);
        if(NULL == pUmiProps[ulCount].pszPropertyName)
            BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
        ulCount++;
    }

    pUmiPropVals->uCount = ulCount;
    pUmiPropVals->pPropArray = pUmiProps;

    *pProps = pUmiPropVals; 

    RRETURN(UMI_S_NO_ERROR);

error:

    if(pUmiProps != NULL) { 
        for(ulIndex = 0; ulIndex < m_dwSchemaSize; ulIndex++)
            if(pUmiProps[ulIndex].pszPropertyName != NULL)
                FreeADsStr(pUmiProps[ulIndex].pszPropertyName);

        FreeADsMem(pUmiProps);
    }

    if(pUmiPropVals != NULL)
        FreeADsMem(pUmiPropVals);

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   GetObjectPropNames
//
// Synopsis:   Returns the names of all object properties in the cache. 
//
// Arguments:
//
// pProps      Returns the names of the properties, without any data
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *pProps to return the property names
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetObjectPropNames(
    UMI_PROPERTY_VALUES **pProps
    )
{
    ADsAssert(pProps != NULL);
    ADsAssert(FALSE == m_fIsIntfPropObj);

    RRETURN(m_pPropCache->GetPropNames(pProps));
}
         
//----------------------------------------------------------------------------
// Function:   GetProps 
//
// Synopsis:   Implements IUmiPropList::GetProps. Gets multiple properties.
//             This method will currently only support retrieving the names
//             of the properties supported. For interface property objects,
//             the names of all interface properties will be returned. For
//             object properties, the names of all properties in the cache will
//             be returned.
//             This method also supports retrieving class information if
//             the underlying object is a class object (in which case
//             m_pClassInfo will be non-NULL). This is supported only on an
//             interface property object. 
//
// Arguments:
//
// pszNames    Names of properties to retrieve. Should be NULL if only names
//             are requested.
// uNameCount  Number of properties in pszNames. Should be 0 if only names
//             are requested.
// uFlags      Should be UMI_FLAG_GETPROPS_NAMES to retrieve names of properties
//             and UMI_FLAG_GETPROPS_SCHEMA to get class information.
// pProps      Returns the names of the properties, without any data
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *pProps to return the property names 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetProps(
    LPCWSTR *pszNames,
    ULONG uNameCount,
    ULONG uFlags,
    UMI_PROPERTY_VALUES **pProps
    )
{
    HRESULT hr = UMI_S_NO_ERROR;

    SetLastStatus(0);

    if( (uFlags != ((ULONG) UMI_FLAG_GETPROPS_NAMES)) && 
        (uFlags != ((ULONG) UMI_FLAG_GETPROPS_SCHEMA)) )
        BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);

    if( (pszNames != NULL) || (uNameCount != 0) || (NULL == pProps) )
        BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);

    *pProps = NULL;

    if( ((ULONG) UMI_FLAG_GETPROPS_SCHEMA) == uFlags ) {
        if(NULL == m_pClassInfo) {
        // this is not a class object. This operation is not supported.
            BAIL_ON_FAILURE(hr = UMI_E_UNSUPPORTED_FLAGS);
        }
        else
            hr = GetClassInfo(pProps);
    }
    else {
        if(TRUE == m_fIsIntfPropObj)
            hr = GetInterfacePropNames(pProps);
        else
            hr = GetObjectPropNames(pProps);
    }

error:
 
    if(FAILED(hr))
        SetLastStatus(hr);

    RRETURN(MapHrToUmiError(hr));
}

//---------------------------------------------------------------------------
// Methods of IUmiPropList that are currently not implemented. 
//
//---------------------------------------------------------------------------
HRESULT CUmiPropList::GetAt(
    LPCWSTR pszName,
    ULONG uFlags,
    ULONG uBufferLength,
    LPVOID pExistingMem
    )
{
    SetLastStatus(UMI_E_NOTIMPL);

    RRETURN(UMI_E_NOTIMPL);
}

HRESULT CUmiPropList::PutProps(
    LPCWSTR *pszNames,
    ULONG uNameCount,
    ULONG uFlags,
    UMI_PROPERTY_VALUES *pProps
    )
{
    SetLastStatus(UMI_E_NOTIMPL);

    RRETURN(UMI_E_NOTIMPL);
}

HRESULT CUmiPropList::PutFrom(
    LPCWSTR pszName,
    ULONG uFlags,
    ULONG uBufferLength,
    LPVOID pExistingMem
    )
{
    SetLastStatus(UMI_E_NOTIMPL);

    RRETURN(UMI_E_NOTIMPL);
}

HRESULT CUmiPropList::Delete(
    LPCWSTR pszName,
    ULONG uFlags
    )
{
    SetLastStatus(UMI_E_NOTIMPL);

    RRETURN(UMI_E_NOTIMPL);
}

//----------------------------------------------------------------------------
// Function:   SetStandardProperties
//
// Synopsis:   Sets standard interface properties supported by all UMI objects
//             in the cache.
//
// Arguments:
//
// pIADs       Pointer to IADs interface on object
// pCoreObj    Pointer to core object for this WinNT object
//
// Returns:    S_OK on success. Error code otherwise. 
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::SetStandardProperties(
    IADs *pIADs,
    CCoreADsObject *pCoreObj
    )
{
    HRESULT    hr = S_OK;
    DWORD      dwIndex = 0;
    IDispatch  *pDispatch = NULL;
    DISPID     DispId;
    DISPPARAMS DispParams = {NULL, NULL, 0, 0};
    VARIANT    var;
    BSTR       bstrADsPath = NULL, bstrClass = NULL;
    LPWSTR     pFullUmiPath = NULL, pShortUmiPath = NULL, pRelUmiPath = NULL;
    LPWSTR     pFullRelUmiPath = NULL, pFullParentPath = NULL;
    DWORD      dwGenus = 0;
    BSTR       bstrName = NULL, bstrParent = NULL;
    WCHAR      *pSlash = NULL;
    LPWSTR     Classes[] = {NULL, L"Schema"};
    LPWSTR     pUmiSchemaPath = NULL;
    OBJECTINFO ObjectInfo;

    ADsAssert( (pIADs != NULL) && (TRUE == m_fIsIntfPropObj) );

    hr = pIADs->QueryInterface(
        IID_IDispatch,
        (void **) &pDispatch
        );
    BAIL_ON_FAILURE(hr);

    // First, set all properties supported on IADs. The names of these UMI
    // properties are not necessarily the same as the IADs properties, so
    // map the names appropriately.
    for(dwIndex = 0; dwIndex < g_dwIADsProperties; dwIndex++) {
        hr = pDispatch->GetIDsOfNames(
                IID_NULL,
                &g_IADsProps[dwIndex].IADsPropertyName,
                1,
                LOCALE_SYSTEM_DEFAULT,
                &DispId
                );
        BAIL_ON_FAILURE(hr);

        hr = pDispatch->Invoke(
                DispId,
                IID_NULL,
                LOCALE_SYSTEM_DEFAULT,
                DISPATCH_PROPERTYGET,
                &DispParams,
                &var,
                NULL,
                NULL
                );

        if(0 == _wcsicmp(g_IADsProps[dwIndex].IADsPropertyName, L"Schema")) {
            if(FAILED(hr))
            // Not a catastrophic failure. Can't get this property from the
            // cache. Only scenario where this should happen is when calling 
            // get_Schema on a schema/namespace object.
                continue;
            else {
            // store native path to schema in member variable
                m_pszSchema = AllocADsStr(V_BSTR(&var));
                VariantClear(&var);

                if(NULL == m_pszSchema)
                    BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

                // walk path backwards and get rid of last '/'
                pSlash = wcsrchr(m_pszSchema, L'/');
                if(NULL == pSlash) 
                // bad schema path
                    BAIL_ON_FAILURE(UMI_E_FAIL);

                *pSlash = L'\0';

                Classes[0] = pCoreObj->_CompClasses[0];
                ObjectInfo.DisplayComponentArray[0] = 
                          pCoreObj->_ObjectInfo.DisplayComponentArray[0];
                ObjectInfo.DisplayComponentArray[1] = SCHEMA_NAME;
                hr = ADsToUmiPath(
                        m_pszSchema,
                        &ObjectInfo,
                        Classes,
                        2,
                        FULL_UMI_PATH,
                        &pUmiSchemaPath
                        );

                *pSlash = L'/';

                BAIL_ON_FAILURE(hr);

                hr = SetLPTSTRPropertyInCache(
                        m_pPropCache,
                        TEXT(UMIOBJ_INTF_PROP_SCHEMAPATH),
                        pUmiSchemaPath,
                        TRUE
                        );
                BAIL_ON_FAILURE(hr);                

                continue;
            } // else 
        } // if(_wcsicmp...)

        BAIL_ON_FAILURE(hr); // if Invoke failed

        if(0 == _wcsicmp(g_IADsProps[dwIndex].IADsPropertyName, L"Parent")) {
        // convert the parent to a full UMI path
            if(0 == pCoreObj->_dwNumComponents) {
            // namespace object has no parent
                VariantClear(&var);
                continue;
            }
            else {
                bstrParent = V_BSTR(&var);

                hr = ADsToUmiPath(
                        bstrParent,
                        pCoreObj->_pObjectInfo,
                        pCoreObj->_CompClasses,
                        pCoreObj->_dwNumComponents - 1,
                        FULL_UMI_PATH,
                        &pFullParentPath
                        );
                VariantClear(&var);

                BAIL_ON_FAILURE(hr);

                hr = SetLPTSTRPropertyInCache(
                        m_pPropCache,
                        TEXT(UMIOBJ_INTF_PROP_PARENT),
                        pFullParentPath,
                        TRUE
                        );
                BAIL_ON_FAILURE(hr);

                continue;
            } // else
        } // if(0 ==

        hr = GenericPutPropertyManager(
                m_pPropCache,
                m_pSchema,
                m_dwSchemaSize,
                g_IADsProps[dwIndex].UMIPropertyName,
                var,
                FALSE
                );
        VariantClear(&var);

        BAIL_ON_FAILURE(hr);
    }
        
    // Now, set the remaining standard interface properties
    hr = pIADs->get_ADsPath(&bstrADsPath);
    BAIL_ON_FAILURE(hr);

    hr = ADsToUmiPath(
            bstrADsPath, 
            pCoreObj->_pObjectInfo,
            pCoreObj->_CompClasses, 
            pCoreObj->_dwNumComponents,
            FULL_UMI_PATH, 
            &pFullUmiPath
            );
    BAIL_ON_FAILURE(hr);

    hr = ADsToUmiPath(
            bstrADsPath,
            pCoreObj->_pObjectInfo, 
            pCoreObj->_CompClasses,
            pCoreObj->_dwNumComponents, 
            SHORT_UMI_PATH, 
            &pShortUmiPath
            );
    BAIL_ON_FAILURE(hr);

    hr = ADsToUmiPath(
            bstrADsPath,
            pCoreObj->_pObjectInfo, 
            pCoreObj->_CompClasses,
            pCoreObj->_dwNumComponents,
            RELATIVE_UMI_PATH, 
            &pRelUmiPath
            );
    BAIL_ON_FAILURE(hr);

    hr = ADsToUmiPath(
            bstrADsPath,
            pCoreObj->_pObjectInfo,
            pCoreObj->_CompClasses,
            pCoreObj->_dwNumComponents,
            FULL_RELATIVE_UMI_PATH,
            &pFullRelUmiPath
            );
    BAIL_ON_FAILURE(hr);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_FULLURL),
            pFullUmiPath,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_URL), 
            pShortUmiPath,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_RELURL),
            pRelUmiPath,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_FULLRELURL),
            pFullRelUmiPath,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    // Relpath is the same as the full relative URL
    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_RELPATH),
            pFullRelUmiPath,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    // set the genus based on the class of the object
    hr = pIADs->get_Class(&bstrClass);
    BAIL_ON_FAILURE(hr);

    if(IsSchemaObject(bstrClass)) {
        dwGenus = UMI_GENUS_CLASS;

        // WMI requires that the value of __CLASS be the same on instances
        // and classes. Thus, on class objects, the value of __CLASS should
        // be "user" instead of "class". __SUPERCLASS is exposed only on
        // class objects. Its value is always NULL in the WinNT provider 
        // since there is no class hierarchy.

        if(IsClassObj(bstrClass)) {
            hr = pIADs->get_Name(&bstrName);
            BAIL_ON_FAILURE(hr);

            // overwrite the value of __CLASS already stored in cache above
            hr = SetLPTSTRPropertyInCache(
                m_pPropCache,
                TEXT(UMIOBJ_INTF_PROP_CLASS),
                bstrName,
                TRUE
                );
            BAIL_ON_FAILURE(hr);

            hr = SetLPTSTRPropertyInCache(
                m_pPropCache,
                TEXT(UMIOBJ_INTF_PROP_SUPERCLASS),
                NULL,
                TRUE
                );

            m_fIsClassObj = TRUE;

            BAIL_ON_FAILURE(hr);
        } // if(IsClassObj...)
    }
    else
        dwGenus = UMI_GENUS_INSTANCE;

    hr = SetDWORDPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_GENUS),
            dwGenus,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    // set the key property. For WinNT, it will always be "Name" except that
    // namespace objects have no key (since the UMI path to a namespace object
    // is just umi:///winnt - there is no component of the form class.key=val.
    if(!IsNamespaceObj(bstrClass)) {
        hr = SetLPTSTRPropertyInCache(
                m_pPropCache,
                TEXT(UMIOBJ_INTF_PROP_KEY),
                WINNT_KEY_NAME,
                TRUE 
                );

        BAIL_ON_FAILURE(hr);
    }
    else {
        m_fIsNamespaceObj = TRUE;
    }

    // Mark all properties as "not modified", since the client really hasn't
    // updated the cache, though we have.
    m_pPropCache->ClearModifiedFlags();

error:
    if(pDispatch != NULL)
        pDispatch->Release();

    if(bstrADsPath != NULL)
        SysFreeString(bstrADsPath);

    if(bstrClass != NULL)
        SysFreeString(bstrClass);

    if(pFullUmiPath != NULL)
        FreeADsStr(pFullUmiPath);

    if(pRelUmiPath != NULL)
        FreeADsStr(pRelUmiPath);

    if(pFullRelUmiPath != NULL)
        FreeADsStr(pFullRelUmiPath);

    if(pShortUmiPath != NULL)
        FreeADsStr(pShortUmiPath);

    if(pFullParentPath != NULL)
        FreeADsStr(pFullParentPath);

    if(bstrName != NULL)
        SysFreeString(bstrName);

    if(pUmiSchemaPath != NULL)
        FreeADsStr(pUmiSchemaPath);

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   IsSchemaObject 
//
// Synopsis:   Returns whether an object of a specified class is a schema
//             object or not. 
//
// Arguments:
//
// bstrClass   Class of object
//
// Returns:    TRUE if it is a schema object. FALSE otherwise. 
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
BOOL CUmiPropList::IsSchemaObject(
    BSTR bstrClass
    )
{
    ADsAssert(bstrClass != NULL);

    if( (!_wcsicmp(bstrClass, L"Schema")) ||
        (!_wcsicmp(bstrClass, L"Class")) ||
        (!_wcsicmp(bstrClass, L"Property")) ||
        (!_wcsicmp(bstrClass, L"Syntax")) ||
        (!_wcsicmp(bstrClass, L"Namespace")) )
        RRETURN(TRUE);

    RRETURN(FALSE);
}

//----------------------------------------------------------------------------
// Function:   GetSchemaObject
//
// Synopsis:   Returns a IUmiObject pointer pointing to the schema class object
//             corresponding to this WinNT object. If there is no class object,
//             returns error. 
//
// Arguments:
//
// pszName     Name of the schema property
// ppProp      Returns pointer to the structure containing the IUmiObject
//             pointer. 
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise. 
//
// Modifies:   *ppProp to return the address of UMI_PROPERTY_VALUES structure. 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetSchemaObject(
    LPWSTR pszName,
    UMI_PROPERTY_VALUES **ppProp
    )
{
    HRESULT    hr = UMI_S_NO_ERROR;
    IUnknown   *pUnknown = NULL;
    IUmiObject *pUmiObj = NULL;
    UMI_PROPERTY_VALUES *pProp = NULL;

    PUMI_COM_OBJECT pUmiComObj = NULL;
    // use ADS_AUTH_RESERVED since the call is from UMI
    CWinNTCredentials Credentials(NULL, NULL, ADS_AUTH_RESERVED);

    ADsAssert( (ppProp != NULL) && (TRUE == m_fIsIntfPropObj) );

    *ppProp = NULL;

    if(NULL == m_pszSchema)
    // schema objects don't support __SCHEMA
        RRETURN(UMI_E_PROPERTY_NOT_FOUND);

    hr = GetObject(
            m_pszSchema,
            (LPVOID *) &pUnknown,
            Credentials
            ); 
    BAIL_ON_FAILURE(hr);

    hr = pUnknown->QueryInterface(IID_IUmiObject, (LPVOID *) &pUmiObj);
    BAIL_ON_FAILURE(hr);

    pUmiComObj = (PUMI_COM_OBJECT) AllocADsMem(sizeof(UMI_COM_OBJECT));
    if(NULL == pUmiComObj)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pUmiComObj, 0, sizeof(UMI_COM_OBJECT));

    pUmiComObj->priid = (IID *) AllocADsMem(sizeof(IID));
    if(NULL == pUmiComObj->priid)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    memcpy(pUmiComObj->priid, &IID_IUmiObject, sizeof(IID));
    pUmiComObj->pInterface = (LPVOID) pUmiObj;

    // allocate structure to return values
    pProp = (UMI_PROPERTY_VALUES *) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
    if(NULL == pProp)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pProp, 0, sizeof(UMI_PROPERTY_VALUES));

    pProp->pPropArray = (UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
    if(NULL == pProp->pPropArray)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pProp->pPropArray, 0, sizeof(UMI_PROPERTY));

    pProp->pPropArray->pUmiValue = (UMI_VALUE *) pUmiComObj;

    // Get fetches only one property at a time
    pProp->uCount = 1;

    // Fill in remaining fields of UMI_PROPERTY
    pProp->pPropArray->uOperationType = 0;
    pProp->pPropArray->uType = UMI_TYPE_IUNKNOWN;
    pProp->pPropArray->uCount = 1;

    // not critical if this memory allocation fails. Property name doesn't
    // have to be returned to the caller.
    pProp->pPropArray->pszPropertyName = AllocADsStr(pszName);

    *ppProp = pProp;

error:

    if(pUnknown != NULL)
        pUnknown->Release();

    if(FAILED(hr)) {
        if(pUmiObj != NULL)
            pUmiObj->Release();

        if(pUmiComObj != NULL) {
            if(pUmiComObj->priid != NULL)
                FreeADsMem(pUmiComObj->priid);

            FreeADsMem(pUmiComObj);
        }

        if(pProp != NULL) {
            if(pProp->pPropArray != NULL) {
                if(pProp->pPropArray->pszPropertyName != NULL)
                    FreeADsStr(pProp->pPropArray->pszPropertyName);
                FreeADsMem(pProp->pPropArray);
            }

            FreeADsMem(pProp);
        }
    } // if(FAILED(hr)) 

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   SetClassInfo 
//
// Synopsis:   Initializes class info for this object. Class info will be
//             stored only for class schema objects.  
//
// Arguments:
//
// pClassInfo  Class info for the object (NULL if not a class object)
//
// Returns:    Nothing 
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
void CUmiPropList::SetClassInfo(
    CLASSINFO *pClassInfo 
    )
{
    m_pClassInfo = pClassInfo;
    return;
} 
     
//----------------------------------------------------------------------------
// Function:   GetClassInfo
//
// Synopsis:   Returns the name and UMI type of all attributes in a given
//             WinNT class. This method will only be called on the interface
//             property object of a class object.
//
// Arguments:
//
// pProps      Returns the names and types of the attributes, without any data
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *pProps to return the property names 
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetClassInfo(
    UMI_PROPERTY_VALUES **pProps
    )
{
    UMI_PROPERTY_VALUES *pUmiPropVals = NULL;
    UMI_PROPERTY        *pUmiProps = NULL;
    HRESULT             hr = UMI_S_NO_ERROR;
    ULONG               ulIndex = 0;
    PPROPERTYINFO       pClassSchema = NULL;
    DWORD               dwClassSchemaSize = 0;

    ADsAssert(pProps != NULL);
    ADsAssert(TRUE == m_fIsIntfPropObj);
    ADsAssert(m_pClassInfo != NULL);

    pUmiPropVals = (UMI_PROPERTY_VALUES *) AllocADsMem(
                          sizeof(UMI_PROPERTY_VALUES));
    if(NULL == pUmiPropVals)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    memset(pUmiPropVals, 0, sizeof(UMI_PROPERTY_VALUES));

    pClassSchema = m_pClassInfo->aPropertyInfo;
    dwClassSchemaSize = m_pClassInfo->cPropertyInfo;

    if(0 == dwClassSchemaSize) {
    // no properties in class
        *pProps = pUmiPropVals;
        RRETURN(UMI_S_NO_ERROR);
    }

    pUmiProps = (UMI_PROPERTY *) AllocADsMem(
                          dwClassSchemaSize * sizeof(UMI_PROPERTY));
    if(NULL == pUmiProps)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    memset(pUmiProps, 0, dwClassSchemaSize * sizeof(UMI_PROPERTY));

    for(ulIndex = 0; ulIndex < dwClassSchemaSize; ulIndex++) {
        pUmiProps[ulIndex].pszPropertyName = 
            (LPWSTR) AllocADsStr(pClassSchema[ulIndex].szPropertyName);
        if(NULL == pUmiProps[ulIndex].pszPropertyName)
            BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

        // map the NT type to a UMI type
        if(pClassSchema[ulIndex].dwSyntaxId >= g_dwNumNTTypes)
            BAIL_ON_FAILURE(hr = UMI_E_FAIL); // shouldn't happen

        pUmiProps[ulIndex].uType = 
            g_mapNTTypeToUmiType[pClassSchema[ulIndex].dwSyntaxId];
    }

    pUmiPropVals->uCount = dwClassSchemaSize;
    pUmiPropVals->pPropArray = pUmiProps;

    *pProps = pUmiPropVals; 

    RRETURN(UMI_S_NO_ERROR);

error:

    if(pUmiProps != NULL) { 
        for(ulIndex = 0; ulIndex < dwClassSchemaSize; ulIndex++)
            if(pUmiProps[ulIndex].pszPropertyName != NULL)
                FreeADsStr(pUmiProps[ulIndex].pszPropertyName);

        FreeADsMem(pUmiProps);
    }

    if(pUmiPropVals != NULL)
        FreeADsMem(pUmiPropVals);

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   IsNamespaceObj
//
// Synopsis:   Returns whether an object of a specified class is a namespace 
//             object or not.
//
// Arguments:
//
// bstrClass   Class of object
//
// Returns:    TRUE if it is a namespace object. FALSE otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
BOOL CUmiPropList::IsNamespaceObj(
    BSTR bstrClass
    )
{
    ADsAssert(bstrClass != NULL);

    if(!_wcsicmp(bstrClass, L"Namespace"))
        RRETURN(TRUE);

    RRETURN(FALSE);
}

//----------------------------------------------------------------------------
// Function:   IsClassObj
//
// Synopsis:   Returns whether an object of a specified class is a class 
//             object or not.
//
// Arguments:
//
// bstrClass   Class of object
//
// Returns:    TRUE if it is a class object. FALSE otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
BOOL CUmiPropList::IsClassObj(
    BSTR bstrClass
    )
{
    ADsAssert(bstrClass != NULL);

    if(!_wcsicmp(bstrClass, L"Class"))
        RRETURN(TRUE);

    RRETURN(FALSE);
}

//----------------------------------------------------------------------------
// Function:   DisableWrites 
//
// Synopsis:   Disables writes on an interface property object. Used to disable
//             modification of connection interface properties after the
//             connection is opened. 
//
// Arguments:
//
// None
//
// Returns:    Nothing 
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
void CUmiPropList::DisableWrites(void)
{
    ADsAssert(TRUE == m_fIsIntfPropObj);

    m_fDisableWrites = TRUE;
}

//----------------------------------------------------------------------------
// Function:   SetDefaultConnProps 
//
// Synopsis:   Sets the default connection interface properties on the
//             interface property object of a connection. 
//
// Arguments:
//
// None
//
// Returns:    S_OK on success. Error code otherwise. 
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::SetDefaultConnProps(void)
{
    HRESULT hr = S_OK;

    ADsAssert(TRUE == m_fIsIntfPropObj);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(CONN_INTF_PROP_USERNAME),
            CONN_INTF_PROP_DEFAULT_USERNAME,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetLPTSTRPropertyInCache(
            m_pPropCache,
            TEXT(CONN_INTF_PROP_PASSWORD),
            CONN_INTF_PROP_DEFAULT_PASSWORD,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetBOOLPropertyInCache(
            m_pPropCache,
            TEXT(CONN_INTF_PROP_SECURE_AUTH),
            CONN_INTF_PROP_DEFAULT_SECURE_AUTH,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    hr = SetBOOLPropertyInCache(
            m_pPropCache,
            TEXT(CONN_INTF_PROP_READONLY_SERVER),
            CONN_INTF_PROP_DEFAULT_READONLY_SERVER,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

    RRETURN(S_OK);

error:

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   SetPropertyCount
//
// Synopsis:   Sets the property count in the interface property object's
//             cache. The property count is the number of properties in the
//             schema class object. It is exposed on both schema objects and
//             instances. 
//
// Arguments:
//
// dwPropCount Property count 
//
// Returns:    S_OK on success. Error code otherwise.
//
// Modifies:   Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::SetPropertyCount(DWORD dwPropCount)
{
    HRESULT hr = S_OK;

    hr = SetDWORDPropertyInCache(
            m_pPropCache,
            TEXT(UMIOBJ_INTF_PROP_PROPERTY_COUNT),
            dwPropCount,
            TRUE
            );
    BAIL_ON_FAILURE(hr);

error:

    RRETURN(hr);
}

//----------------------------------------------------------------------------
// Function:   GetPropertyOrigin
//
// Synopsis:   Returns the class in the hierarchy that introduced a
//             property. Since WinNT does not have a class hierarchy, this
//             will always be the class on which this method is called. If
//             the property is not in the class, an error is returned. 
//
// Arguments:
//
// pszName     Name of the schema property
// ppProp      Returns pointer to the structure containing the class name 
//
// Returns:    UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies:   *ppProp to return the address of UMI_PROPERTY_VALUES structure.
//
//----------------------------------------------------------------------------
HRESULT CUmiPropList::GetPropertyOrigin(
    LPCWSTR pszName,
    UMI_PROPERTY_VALUES **ppProp
    )
{
    HRESULT       hr = UMI_S_NO_ERROR;
    DWORD         dwIndex = 0;
    PPROPERTYINFO pClassSchema = NULL;
    DWORD         dwClassSchemaSize = 0;
    UMI_PROPERTY_VALUES *pProp = NULL;
    LPWSTR        *ppszClassArray = NULL;

    ADsAssert( (pszName != NULL) && (ppProp != NULL) && 
               (TRUE == m_fIsIntfPropObj) && (m_pClassInfo != NULL) );

    *ppProp = NULL;

    pClassSchema = m_pClassInfo->aPropertyInfo;
    dwClassSchemaSize = m_pClassInfo->cPropertyInfo;

    if(0 == dwClassSchemaSize) 
    // no properties in class
        BAIL_ON_FAILURE(hr = UMI_E_PROPERTY_NOT_FOUND);

    for(dwIndex = 0; dwIndex < dwClassSchemaSize; dwIndex++) {
        if(0 == _wcsicmp(pszName, pClassSchema[dwIndex].szPropertyName))
        // found the property
            break;
    }

    if(dwIndex == dwClassSchemaSize)
        BAIL_ON_FAILURE(hr = UMI_E_PROPERTY_NOT_FOUND);

    // allocate structure to return class name 
    pProp = (UMI_PROPERTY_VALUES *) AllocADsMem(sizeof(UMI_PROPERTY_VALUES));
    if(NULL == pProp)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pProp, 0, sizeof(UMI_PROPERTY_VALUES));

    pProp->pPropArray = (UMI_PROPERTY *) AllocADsMem(sizeof(UMI_PROPERTY));
    if(NULL == pProp->pPropArray)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(pProp->pPropArray, 0, sizeof(UMI_PROPERTY));

    ppszClassArray = (LPWSTR *) AllocADsMem(sizeof(LPWSTR *));
    if(NULL == pProp->pPropArray)
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
    memset(ppszClassArray, 0, sizeof(LPWSTR *));

    ppszClassArray[0] = AllocADsStr(m_pClassInfo->bstrName);
    if(NULL == ppszClassArray[0])
        BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);

    pProp->pPropArray->pUmiValue = (UMI_VALUE *) ppszClassArray;

    // Get fetches only one property at a time
    pProp->uCount = 1;

    // Fill in remaining fields of UMI_PROPERTY
    pProp->pPropArray->uOperationType = 0;
    pProp->pPropArray->uType = UMI_TYPE_LPWSTR;
    pProp->pPropArray->uCount = 1;

    // not critical if this memory allocation fails. Property name doesn't
    // have to be returned to the caller.
    pProp->pPropArray->pszPropertyName = AllocADsStr(pszName);

    *ppProp = pProp;

error:

    if(FAILED(hr)) {
        if(pProp != NULL) {
            if(pProp->pPropArray != NULL) {
                if(pProp->pPropArray->pszPropertyName != NULL)
                    FreeADsStr(pProp->pPropArray->pszPropertyName);
                FreeADsMem(pProp->pPropArray);
            }

            FreeADsMem(pProp);
        }

        if(ppszClassArray != NULL) {
            if(ppszClassArray[0] != NULL)
                FreeADsStr(ppszClassArray[0]);

            FreeADsMem(ppszClassArray);
        }

    } // if(FAILED(hr))

    RRETURN(hr);
}