windows-xp/Source/XPSP1/NT/com/ole32/stg/props/utils.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File:       utils.cxx
//
//  Contents:   Utility classes/functions for property implementation.
//
//  Classes:    CPropSetName -- wraps buffer and conversion of fmtids
//              CStackBuffer -- utility class that allows a small number
//                              of items be on stack, but more be on heap.
//
//  Functions:  PropVariantClear
//              FreePropVariantArray
//              AllocAndCopy
//              PropVariantCopy
//
//  History:    1-Mar-95   BillMo      Created.
//             22-Feb-96   MikeHill    Removed an over-active assert.
//             22-May-96   MikeHill    Handle "unmappable character" in
//                                     NtStatusToScode.
//             12-Jun-96   MikeHill    - Added PropSysAllocString and PropSysFreeString.
//                                     - Added VT_I1 support (under ifdef)
//                                     - Fix PropVarCopy where the input VT_CF
//                                       has a zero size but a non-NULL pClipData.
//             29-Jul-96   MikeHill    - PropSet names:  WCHAR => OLECHAR
//                                     - Bug in PropVarCopy of 0-length VT_BLOB
//                                     - Support VT_BSTR_BLOB types (used in IProp.dll)
//             10-Mar-98   MikeHIll    Support Variant types in PropVariantCopy/Clear
//             06-May-98   MikeHill    - Use CoTaskMem rather than new/delete.
//                                     - Removed unused PropSysAlloc/FreeString.
//                                     - Support VT_VECTOR|VT_I1.
//                                     - Removed UnicodeCallouts support.
//                                     - Use oleaut32.dll wrappers, don't call directly.
//     5/18/98  MikeHill
//              -   Moved IsOriginalPropVariantType from utils.hxx.
//              -   Added IsVariantType.
//
//  Notes:
//
//  Codework:
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#include <privoa.h>     // Private OleAut32 wrappers

#ifdef _MAC_NODOC
ASSERTDATA  // File-specific data for FnAssert
#endif

//+-------------------------------------------------------------------
//
//  Member:     CPropSetName::CPropSetName
//
//  Synopsis:   Initialize internal buffer with converted FMTID
//
//  Arguments:  [rfmtid] -- FMTID to convert
//
//--------------------------------------------------------------------

CPropSetName::CPropSetName(REFFMTID rfmtid)
{
    PrGuidToPropertySetName(&rfmtid, _oszName);
}

//+-------------------------------------------------------------------
//
//  Member:     CStackBuffer::Init
//
//  Synopsis:   Determine whether the class derived from this one
//              needs to have additional buffer allocated on the
//              heap and allocate it if neccessary.  Otherwise, if
//              there is space, use the internal buffer in the
//              derived class.
//
//  Arguments:  [cElements] -- the number of elements required.
//
//  Returns:    S_OK if buffer available
//              STG_E_INSUFFICIENTMEMORY if stack buffer was not
//                  big enough AND heap allocation failed.
//
//  Notes:      To be called directly by client after the derived
//              classes constructor initialized CStackBuffer.
//
//--------------------------------------------------------------------

HRESULT CStackBuffer::Init(ULONG cElements)
{
    if (cElements > _cElements)
    {
        _pbHeapBuf = reinterpret_cast<BYTE*>( CoTaskMemAlloc( cElements * _cbElement ));
        if (_pbHeapBuf == NULL)
        {
            return(STG_E_INSUFFICIENTMEMORY);
        }
        _cElements = cElements;
    }

    memset( _pbHeapBuf, 0, _cElements * _cbElement );

    return(S_OK);
}


//+-------------------------------------------------------------------------
//
//  Function:   PropVariantClear
//
//  Synopsis:   Deallocates the members of the PROPVARIANT that require
//              deallocation.
//
//  Arguments:  [pvarg] - variant to clear
//
//  Returns:    S_OK if successful,
//              STG_E_INVALIDPARAMETER if any part of the variant has
//                  an unknown vt type.  (In this case, ALL the elements
//                  that can be freed, will be freed.)
//
//  Modifies:   [pvarg] - the variant is left with vt = VT_EMPTY
//
//--------------------------------------------------------------------------

STDAPI PropVariantClear(PROPVARIANT *pvarg)
{

    ULONG l;
    HRESULT hr = S_OK;

    // Is there really anything to clear?
    if (pvarg == NULL)
        return(hr);

    // Validate the input
    VDATEPTROUT( pvarg, PROPVARIANT );

    switch (pvarg->vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_ILLEGAL:

    case VT_I1:
    case VT_UI1:
    case VT_I2:
    case VT_UI2:
    case VT_I4:
    case VT_UI4:
    case VT_I8:
    case VT_UI8:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
        break;

    case VT_BSTR:
        if (pvarg->bstrVal != NULL)
            PrivSysFreeString( pvarg->bstrVal );
        break;

    case VT_BSTR_BLOB:
        if (pvarg->bstrblobVal.pData != NULL)
            CoTaskMemFree( pvarg->bstrblobVal.pData );
        break;
    case VT_BOOL:
    case VT_ERROR:
    case VT_FILETIME:
        break;

    case VT_LPSTR:
    case VT_LPWSTR:
    case VT_CLSID:
        DfpAssert((void**)&pvarg->pszVal == (void**)&pvarg->pwszVal);
        DfpAssert((void**)&pvarg->pszVal == (void**)&pvarg->puuid);
        CoTaskMemFree( pvarg->pszVal ); // ptr at 0
        break;
        
    case VT_CF:
        if (pvarg->pclipdata != NULL)
        {
            CoTaskMemFree( pvarg->pclipdata->pClipData ); // ptr at 8
            CoTaskMemFree( pvarg->pclipdata );
        }
        break;

    case VT_BLOB:
    case VT_BLOB_OBJECT:
        CoTaskMemFree( pvarg->blob.pBlobData ); //ptr at 4
        break;

    case VT_STREAM:
    case VT_STREAMED_OBJECT:
        if (pvarg->pStream != NULL)
            pvarg->pStream->Release();
        break;

    case VT_VERSIONED_STREAM:
        if( NULL != pvarg->pVersionedStream )
        {
            if( NULL != pvarg->pVersionedStream->pStream )
                pvarg->pVersionedStream->pStream->Release();
            CoTaskMemFree( pvarg->pVersionedStream );
        }
        break;

    case VT_STORAGE:
    case VT_STORED_OBJECT:
        if (pvarg->pStorage != NULL)
            pvarg->pStorage->Release();
        break;

    case (VT_VECTOR | VT_I1):
    case (VT_VECTOR | VT_UI1):
    case (VT_VECTOR | VT_I2):
    case (VT_VECTOR | VT_UI2):
    case (VT_VECTOR | VT_I4):
    case (VT_VECTOR | VT_UI4):
    case (VT_VECTOR | VT_I8):
    case (VT_VECTOR | VT_UI8):
    case (VT_VECTOR | VT_R4):
    case (VT_VECTOR | VT_R8):
    case (VT_VECTOR | VT_CY):
    case (VT_VECTOR | VT_DATE):

FreeArray:
        DfpAssert((void**)&pvarg->caub.pElems == (void**)&pvarg->cai.pElems);
        CoTaskMemFree( pvarg->caub.pElems );
        break;

    case (VT_VECTOR | VT_BSTR):
        if (pvarg->cabstr.pElems != NULL)
        {
            for (l=0; l< pvarg->cabstr.cElems; l++)
            {
                if (pvarg->cabstr.pElems[l] != NULL)
                {
                    PrivSysFreeString( pvarg->cabstr.pElems[l] );
                }
            }
        }
        goto FreeArray;

    case (VT_VECTOR | VT_BSTR_BLOB):
        if (pvarg->cabstrblob.pElems != NULL)
        {
            for (l=0; l< pvarg->cabstrblob.cElems; l++)
            {
                if (pvarg->cabstrblob.pElems[l].pData != NULL)
                {
                    CoTaskMemFree( pvarg->cabstrblob.pElems[l].pData );
                }
            }
        }
        goto FreeArray;

    case (VT_VECTOR | VT_BOOL):
    case (VT_VECTOR | VT_ERROR):
        goto FreeArray;

    case (VT_VECTOR | VT_LPSTR):
    case (VT_VECTOR | VT_LPWSTR):
        if (pvarg->calpstr.pElems != NULL)
        for (l=0; l< pvarg->calpstr.cElems; l++)
        {
            CoTaskMemFree( pvarg->calpstr.pElems[l] );
        }
        goto FreeArray;

    case (VT_VECTOR | VT_FILETIME):
    case (VT_VECTOR | VT_CLSID):
        goto FreeArray;

    case (VT_VECTOR | VT_CF):
        if (pvarg->caclipdata.pElems != NULL)
            for (l=0; l< pvarg->caclipdata.cElems; l++)
            {
                CoTaskMemFree( pvarg->caclipdata.pElems[l].pClipData );
            }
        goto FreeArray;

    case (VT_VECTOR | VT_VARIANT):
        if (pvarg->capropvar.pElems != NULL)
            hr = FreePropVariantArray(pvarg->capropvar.cElems, pvarg->capropvar.pElems);
        goto FreeArray;

    default:

        hr = PrivVariantClear( reinterpret_cast<VARIANT*>(pvarg) );
        if( DISP_E_BADVARTYPE == hr )
            hr = STG_E_INVALIDPARAMETER;

        break;
    }

    //  We have all of the important information about the variant, so
    //  let's clear it out.
    //
    PropVariantInit(pvarg);

    return (hr);
}

//+---------------------------------------------------------------------------
//
//  Function:   FreePropVariantArray, public
//
//  Synopsis:   Frees a value array returned from ReadMultiple
//
//  Arguments:  [cval] - Number of elements
//              [rgvar] - Array
//
//  Returns:    S_OK if all types recognised and all freeable items were freed.
//              STG_E_INVALID_PARAMETER if one or more types were not
//              recognised but all items are freed too.
//
//  Notes:      Even if a vt-type is not understood, all the ones that are
//              understood are freed.  The error code will indicate
//              if *any* of the members were illegal types.
//
//----------------------------------------------------------------------------

STDAPI FreePropVariantArray (
        ULONG cVariants,
        PROPVARIANT *rgvars)
{
    HRESULT hr = S_OK;

    VDATESIZEPTROUT_LABEL(rgvars, cVariants * sizeof(PROPVARIANT),
                          Exit, hr );

    if (rgvars != NULL)
        for ( ULONG I=0; I < cVariants; I++ )
            if (STG_E_INVALIDPARAMETER == PropVariantClear ( rgvars + I ))
                hr = STG_E_INVALIDPARAMETER;

Exit:

    return hr;
}

//+-------------------------------------------------------------------
//
//  Function:   AllocAndCopy
//
//  Synopsis:   Allocates enough memory to copy the passed data into and
//              then copies the data into the new buffer.
//
//  Arguments:  [cb] -- number of bytes of data to allocate and copy
//              [pvData]  --  the source of the data to copy
//              [phr] -- optional pointer to an HRESULT set to
//                       STG_E_INSUFFICIENTMEMORY if memory could
//                       not be allocated.
//              
//
//  Returns:    NULL if no memory could be allocated,
//              Otherwise, pointer to allocated and copied data.
//
//--------------------------------------------------------------------

void * AllocAndCopy(ULONG cb, void * pvData, HRESULT *phr /* = NULL */)
{
    void * pvNew  =  CoTaskMemAlloc( cb );
    if (pvNew != NULL)
    {
        memcpy(pvNew, pvData, cb);
    }
    else
    {
        if (phr != NULL)
        {
            *phr = STG_E_INSUFFICIENTMEMORY;
        }
    }
    return(pvNew);
}



//+-------------------------------------------------------------------
//
//  Function:   PropSysAllocString
//              PropSysFreeString
//
//  Synopsis:   Wrappers for OleAut32 routines.
//
//  Notes:      These PropSys* functions simply forward the call to
//              the PrivSys* routines in OLE32.  Those functions
//              will load OleAut32 if necessary, and forward the call.
//
//              The PrivSys* wrapper functions are provided in order to
//              delay the OleAut32 load.  The PropSys* functions below
//              are provided as a mechanism to allow the NTDLL PropSet
//              functions to call the PrivSys* function pointers.
//
//              The PropSys* functions below are part of the
//              UNICODECALLOUTS structure used by NTDLL.
//              These functions should go away when the property set
//              code is moved from NTDLL to OLE32.
//
//--------------------------------------------------------------------

STDAPI_(BSTR)
PropSysAllocString(OLECHAR FAR* pwsz)
{
    return( PrivSysAllocString( pwsz ));
}

STDAPI_(VOID)
PropSysFreeString(BSTR bstr)
{
    PrivSysFreeString( bstr );
    return;
}

//+---------------------------------------------------------------------------
//
//  Class:      CRGTypeSizes (instantiated in g_TypeSizes)
//
//  Synopsis:   This class maintains a table with an entry for
//              each of the VT types.  Each entry contains
//              flags and a byte-size for the type (each entry is
//              only a byte).
//
//              This was implemented as a class so that we could use
//              it like an array (using an overloaded subscript operator),
//              indexed by the VT.  An actual array would require
//              4K entries
//
//              Internally, this class keeps two tables, each containing
//              a range of VTs (the VTs range from 0 to 31, and 64 to 72).
//              Other values are treated as a special-case.
//
//----------------------------------------------------------------------------

//  -----------------------
//  Flags for table entries
//  -----------------------

#define BIT_VECTNOALLOC 0x80    // the VT_VECTOR with this type does not
                                // use heap allocation

#define BIT_SIMPNOALLOC 0x40    // the non VT_VECTOR with this type does not
                                // use heap allocation

#define BIT_INVALID     0x20    // marks an invalid type

#define BIT_SIZEMASK    0x1F    // mask for size of underlying type

//  Dimensions of the internal tables

#define MIN_TYPE_SIZES_A    VT_EMPTY        // First contiguous range of VTs
#define MAX_TYPE_SIZES_A    VT_LPWSTR

#define MIN_TYPE_SIZES_B    VT_FILETIME     // Second continuous range of VTs
#define MAX_TYPE_SIZES_B    VT_VERSIONED_STREAM

//  ----------------
//  class CRTTypeSizes
//  ----------------

class CRGTypeSizes
{

public:

    // Subscript Operator
    //
    // This is the only method on this class.  It is used to
    // read an entry in the table.

    unsigned char operator[]( int nSubscript )
    {
        // Is this in the first table?
        if( MIN_TYPE_SIZES_A <= nSubscript && nSubscript <= MAX_TYPE_SIZES_A )
        {
	    return( m_ucTypeSizesA[ nSubscript ] );
        }

        // Or, is it in the second table?
        else if( MIN_TYPE_SIZES_B<= nSubscript && nSubscript <= MAX_TYPE_SIZES_B )
        {
            return( m_ucTypeSizesB[ nSubscript - MIN_TYPE_SIZES_B ] );
        }

        // Or, is it a special-case value (not in either table)?
        else
        if( VT_BSTR_BLOB == nSubscript )
        {
	    return( sizeof(BSTRBLOB) );
        }

        // Otherwise, the VT is invalid.
        return( BIT_INVALID );
    }


private:

    // There are two ranges of supported VTs, so we have
    // one table for each.

    static const unsigned char m_ucTypeSizesA[];
    static const unsigned char m_ucTypeSizesB[];
};

//  --------------------------
//  Instantiate the CRGTypeSizes
//  --------------------------

CRGTypeSizes g_TypeSizes;

//  ----------------------------
//  Define the CTypeSizes tables
//  ----------------------------

const unsigned char CRGTypeSizes::m_ucTypeSizesA[] =
{                 BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_EMPTY= 0,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_NULL      = 1,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  2,                    //VT_I2        = 2,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  4,                    //VT_I4        = 3,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  4,                    //VT_R4        = 4,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  8,                    //VT_R8        = 5,
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  sizeof(CY),           //VT_CY        = 6,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  sizeof(DATE),         //VT_DATE      = 7,
                                                       sizeof(BSTR),         //VT_BSTR      = 8,
                                        BIT_INVALID |  0,                    //VT_DISPATCH  = 9,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  sizeof(SCODE),        //VT_ERROR     = 10,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  sizeof(VARIANT_BOOL), //VT_BOOL      = 11,
                                                       sizeof(PROPVARIANT),  //VT_VARIANT   = 12,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_UNKNOWN   = 13,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    // 14
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    // 15
		  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  1,                    //VT_I1        = 16,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  1,                    //VT_UI1       = 17,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  2,                    //VT_UI2       = 18,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  4,                    //VT_UI4       = 19,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  8,                    //VT_I8        = 20,
                  BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  8,                    //VT_UI8       = 21,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_INT  = 22,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_UINT = 23,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_VOID = 24,
    BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC |  0,                    //VT_HRESULT      = 25,
    BIT_INVALID |                                      0,                    //VT_PTR  = 26,
    BIT_INVALID |                                      0,                    //VT_SAFEARRAY    = 27,
    BIT_INVALID |                                      0,                    //VT_CARRAY       = 28,
    BIT_INVALID |                                      0,                    //VT_USERDEFINED  = 29,
														   sizeof(LPSTR),        //VT_LPSTR        = 30,
														   sizeof(LPWSTR)        //VT_LPWSTR       = 31,
};

const unsigned char CRGTypeSizes::m_ucTypeSizesB[] =
{
    // sizes for vectors of types marked ** are determined dynamically
    BIT_SIMPNOALLOC | BIT_VECTNOALLOC |     sizeof(FILETIME),     //VT_FILETIME                 = 64,
                                            0,                    //**VT_BLOB                   = 65,
                                            0,                    //**VT_STREAM                 = 66,
                                            0,                    //**VT_STORAGE                = 67,
                                            0,                    //**VT_STREAMED_OBJECT        = 68,
                                            0,                    //**VT_STORED_OBJECT          = 69,
                                            0,                    //**VT_BLOB_OBJECT            = 70,
                                            sizeof(CLIPDATA),     //VT_CF                       = 71,
                      BIT_VECTNOALLOC |     sizeof(CLSID),        //VT_CLSID                    = 72,
                                            0                     //**VT_VERSIONED_STREAM       = 73
};


//+---------------------------------------------------------------------------
//
//  Function:   PropVariantCopy, public
//
//  Synopsis:   Copies a PROPVARIANT
//
//  Arguments:  [pDest] -- the destination PROPVARIANT
//              [pvarg] - the source PROPVARIANT
//
//  Returns:    Appropriate status code
//
//----------------------------------------------------------------------------

STDAPI PropVariantCopy ( PROPVARIANT * pvOut, const PROPVARIANT * pvarg )
{
    HRESULT     hr = S_OK;
    register unsigned char TypeInfo;
    register int iBaseType;
    BOOL fInputValidated = FALSE;
    PROPVARIANT Temp, *pDest = &Temp;

    //  ----------
    //  Initialize
    //  ----------

    // Validate the inputs

    VDATEREADPTRIN_LABEL( pvarg, PROPVARIANT, Exit, hr );
    VDATEPTROUT_LABEL( pvOut, PROPVARIANT, Exit, hr );
    fInputValidated = TRUE;

    // Duplicate the source propvar to the temp destination.  For types with
    // no external buffer (e.g. an I4), this will be sufficient.  For
    // types with an external buffer, we'll now have both propvars
    // pointing to the same buffer.  So we'll have to re-allocate 
    // for the destination propvar and copy the data into it.
    //

    *pDest = *pvarg;

    // Handle the simple types quickly.

    iBaseType = pvarg->vt & ~VT_VECTOR;
    TypeInfo = g_TypeSizes[ iBaseType ];    // Not to be confused with an ITypeInfo

    if( (TypeInfo & BIT_INVALID) != 0 )
    {
        // Try copying it as a regular Variant
        PropVariantInit( pDest );
        hr = PrivVariantCopy( reinterpret_cast<VARIANT*>(pDest),
                              reinterpret_cast<VARIANT*>(const_cast<PROPVARIANT*>( pvarg )) );
        goto Exit;
    }

    //  -----------------------
    //  Handle non-vector types
    //  -----------------------

    if ((pvarg->vt & VT_VECTOR) == 0)
    {

        // Is this a type which requires an allocation (otherwise there's
        // nothing to do)?

        if ((TypeInfo & BIT_SIMPNOALLOC) == 0)
        {
            // Yes - an allocation is required.

            // Keep a copy of the allocated buffer, so that at the end of
            // this switch, we can distiguish the out-of-memory condition from
            // the no-alloc-required condition.

            void * pvAllocated = (void*)-1;

            switch (pvarg->vt)
            {
                case VT_BSTR:
                    if( NULL != pvarg->bstrVal )
                        pvAllocated = pDest->bstrVal = PrivSysAllocString( pvarg->bstrVal );
                    break;

                case VT_BSTR_BLOB:
                    if( NULL != pvarg->bstrblobVal.pData )
                        pvAllocated = pDest->bstrblobVal.pData = (BYTE*)
                            AllocAndCopy(pDest->bstrblobVal.cbSize, pvarg->bstrblobVal.pData);
                    break;

                case VT_LPSTR:
                    if (pvarg->pszVal != NULL)
                        pvAllocated = pDest->pszVal = (CHAR *)
                            AllocAndCopy(strlen(pvarg->pszVal)+1, pvarg->pszVal);
                    break;
                case VT_LPWSTR:
                    if (pvarg->pwszVal != NULL)
                    {
                        ULONG cbString = (Prop_wcslen(pvarg->pwszVal)+1) * sizeof(WCHAR);
                        pvAllocated = pDest->pwszVal = (WCHAR *)
                            AllocAndCopy(cbString, pvarg->pwszVal);
                    }
                    break;
                case VT_CLSID:
                    if (pvarg->puuid != NULL)
                        pvAllocated = pDest->puuid = (GUID *)
                            AllocAndCopy(sizeof(*(pvarg->puuid)), pvarg->puuid);
                    break;
                
                case VT_CF:
                    // first check if CLIPDATA is present
                    if (pvarg->pclipdata != NULL)
                    {
                        // yes ... copy the clip data structure

                        pvAllocated = pDest->pclipdata = (CLIPDATA*)AllocAndCopy(
                            sizeof(*(pvarg->pclipdata)), pvarg->pclipdata);

                        // did we allocate the CLIPDATA ?
                        if (pvAllocated != NULL)
                        {
                            // yes ... initialize the destination.
                            pDest->pclipdata->pClipData = NULL;

                            // Is the input valid?
                            if (NULL == pvarg->pclipdata->pClipData
                                &&
                                0 != CBPCLIPDATA(*pvarg->pclipdata))
                            {
                                // no ... the input is not valid
                                hr = STG_E_INVALIDPARAMETER;
                                CoTaskMemFree( pDest->pclipdata );
                                pvAllocated = pDest->pclipdata = NULL;
                                break;
                            }

                            // Copy the actual clip data.  Note that if the source
                            // is non-NULL, we copy it, even if the length is 0.

                            if( NULL != pvarg->pclipdata->pClipData )
                            {
                                pvAllocated = pDest->pclipdata->pClipData =
                                    (BYTE*)AllocAndCopy(CBPCLIPDATA(*pvarg->pclipdata),
                                             pvarg->pclipdata->pClipData);
                            }

                        }   // if (pvAllocated != NULL)
                    }   // if (pvarg->pclipdata != NULL)
                    break;

                case VT_BLOB:
                case VT_BLOB_OBJECT:

                    // Is the input valid?
                    if (NULL == pvarg->blob.pBlobData
                        &&
                        0 != pvarg->blob.cbSize)
                    {
                        // no ... the input is not valid
                        hr = STG_E_INVALIDPARAMETER;
                        goto Exit;
                    }

                    // Copy the actual blob.  Note that if the source
                    // is non-NULL, we copy it, even if the length is 0.

                    if( NULL != pvarg->blob.pBlobData )
                    {
                        pvAllocated = pDest->blob.pBlobData =
                            (BYTE*)AllocAndCopy(pvarg->blob.cbSize,
                                     pvarg->blob.pBlobData);
                    }


                    break;

                case VT_STREAM:
                case VT_STREAMED_OBJECT:

                    if (pDest->pStream != NULL)
                            pDest->pStream->AddRef();
                    break;

                case VT_VERSIONED_STREAM:

                    if( NULL != pvarg->pVersionedStream )
                    {
                        LPVERSIONEDSTREAM pVersionedStream
                            = reinterpret_cast<LPVERSIONEDSTREAM>(CoTaskMemAlloc( sizeof(VERSIONEDSTREAM) ));
                        if( NULL == pVersionedStream )
                        {
                            hr = E_OUTOFMEMORY;
                            goto Exit;
                        }

                        *pVersionedStream = *pvarg->pVersionedStream;
                        if( NULL != pVersionedStream->pStream )
                            pVersionedStream->pStream->AddRef();

                        pDest->pVersionedStream = pVersionedStream;
                    }

                    break;


                case VT_STORAGE:
                case VT_STORED_OBJECT:

                    if (pDest->pStorage != NULL)
                            pDest->pStorage->AddRef();
                    break;

                case VT_VARIANT:

                    // drop through - this merely documents that VT_VARIANT has been thought of.
                    // VT_VARIANT is only supported as part of a vector.

                default:

                    hr = STG_E_INVALIDPARAMETER;
                    goto Exit;

            }   // switch (pvarg->vt)

            // If there was an error, we're done.
            if( FAILED(hr) )
                goto Exit;

            // pvAllocated was initialized to -1, so if it's NULL now,
            // there was an alloc failure.

            if (pvAllocated == NULL)
            {
                hr = STG_E_INSUFFICIENTMEMORY;
                goto Exit;
            }

        }   // if ((TypeInfo & BIT_SIMPNOALLOC) == 0)
    }   // if ((pvarg->vt & VT_VECTOR) == 0)

    //  -------------------
    //  Handle vector types
    //  -------------------

    else
    {
        // What's the byte-size of this type.

        ULONG cbType = TypeInfo & BIT_SIZEMASK;
        if (cbType == 0)
        {
            hr = STG_E_INVALIDPARAMETER;
            goto Exit;
        }

        // handle the vector types

        // this depends on the pointer and count being in the same place in
        // each of CAUI1 CAI2 etc

        // allocate the array for pElems
        if (pvarg->caub.pElems == NULL || pvarg->caub.cElems == 0)
        {
            DfpAssert( hr == S_OK );
            goto Exit; // not really an error
        }

        // Allocate the pElems array (the size of which is
        // type-dependent), and copy the source into it.

        void *pvAllocated = pDest->caub.pElems = (BYTE *)
            AllocAndCopy(cbType * pvarg->caub.cElems, pvarg->caub.pElems);

        if (pvAllocated == NULL)
        {
            hr = STG_E_INSUFFICIENTMEMORY;
            goto Exit;
        }

        // If this type doesn't require secondary allocation (e.g.
        // a VT_VECTOR | VT_I4), then we're done.

        if ((TypeInfo & BIT_VECTNOALLOC) != 0)
        {
            // the vector needs no further allocation
            DfpAssert( hr == S_OK );
            goto Exit;
        }

        ULONG l;

        // vector types that require allocation ...
        // we first zero out the pointers so that we can use PropVariantClear
        // to clean up in the error case

        switch (pvarg->vt)
        {
        case (VT_VECTOR | VT_BSTR):
            // initialize for error case
            for (l=0; l< pvarg->cabstr.cElems; l++)
            {
                pDest->cabstr.pElems[l] = NULL;
            }
            break;

        case (VT_VECTOR | VT_BSTR_BLOB):
            // initialize for error case
            for (l=0; l< pvarg->cabstrblob.cElems; l++)
            {
                memset( &pDest->cabstrblob.pElems[l], 0, sizeof(BSTRBLOB) );
            }
            break;

        case (VT_VECTOR | VT_LPSTR):
        case (VT_VECTOR | VT_LPWSTR):
            // initialize for error case
            for (l=0; l< pvarg->calpstr.cElems; l++)
            {
                pDest->calpstr.pElems[l] = NULL;
            }
            break;

        case (VT_VECTOR | VT_CF):
            // initialize for error case
            for (l=0; l< pvarg->caclipdata.cElems; l++)
            {
                pDest->caclipdata.pElems[l].pClipData  = NULL;
            }
            break;

        case (VT_VECTOR | VT_VARIANT):
            // initialize for error case
            for (l=0; l< pvarg->capropvar.cElems; l++)
            {
                pDest->capropvar.pElems[l].vt = VT_ILLEGAL;
            }
            break;

        default:
            DfpAssert(!"Internal error: Unexpected type in PropVariantCopy");
            CoTaskMemFree( pvAllocated );
            hr = STG_E_INVALIDPARAMETER;
            goto Exit;
        }

        // This is a vector type which requires a secondary alloc.

        switch (pvarg->vt)
        {
            case (VT_VECTOR | VT_BSTR):
                for (l=0; l< pvarg->cabstr.cElems; l++)
                {
                    if (pvarg->cabstr.pElems[l] != NULL)
                    {
                        pDest->cabstr.pElems[l] = PrivSysAllocString( pvarg->cabstr.pElems[l]);
                        if (pDest->cabstr.pElems[l]  == NULL)
                        {
                            hr = STG_E_INSUFFICIENTMEMORY;
                            break;
                        }
                    }
                }
                break;

            case (VT_VECTOR | VT_BSTR_BLOB):
                for (l=0; l< pvarg->cabstrblob.cElems; l++)
                {
                    if (pvarg->cabstrblob.pElems[l].pData != NULL)
                    {
                        pDest->cabstrblob.pElems[l].cbSize
                            = pvarg->cabstrblob.pElems[l].cbSize;

                        pDest->cabstrblob.pElems[l].pData = (BYTE*)AllocAndCopy(
                            pvarg->cabstrblob.pElems[l].cbSize,
                            pvarg->cabstrblob.pElems[l].pData,
                            &hr );

                        if (hr != S_OK)
                            break;
                    }
                }
                break;
        
            case (VT_VECTOR | VT_LPWSTR):
                for (l=0; l< pvarg->calpwstr.cElems; l++)
                {
                    if (pvarg->calpwstr.pElems[l] != NULL)
                    {

                        pDest->calpwstr.pElems[l] = (LPWSTR)AllocAndCopy(
                            sizeof(WCHAR)*(Prop_wcslen(pvarg->calpwstr.pElems[l])+1),
                            pvarg->calpwstr.pElems[l],
                            &hr);

                        if (hr != S_OK)
                            break;
                    }
                }
                break;

            case (VT_VECTOR | VT_LPSTR):
                for (l=0; l< pvarg->calpstr.cElems; l++)
                {
                    if (pvarg->calpstr.pElems[l] != NULL)
                    {
                        pDest->calpstr.pElems[l] = (LPSTR)AllocAndCopy(
                            strlen(pvarg->calpstr.pElems[l])+1,
                            pvarg->calpstr.pElems[l],
                            &hr);

                        if (hr != S_OK)
                            break;
                    }
                }
                break;

            case (VT_VECTOR | VT_CF):
                for (l=0; l< pvarg->caclipdata.cElems; l++)
                {
                    // Is the input valid?
                    if (NULL == pvarg->caclipdata.pElems[l].pClipData
                        &&
                        0 != CBPCLIPDATA(pvarg->caclipdata.pElems[l] ))
                    {
                        hr = STG_E_INVALIDPARAMETER;
                        break;
                    }

                    // Is there data to copy?
                    if (NULL != pvarg->caclipdata.pElems[l].pClipData)
                    {
                        pDest->caclipdata.pElems[l].pClipData  = (BYTE*)AllocAndCopy(
                            CBPCLIPDATA(pvarg->caclipdata.pElems[l]),
                            pvarg->caclipdata.pElems[l].pClipData,
                            &hr);

                        if (hr != S_OK)
                            break;
                    }
                }
                break;

            case (VT_VECTOR | VT_VARIANT):
                for (l=0; l< pvarg->capropvar.cElems; l++)
                {
                    hr = PropVariantCopy(pDest->capropvar.pElems + l,
                                         pvarg->capropvar.pElems + l);
                    if (hr != S_OK)
                    {
                        break;
                    }
                }
                break;

            default:
                DfpAssert(!"Internal error: Unexpected type in PropVariantCopy");
                CoTaskMemFree( pvAllocated );
                hr = STG_E_INVALIDPARAMETER;
                goto Exit;

        }   // switch (pvarg->vt)
    }   // if ((pvarg->vt & VT_VECTOR) == 0) ... else

    //  ----
    //  Exit
    //  ----

Exit:

    // If there was an error, and it wasn't a caller error
    // (in which case *pDest may not be writable), clear the
    // destination propvar.

    if (fInputValidated && hr != S_OK && E_INVALIDARG != hr)
    {
        // if *pDest == *pvarg, then we didn't alloc anything, and
        // nothing need be cleared, so we'll just init *pDest.
        // We can't free it because it may point to pvarg's buffers.

        if( !memcmp( pDest, pvarg, sizeof(PROPVARIANT) ))
            PropVariantInit( pDest );

        // Otherwise, we must have done some allocations for *pDest,
        // and must free them.

        else
            PropVariantClear( pDest );

    }

    if (SUCCEEDED(hr))
        *pvOut = Temp;

    return(hr);
}

//+---------------------------------------------------------------------------
//
//  Function:   NtStatusToScode, public
//
//  Synopsis:   Attempts to map an NTSTATUS code to an SCODE
//
//  Arguments:  [nts] - NTSTATUS
//
//  Returns:    Appropriate status code
//
//  History:    29-Jun-93       DrewB   Created
//
//  Notes:      Assumes [nts] is an error code
//              This function is by no means exhaustively complete
//
//----------------------------------------------------------------------------

SCODE NtStatusToScode(NTSTATUS nts)
{
    SCODE sc;

    propDbg((DEB_ITRACE, "In  NtStatusToScode(%lX)\n", nts));

    switch(nts)
    {
    case STATUS_INVALID_PARAMETER:
    case STATUS_INVALID_PARAMETER_MIX:
    case STATUS_INVALID_PARAMETER_1:
    case STATUS_INVALID_PARAMETER_2:
    case STATUS_INVALID_PARAMETER_3:
    case STATUS_INVALID_PARAMETER_4:
    case STATUS_INVALID_PARAMETER_5:
    case STATUS_INVALID_PARAMETER_6:
    case STATUS_INVALID_PARAMETER_7:
    case STATUS_INVALID_PARAMETER_8:
    case STATUS_INVALID_PARAMETER_9:
    case STATUS_INVALID_PARAMETER_10:
    case STATUS_INVALID_PARAMETER_11:
    case STATUS_INVALID_PARAMETER_12:
        sc = STG_E_INVALIDPARAMETER;
        break;

    case STATUS_DUPLICATE_NAME:
    case STATUS_DUPLICATE_OBJECTID:
    case STATUS_OBJECTID_EXISTS:
    case STATUS_OBJECT_NAME_COLLISION:
        sc = STG_E_FILEALREADYEXISTS;
        break;

    case STATUS_NO_SUCH_DEVICE:
    case STATUS_NO_SUCH_FILE:
    case STATUS_OBJECT_NAME_NOT_FOUND:
    case STATUS_NOT_A_DIRECTORY:
    case STATUS_FILE_IS_A_DIRECTORY:
    case STATUS_PROPSET_NOT_FOUND:
    case STATUS_NOT_FOUND:
    case STATUS_OBJECT_TYPE_MISMATCH:
        sc = STG_E_FILENOTFOUND;
        break;

    case STATUS_OBJECT_NAME_INVALID:
    case STATUS_OBJECT_PATH_SYNTAX_BAD:
    case STATUS_OBJECT_PATH_INVALID:
    case STATUS_NAME_TOO_LONG:
        sc = STG_E_INVALIDNAME;
        break;

    case STATUS_ACCESS_DENIED:
        sc = STG_E_ACCESSDENIED;
        break;

    case STATUS_NO_MEMORY:
    case STATUS_INSUFFICIENT_RESOURCES:
        sc = STG_E_INSUFFICIENTMEMORY;
        break;

    case STATUS_INVALID_HANDLE:
    case STATUS_FILE_INVALID:
    case STATUS_FILE_FORCED_CLOSED:
        sc = STG_E_INVALIDHANDLE;
        break;

    case STATUS_INVALID_DEVICE_REQUEST:
    case STATUS_INVALID_SYSTEM_SERVICE:
    case STATUS_NOT_IMPLEMENTED:
        sc = STG_E_INVALIDFUNCTION;
        break;

    case STATUS_NO_MEDIA_IN_DEVICE:
    case STATUS_UNRECOGNIZED_MEDIA:
    case STATUS_DISK_CORRUPT_ERROR:
    case STATUS_DATA_ERROR:
        sc = STG_E_WRITEFAULT;
        break;

    case STATUS_OBJECT_PATH_NOT_FOUND:
        sc = STG_E_PATHNOTFOUND;
        break;

    case STATUS_SHARING_VIOLATION:
        sc = STG_E_SHAREVIOLATION;
        break;

    case STATUS_FILE_LOCK_CONFLICT:
    case STATUS_LOCK_NOT_GRANTED:
        sc = STG_E_LOCKVIOLATION;
        break;

    case STATUS_DISK_FULL:
        sc = STG_E_MEDIUMFULL;
        break;

    case STATUS_ACCESS_VIOLATION:
    case STATUS_INVALID_USER_BUFFER:
        sc = STG_E_INVALIDPOINTER;
        break;

    case STATUS_TOO_MANY_OPENED_FILES:
        sc = STG_E_TOOMANYOPENFILES;
        break;

    case STATUS_DIRECTORY_NOT_EMPTY:
        sc = HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY);
        break;

    case STATUS_DELETE_PENDING:
        sc = STG_E_REVERTED;
        break;

    case STATUS_INTERNAL_DB_CORRUPTION:
        sc = STG_E_INVALIDHEADER;
        break;

    case STATUS_UNSUCCESSFUL:
        sc = E_FAIL;
        break;
        
    case STATUS_UNMAPPABLE_CHARACTER:
        sc = HRESULT_FROM_WIN32( ERROR_NO_UNICODE_TRANSLATION );
        break;

    default:
        propDbg((DEB_TRACE, "NtStatusToScode: Unknown status %lX\n", nts));

        sc = HRESULT_FROM_WIN32(RtlNtStatusToDosError(nts));
        break;
    }

    propDbg((DEB_ITRACE, "Out NtStatusToScode => %lX\n", sc));
    return sc;
}

#if DBG!=0 && !defined(WINNT)

ULONG
DbgPrint(
    PCHAR Format,
    ...
    )
{
    va_list arglist;
    CHAR Buffer[512];
    int cb;

    //
    // Format the output into a buffer and then print it.
    //

    va_start(arglist, Format);
    cb = PropVsprintfA(Buffer, Format, arglist);
    if (cb == -1) {             // detect buffer overflow
        cb = sizeof(Buffer);
        Buffer[sizeof(Buffer) - 2] = '\n';
        Buffer[sizeof(Buffer) - 1] = '\0';
    }

    OutputDebugString(Buffer);

    return 0;
}
#endif


//+-------------------------------------------------------------------
//
//  Member:     ValidateInRGPROPVARIANT
//
//  Synopsis:   S_OK if PROPVARIANT[] is valid for Read.
//              E_INVALIDARG otherwise.
//
//--------------------------------------------------------------------

HRESULT
ValidateInRGPROPVARIANT( ULONG cpspec, const PROPVARIANT rgpropvar[] )
{
    // We verify that we can read the whole PropVariant[], but
    // we don't validate the content of those elements.

    HRESULT hr;
    VDATESIZEREADPTRIN_LABEL(rgpropvar, cpspec * sizeof(PROPVARIANT), Exit, hr);
    hr = S_OK;

Exit:

    return( hr );
}

//+-------------------------------------------------------------------
//
//  Member:     ValidateOutRGPROPVARIANT
//
//  Synopsis:   S_OK if PROPVARIANT[] is valid for Write.
//              E_INVALIDARG otherwise.
//
//--------------------------------------------------------------------

HRESULT
ValidateOutRGPROPVARIANT( ULONG cpspec, PROPVARIANT rgpropvar[] )
{
    // We verify that we can write the whole PropVariant[], but
    // we don't validate the content of those elements.

    HRESULT hr;
    VDATESIZEPTROUT_LABEL(rgpropvar, cpspec * sizeof(PROPVARIANT), Exit, hr);
    hr = S_OK;

Exit:

    return( hr );
}

//+-------------------------------------------------------------------
//
//  Member:     ValidateOutRGLPOLESTR.
//
//  Synopsis:   S_OK if LPOLESTR[] is valid for Write.
//              E_INVALIDARG otherwise.
//
//--------------------------------------------------------------------

HRESULT
ValidateOutRGLPOLESTR( ULONG cpropid, LPOLESTR rglpwstrName[] )
{
    HRESULT hr;
    VDATESIZEPTROUT_LABEL( rglpwstrName, cpropid * sizeof(LPOLESTR), Exit, hr );
    hr = S_OK;

Exit:

    return( hr );
}

//+-------------------------------------------------------------------
//
//  Member:     ValidateInRGLPOLESTR
//
//  Synopsis:   S_OK if LPOLESTR[] is valid for Read.
//              E_INVALIDARG otherwise.
//
//--------------------------------------------------------------------

HRESULT
ValidateInRGLPOLESTR( ULONG cpropid, const OLECHAR* const rglpwstrName[] )
{
    // Validate that we can read the entire vector.

    HRESULT hr;
    VDATESIZEREADPTRIN_LABEL( rglpwstrName, cpropid * sizeof(LPOLESTR), Exit, hr );

    // Validate that we can at least read the first character of
    // each of the strings.

    for( ; cpropid > 0; cpropid-- )
    {
        VDATEREADPTRIN_LABEL( rglpwstrName[cpropid-1], WCHAR, Exit, hr );
    }

    hr = S_OK;

Exit:

    return( hr );
}





//+----------------------------------------------------------------------------
//
//  Function:   IsOriginalPropVariantType
//
//  Determines if a VARTYPE was one of the ones in the original PropVariant
//  definition (as defined in the OLE2 spec and shipped with NT4/DCOM95).
//
//+----------------------------------------------------------------------------

BOOL
IsOriginalPropVariantType( VARTYPE vt )
{
    if( vt & ~VT_TYPEMASK & ~VT_VECTOR )
        return( FALSE );

    switch( vt )
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_UI1: 
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_ERROR:
    case VT_I8:
    case VT_UI8:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_FILETIME:
    case VT_CLSID:
    case VT_BLOB:
    case VT_BLOB_OBJECT:
    case VT_CF:
    case VT_STREAM:
    case VT_STREAMED_OBJECT:
    case VT_STORAGE:
    case VT_STORED_OBJECT:
    case VT_BSTR:
    case VT_LPSTR:
    case VT_LPWSTR:
    case VT_UI1|VT_VECTOR:
    case VT_I2|VT_VECTOR:
    case VT_UI2|VT_VECTOR:
    case VT_BOOL|VT_VECTOR:
    case VT_I4|VT_VECTOR:
    case VT_UI4|VT_VECTOR:
    case VT_R4|VT_VECTOR:
    case VT_ERROR|VT_VECTOR:
    case VT_I8|VT_VECTOR:
    case VT_UI8|VT_VECTOR:
    case VT_R8|VT_VECTOR:
    case VT_CY|VT_VECTOR:
    case VT_DATE|VT_VECTOR:
    case VT_FILETIME|VT_VECTOR:
    case VT_CLSID|VT_VECTOR:
    case VT_CF|VT_VECTOR:
    case VT_BSTR|VT_VECTOR:
    case VT_BSTR_BLOB|VT_VECTOR:
    case VT_LPSTR|VT_VECTOR:
    case VT_LPWSTR|VT_VECTOR:
    case VT_VARIANT|VT_VECTOR:

        return( TRUE );
    }

    return( FALSE );
}



//+----------------------------------------------------------------------------
//
//  Function:   IsVariantType
//
//  Determines if a VARTYPE is one in the set of Variant types which are 
//  supported in the property set implementation.
//
//+----------------------------------------------------------------------------

BOOL
IsVariantType( VARTYPE vt )
{
    // Vectors are unsupported
    if( (VT_VECTOR | VT_RESERVED) & vt )
        return( FALSE );

    switch( VT_TYPEMASK & vt )
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_UI1:
    case VT_I2:
    case VT_UI2:
    case VT_I4:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_BSTR:
    case VT_UNKNOWN:
    case VT_DISPATCH:
    case VT_BOOL:
    case VT_ERROR:
    case VT_DECIMAL:
    case VT_VARIANT:

        return( TRUE );

    default:

        return( FALSE );
    }
}