//+------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995-2000.
//
// File:        oleprop.cxx
//
// Contents:    OLE Property Manager.
//
// Classes:     COLEPropManager
//
// History:     13-Dec-95       dlee   Created from KyleP's FCB Manager
//
//-------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <shlobj.h>
#include <nserror.h>

#include <propstm.hxx>
#include <oleprop.hxx>
#include <propvar.h>
#include <pmalloc.hxx>

//+---------------------------------------------------------------------------
//
//  Function:   FunnyToNormalPath
//
//  Synopsis:   Gets an interface over a file using the shell
//
//  Arguments:  [pwcPath] -- Path of the file to be opened
//              [riid]    -- Interface being requested
//              [ppv]     -- Where the interface is returned
//
//  Returns:    SCODE result of the open
//
//  History:    1-Feb-01       dlee   Created
//
//----------------------------------------------------------------------------

void FunnyToNormalPath( const CFunnyPath & funnyPath,
                        WCHAR * awcPath )
{
    WCHAR const * pwcPath = funnyPath.GetPath();

    #if CIDBG == 1

        unsigned cwc = wcslen( pwcPath );

        Win4Assert( cwc <= MAX_PATH );

    #endif // CIDBG

    // The shell doesn't understand the \\?\ syntax
    // Local:  \\?\c:\foo
    // Remote: \\?\UNC\server\share
    
    if ( !wcsncmp( pwcPath, L"\\\\?\\", 4 ) )
    {
        pwcPath += 4;

        if ( !wcsncmp( pwcPath, L"UNC\\", 4 ) )
            pwcPath += 2;
    }

    wcscpy( awcPath, pwcPath );

    if ( awcPath[1] == L'\\' )
        awcPath[0] = L'\\';
} //FunnyToNormalPath

//+---------------------------------------------------------------------------
//
//  Function:   ShellBindToItemByName
//
//  Synopsis:   Gets an interface over a file using the shell
//
//  Arguments:  [pwcPath] -- Path of the file to be opened
//              [riid]    -- Interface being requested
//              [ppv]     -- Where the interface is returned
//
//  Returns:    SCODE result of the open
//
//  History:    1-Feb-01       dlee   Created
//
//----------------------------------------------------------------------------

SCODE ShellBindToItemByName(
    WCHAR const * pwcPath,
    REFIID        riid,
    void **       ppv )
{
    Win4Assert( wcsncmp( pwcPath, L"\\\\?\\", 4 ) );

    XInterface<IShellFolder> xDesktop;
    SCODE sc = SHGetDesktopFolder( xDesktop.GetPPointer() );

    if ( SUCCEEDED( sc ) )
    {
        XInterface<IBindCtx> xBindCtx;

        sc = CreateBindCtx( 0, xBindCtx.GetPPointer() );
        if ( FAILED( sc ) )
            return sc;

        BIND_OPTS bo = {sizeof(bo), 0};
        bo.grfFlags = BIND_JUSTTESTEXISTENCE;   // skip all junctions

        sc = xBindCtx->SetBindOptions( &bo );

        if ( FAILED( sc ) )
            return sc;

        LPITEMIDLIST pidl;

        // cast needed for bad interface def
    
        sc = xDesktop->ParseDisplayName( 0,
                                         xBindCtx.GetPointer(),
                                         (LPWSTR) pwcPath,
                                         0,
                                         &pidl,
                                         0 );
        if ( SUCCEEDED( sc ) )
        {
            XInterface<IShellFolder> xSF;
            LPCITEMIDLIST pidlChild;

            // Note: apparently pidlChild isn't leaked here
    
            sc = SHBindToParent( pidl,
                                 IID_IShellFolder,
                                 xSF.GetQIPointer(),
                                 &pidlChild );
            if (SUCCEEDED(sc))
                sc = xSF->BindToObject( pidlChild, 0, riid, ppv );
    
            CoTaskMemFree( pidl );
        }
    }

    return sc;
} //ShellBindToItemByName

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::Open, public
//
//  Synopsis:   Open object corresponding to a path.
//
//  Arguments:  [pwcPath] - path of the file to be opened
//
//  Returns:    TRUE if failed due to sharing violation, FALSE otherwise
//
//  History:    13-Dec-95       dlee   Created
//
//----------------------------------------------------------------------------

BOOL COLEPropManager::Open( const CFunnyPath & funnyPath )
{
    Win4Assert( 0 == _ppsstg );

    // if we've tried to open this file before, don't try again.

    if ( _fStgOpenAttempted )
        return _fSharingViolation;

    _fStgOpenAttempted = TRUE;

    // NTRAID#DB-NTBUG9-84131-2000/07/31-dlee Indexing Service contains workarounds for StgOpenStorage AV on > MAX_PATH paths

    if ( funnyPath.GetLength() >= MAX_PATH )
    {
        ciDebugOut(( DEB_WARN, "Not calling StgOpenStorage in COLEPropManager::Open for paths > MAX_PATH: \n(%ws)\n",
                               funnyPath.GetPath() ));
        return FALSE;
    }

    //
    // Make sure the file isn't offline.
    //

    ULONG ulAttributes = GetFileAttributes( funnyPath.GetPath() );

    SCODE sc;

    if ( 0 == (ulAttributes & FILE_ATTRIBUTE_OFFLINE) )  // Note: attrib is also *on* in the error return
    {
        //
        // Get an IPropertSetStorage.
        //

#if 0

        sc = StgOpenStorageEx( funnyPath.GetPath(),     // Path
                               STGM_DIRECT |
                                 STGM_READ |
                                 STGM_SHARE_DENY_WRITE, // Flags (BChapman said use these)
                               STGFMT_ANY,              // Format
                               0,                       // Reserved
                               0,                       // Reserved
                               0,                       // Reserved
                               IID_IPropertySetStorage, // IID
                               (void **)&_ppsstg );

#else

        //
        // Note: Because of the above MAX_PATH check, we can copy into a fixed-length buffer
        // We need to hold onto the path because the shell open function expects the path to
        // remain valid for the life of the IPropertySetStorage we get back.
        //

        FunnyToNormalPath( funnyPath, _awcPath );

        // Use the shell's open to get additional properties from .mp3 files and others

        sc = ShellBindToItemByName( _awcPath,
                                    IID_IPropertySetStorage,
                                    (void **) &_ppsstg );

#endif

    }
    else
        sc = HRESULT_FROM_WIN32(ERROR_FILE_OFFLINE);

    if ( FAILED( sc ) )
    {
        vqDebugOut(( DEB_IWARN, "StgOpenStorage %ws returned 0x%x\n",
                     funnyPath.GetPath(), sc ));

        // For these nonfatal errors, fail silently.
        // Assuming STG_E_INVALIDNAME means the file didn't exist, but
        // even if it means the string is malformed it's ok to ignore.

        if ( STG_E_LOCKVIOLATION == sc ||
             STG_E_SHAREVIOLATION == sc )
        {
            _fSharingViolation = TRUE;
            return TRUE;
        }

        if ( STG_E_INVALIDFUNCTION == sc ||       // Common StgOpenStorageEx error (FAT volumes)
             STG_E_FILEALREADYEXISTS == sc ||     // Common StgOpenStorage error (FAT volumes)
             STG_E_ACCESSDENIED == sc ||
             STG_E_OLDFORMAT == sc ||
             STG_E_OLDDLL == sc ||
             STG_E_PATHNOTFOUND == sc ||
             STG_E_FILENOTFOUND == sc ||
             STG_E_INVALIDHEADER == sc ||
             STG_E_INVALIDNAME == sc ||
             HRESULT_FROM_WIN32(ERROR_FILE_OFFLINE) == sc )
            return FALSE;

        // these errors would mean a CI coding bug

        Win4Assert( STG_E_INVALIDPOINTER != sc );
        Win4Assert( STG_E_INVALIDFLAG != sc );

        // Almost any error code can be returned from StgOpenStorage.
        // The doc has little relation to the set of return codes.
        // This assert is just here so we know when we hit it whether
        // to put the new error in the ignore list (above) or the throw
        // list (here).

        Win4Assert( E_UNEXPECTED == sc ||
                    E_OUTOFMEMORY == sc ||
                    ERROR_NO_SYSTEM_RESOURCES ||
                    STG_E_TOOMANYOPENFILES == sc ||
                    STG_E_INSUFFICIENTMEMORY == sc ||
                    ( HRESULT_FROM_WIN32( ERROR_NOT_READY ) == sc ) );

        THROW( CException( sc ) );
    }

    return FALSE;
} //Open

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::PropSetToOrdinal, public
//
//  Synopsis:   Find property set for specified GUID.
//
//  Arguments:  [guidPS] -- GUID of property set.
//
//  Returns:    Ordinal of property set.
//
//  History:    13-Dec-95       dlee   Created
//
//----------------------------------------------------------------------------

unsigned COLEPropManager::PropSetToOrdinal(
    GUID const & guidPS )
{
    //
    // This is likely to be a very small array.  Just go for a linear search.
    //

    for ( unsigned i = 0; i < _aPropSets.Count(); i++ )
    {
        if ( _aPropSets[ i ].GetGuid() == guidPS )
            return i;
    }

    //
    // New property set.  Need to add entry.
    //

    _aPropSets[ i ] = COLEPropManager::CPropSetMap( guidPS );
    return i;
} //PropSetToOrdinal

//+---------------------------------------------------------------------------
//
//  Function:   IsNullPointerVariant
//
//  Synopsis:   Determines if a variant looks like it should have a
//              pointer but doesn't.
//
//  Arguments:  [ppv] -- the variant to test
//
//  Returns:    TRUE if a variant with a 0 pointer, FALSE otherwise
//
//  History:    04-Mar-96       dlee   Created
//
//----------------------------------------------------------------------------

BOOL IsNullPointerVariant(
    PROPVARIANT *ppv )
{
    if ( (VT_VECTOR & ppv->vt) &&
         0 != ppv->cal.cElems &&
         0 == ppv->cal.pElems )
        return TRUE;

    switch (ppv->vt)
    {
        case VT_CLSID:
            return ( 0 == ppv->puuid );

        case VT_BLOB:
        case VT_BLOB_OBJECT:
            return ( ( 0 != ppv->blob.cbSize ) &&
                     ( 0 == ppv->blob.pBlobData ) );

        case VT_CF:
            return ( ( 0 == ppv->pclipdata ) ||
                     ( 0 == ppv->pclipdata->pClipData ) );

        case VT_BSTR:
        case VT_LPSTR:
        case VT_LPWSTR:
            return ( 0 == ppv->pszVal );

        case VT_VECTOR | VT_BSTR:
        case VT_VECTOR | VT_LPSTR:
        case VT_VECTOR | VT_LPWSTR:
        {
            for (unsigned i = 0; i < ppv->calpstr.cElems; i++)
            {
                if ( 0 == ppv->calpstr.pElems[i] )
                    return TRUE;
            }
            break;
        }
        case VT_VECTOR | VT_VARIANT:
        {
            for (unsigned i = 0; i < ppv->capropvar.cElems; i++)
            {
                if ( IsNullPointerVariant( & (ppv->capropvar.pElems[i]) ) )
                    return TRUE;
            }
            break;
        }
    }

    return FALSE;
} //IsNullPointerVariant

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::FetchProperty, public
//
//  Synopsis:   Retrieve a property from a property set.
//
//  Arguments:  [guidPS]     -- property set to read from
//              [psProperty] -- PROPSPEC for property.
//              [pbData]     -- Property stored here.
//              [pcb]        -- Size in bytes of [pbData].  On output, size
//                              actually required.  An output <= input
//                              implies property successfully retrieved.
//
//  History:    13-Dec-95       dlee   Created
//              27-Aug-97       kylep  Convert Ole summary info to Unicode
//
//----------------------------------------------------------------------------

inline BYTE * PastHeader(
    PROPVARIANT * ppv )
{
    return( (BYTE *)ppv + sizeof( PROPVARIANT ) );
}

#define VCASE( vvar, type )                                             \
    cb += var[0].vvar.cElems * sizeof(var[0].vvar.pElems[0]);           \
    if ( cb <= *pcb )                                                   \
    {                                                                   \
        pbData->vvar.pElems = (type *)PastHeader(pbData);               \
        memcpy( pbData->vvar.pElems,                                    \
                var[0].vvar.pElems,                                     \
                var[0].vvar.cElems * sizeof(var[0].vvar.pElems[0]) );   \
    }

void COLEPropManager::FetchProperty(
    GUID const &     guidPS,
    PROPSPEC const & psProperty,
    PROPVARIANT *    pbData,
    unsigned *       pcb )
{
    if ( 0 == _ppsstg )
    {
        pbData->vt = VT_EMPTY;
        *pcb = sizeof( *pbData );
        return;
    }

    //
    //  The Office custom property set may not be opened when any other
    //  property set is opened, so treat this as a special case.
    //  Close all other property sets when opening it, and close it
    //  when opening any other property set.
    //

    if ( FMTID_UserDefinedProperties == guidPS )
    {
        if ( !_fOfficeCustomPropsetOpen )
        {
            _aPropSets.Clear();
            _fOfficeCustomPropsetOpen = TRUE;
        }
    }
    else if ( _fOfficeCustomPropsetOpen )
    {
        _aPropSets.Clear();
        _fOfficeCustomPropsetOpen = FALSE;
    }

    unsigned iPropSet = PropSetToOrdinal( guidPS );

    Win4Assert( iPropSet < _aPropSets.Count() );

    COLEPropManager::CPropSetMap & sm = _aPropSets[ iPropSet ];

    //
    //  May have to open the set.
    //

    if ( !sm.isOpen( _ppsstg ) )
    {
        pbData->vt = VT_EMPTY;
        *pcb = sizeof( *pbData );
        return;
    }

    PROPVARIANT var[2];
    PropVariantInit( &var[0] );
    PropVariantInit( &var[1] );

    PROPSPEC aps[2];
    aps[0] = psProperty;
    aps[1].ulKind = PRSPEC_PROPID;
    aps[1].propid = PID_CODEPAGE;
    SCODE sc = sm.GetPS().ReadMultiple( 2,
                                        aps,
                                        var );

    // A few specific failures should throw and and cause the
    // entire query to fail.

    if ( E_OUTOFMEMORY == sc ||
         STG_E_INSUFFICIENTMEMORY == sc ||
         E_UNEXPECTED == sc )
        THROW( CException( sc ) );

    if ( FAILED( sc ) )
    {
        // the first three would be due to invalid parameters, which
        // would be a programming bug.

        Win4Assert( STG_E_INVALIDPARAMETER != sc );
        Win4Assert( STG_E_INVALIDPOINTER != sc );
        Win4Assert( HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION) != sc );

        // access-denied is the only legal error that maps to VT_EMPTY

        Win4Assert( STG_E_ACCESSDENIED == sc );

        pbData->vt = VT_EMPTY;
        *pcb = sizeof( *pbData );
        return;
    }

    // The rest of the query code doesn't understand variants that
    // require a pointer but don't have one.  Such variants are legal,
    // but we map them to VT_EMPTY.

    if ( IsNullPointerVariant( &var[0] ) )
    {
        FreePropVariantArray( 1, &var[0] );

        pbData->vt = VT_EMPTY;
        *pcb = sizeof( *pbData );
        return;
    }

    //
    // Maybe we didn't get a codepage?
    //

    DWORD dwCodepage = ( var[1].vt == VT_I2 && CP_WINUNICODE != var[1].iVal ) ?
                       (unsigned short) var[1].iVal :
                       CP_ACP;

    *pbData = var[0];

    unsigned cb = sizeof PROPVARIANT;

    //
    // Deal with variable length portion.
    //

    switch ( var[0].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_DECIMAL:
    case VT_I8:
    case VT_UI8:
    case VT_R4:
    case VT_R8:
    case VT_BOOL:
    case VT_ILLEGAL:
    case VT_ERROR:
    case VT_CY:
    case VT_DATE:
    case VT_FILETIME:
        break;                  // fixed length types -- nothing to do

    case VT_BSTR:
        cb += BSTRLEN( var[0].bstrVal ) + sizeof(OLECHAR) + sizeof(DWORD);
        if (cb <= *pcb)
        {
            BSTR bstr = (BSTR) PastHeader(pbData);

            memcpy( bstr, &BSTRLEN(var[0].bstrVal), cb - sizeof(PROPVARIANT) );
            pbData->bstrVal = (BSTR) (((DWORD *)bstr) + 1);
        }
        break;

    case VT_LPSTR:
        //
        // HACK #274: Translate the Ole summary information LPSTR in LPWSTR
        //            Makes these properties compatible with HTML filter
        //            equivalents.
        //

        if ( FMTID_SummaryInformation == guidPS )
        {
            unsigned cc = strlen( var[0].pszVal ) + 1;

            unsigned ccT = MultiByteToWideChar( dwCodepage,
                                                0, // precomposed used if the codepage supports it
                                                var[0].pszVal,
                                                cc,
                                                (WCHAR *)PastHeader(pbData),
                                                (*pcb - sizeof(PROPVARIANT)) / sizeof(WCHAR) );

            if ( 0 == ccT )
            {
                if ( ERROR_INSUFFICIENT_BUFFER == GetLastError() )
                {
                        unsigned ccNeeded = MultiByteToWideChar( dwCodepage,
                                                                 0, // precomposed used if the codepage supports it
                                                                 var[0].pszVal,
                                                                 cc,
                                                                 0,
                                                                 0 );
                        Win4Assert( ccNeeded > 0 );

                        cb += ccNeeded * sizeof(WCHAR);
                }
                else
                {
                    ciDebugOut(( DEB_ERROR, "Error %d converting \"%s\" to codepage 0x%x\n",
                                 GetLastError(), var[0].pszVal, dwCodepage ));

                    cb += strlen( var[0].pszVal ) + 1;
                    if (cb <= *pcb)
                    {
                        pbData->pszVal = (char *)PastHeader(pbData);
                        memcpy( pbData->pszVal, var[0].pszVal, cb - sizeof(PROPVARIANT) );
                    }
                }
            }

            if ( ccT != 0 )
            {
                pbData->vt = VT_LPWSTR;
                pbData->pwszVal = (WCHAR *)PastHeader(pbData);
                cb += ccT * sizeof(WCHAR);
            }
        }
        else
        {
            cb += strlen( var[0].pszVal ) + 1;
            if (cb <= *pcb)
            {
                pbData->pszVal = (char *)PastHeader(pbData);
                memcpy( pbData->pszVal, var[0].pszVal, cb - sizeof(PROPVARIANT) );
            }
        }
        break;

    case VT_LPWSTR:
        cb += (wcslen( var[0].pwszVal ) + 1) * sizeof(WCHAR);
        if (cb <= *pcb)
        {
            pbData->pwszVal = (WCHAR *)PastHeader(pbData);
            memcpy( pbData->pwszVal, var[0].pwszVal, cb - sizeof(PROPVARIANT) );
        }
        break;

    case VT_CLSID:
        cb += sizeof(GUID);
        if (cb <= *pcb)
        {
            pbData->puuid = (GUID *)PastHeader(pbData);
            memcpy( pbData->puuid, var[0].puuid, cb - sizeof(PROPVARIANT) );
        }
        break;

    case VT_BLOB:
        cb += var[0].blob.cbSize;
        if (cb <= *pcb)
        {
            pbData->blob.pBlobData = PastHeader(pbData);
            memcpy( pbData->blob.pBlobData, var[0].blob.pBlobData, cb - sizeof(PROPVARIANT) );
        }
        break;

    case VT_CF:
        cb += sizeof(*(var[0].pclipdata)) + CBPCLIPDATA(*var[0].pclipdata);
        if ( cb <= *pcb )
        {
            pbData->pclipdata = (CLIPDATA *)PastHeader(pbData);
            memcpy( pbData->pclipdata, var[0].pclipdata, sizeof(*(var[0].pclipdata)) );

            pbData->pclipdata->pClipData = PastHeader(pbData) + sizeof(*(var[0].pclipdata));
            memcpy( pbData->pclipdata->pClipData,
                    var[0].pclipdata->pClipData,
                    CBPCLIPDATA(*var[0].pclipdata) );
        }
        break;

    //
    // Vectors (ugh!)
    //

    case VT_I1|VT_VECTOR:
    case VT_UI1|VT_VECTOR:
        VCASE( caub, BYTE );
        break;

    case VT_I2|VT_VECTOR:
        VCASE( cai, short );
        break;

    case VT_UI2|VT_VECTOR:
        VCASE( caui, USHORT );
        break;

    case VT_BOOL|VT_VECTOR:
        VCASE( cabool, VARIANT_BOOL );
        break;

    case VT_I4|VT_VECTOR:
    case VT_INT|VT_VECTOR:
        VCASE( cal, long );
        break;

    case VT_UI4|VT_VECTOR:
    case VT_UINT|VT_VECTOR:
        VCASE( caul, ULONG );
        break;

    case VT_R4|VT_VECTOR:
        VCASE( caflt, float );
        break;

    case VT_ERROR|VT_VECTOR:
        VCASE( cascode, SCODE );
        break;

    case VT_I8|VT_VECTOR:
        VCASE( cah, LARGE_INTEGER );
        break;

    case VT_UI8|VT_VECTOR:
        VCASE( cauh, ULARGE_INTEGER );
        break;

    case VT_R8|VT_VECTOR:
        VCASE( cadbl, double );
        break;

    case VT_CY|VT_VECTOR:
        VCASE( cacy, CY );
        break;

    case VT_DATE|VT_VECTOR:
        VCASE( cadate, DATE );
        break;

    case VT_FILETIME|VT_VECTOR:
        VCASE( cafiletime, FILETIME );
        break;

    case VT_CLSID|VT_VECTOR:
        VCASE( cauuid, CLSID );
        break;

    case VT_CF|VT_VECTOR:
    {
        cb += var[0].caclipdata.cElems * sizeof(var[0].caclipdata.pElems[0]);

        for ( unsigned i = 0; i < var[0].caclipdata.cElems; i++ )
        {
            cb += CBPCLIPDATA(var[0].caclipdata.pElems[i]);
        }

        if ( cb <= *pcb )
        {
            pbData->caclipdata.pElems = (CLIPDATA *)PastHeader(pbData);
            memcpy( pbData->caclipdata.pElems,
                    var[0].caclipdata.pElems,
                    var[0].caclipdata.cElems * sizeof(var[0].caclipdata.pElems[0]) );

            BYTE * pb = PastHeader(pbData) + var[0].caclipdata.cElems * sizeof(var[0].caclipdata.pElems[0]);

            for ( i = 0; i < var[0].caclipdata.cElems; i++ )
            {
                pbData->caclipdata.pElems[i].pClipData = pb;
                memcpy( pbData->caclipdata.pElems[i].pClipData,
                        var[0].caclipdata.pElems[i].pClipData,
                        CBPCLIPDATA(var[0].caclipdata.pElems[i]) );
                pb += CBPCLIPDATA(var[0].caclipdata.pElems[i]);
            }

        }

        break;
    }

    case VT_LPSTR|VT_VECTOR:
    {
        cb += var[0].calpstr.cElems * sizeof( var[0].calpstr.pElems[0] );

        for ( unsigned i = 0; i < var[0].calpstr.cElems; i++ )
        {
            cb += strlen( var[0].calpstr.pElems[i] ) + 1;
        }

        if ( cb <= *pcb )
        {
            pbData->calpstr.pElems = (char **)PastHeader(pbData);

            char * pc = (char *)PastHeader(pbData) +
                        var[0].calpstr.cElems * sizeof( var[0].calpstr.pElems[0] );

            for ( i = 0; i < var[0].calpstr.cElems; i++ )
            {
                pbData->calpstr.pElems[i] = pc;
                unsigned cc = strlen( var[0].calpstr.pElems[i] ) + 1;

                memcpy( pbData->calpstr.pElems[i],
                        var[0].calpstr.pElems[i],
                        cc );

                pc += cc;
            }
        }
        break;
    }

    case VT_LPWSTR|VT_VECTOR:
    {
        cb += var[0].calpwstr.cElems * sizeof( var[0].calpwstr.pElems[0] );

        for ( unsigned i = 0; i < var[0].calpwstr.cElems; i++ )
        {
            cb += (wcslen( var[0].calpwstr.pElems[i] ) + 1) * sizeof(WCHAR);
        }

        if ( cb <= *pcb )
        {
            pbData->calpwstr.pElems = (WCHAR **)PastHeader(pbData);

            WCHAR * pwc = (WCHAR *)(PastHeader(pbData) +
                          var[0].calpwstr.cElems * sizeof( var[0].calpwstr.pElems[0] ));

            for ( i = 0; i < var[0].calpwstr.cElems; i++ )
            {
                pbData->calpwstr.pElems[i] = pwc;
                unsigned cc = wcslen( var[0].calpwstr.pElems[i] ) + 1;

                memcpy( pbData->calpwstr.pElems[i],
                        var[0].calpwstr.pElems[i],
                        cc * sizeof(WCHAR) );

                pwc += cc;
            }
        }
        break;
    }

    case VT_BSTR|VT_VECTOR:
    {
        cb += var[0].cabstr.cElems * sizeof( var[0].cabstr.pElems[0] );

        for ( unsigned i = 0; i < var[0].cabstr.cElems; i++ )
        {
            cb += AlignBlock( BSTRLEN( var[0].cabstr.pElems[i] ) +
                              sizeof OLECHAR + sizeof DWORD,
                              sizeof DWORD );
        }

        if ( cb <= *pcb )
        {
            pbData->cabstr.pElems = (BSTR *)PastHeader(pbData);

            BSTR pwc = (BSTR)(PastHeader(pbData) +
                          var[0].cabstr.cElems * sizeof( var[0].cabstr.pElems[0] ));

            for ( i = 0; i < var[0].cabstr.cElems; i++ )
            {
                pbData->cabstr.pElems[i] = (BSTR) (((DWORD *) pwc) + 1);
                unsigned cbbstr = BSTRLEN( var[0].cabstr.pElems[i] ) +
                              sizeof(OLECHAR) + sizeof (DWORD);

                memcpy( pwc,
                        &BSTRLEN(var[0].cabstr.pElems[i]),
                        cbbstr);

                pwc += AlignBlock( cbbstr, sizeof DWORD ) / sizeof OLECHAR;
            }
        }
        break;
    }

    case VT_ARRAY | VT_I4:
    case VT_ARRAY | VT_UI1:
    case VT_ARRAY | VT_I2:
    case VT_ARRAY | VT_R4:
    case VT_ARRAY | VT_R8:
    case VT_ARRAY | VT_BOOL:
    case VT_ARRAY | VT_ERROR:
    case VT_ARRAY | VT_CY:
    case VT_ARRAY | VT_DATE:
    case VT_ARRAY | VT_I1:
    case VT_ARRAY | VT_UI2:
    case VT_ARRAY | VT_UI4:
    case VT_ARRAY | VT_INT:
    case VT_ARRAY | VT_UINT:
    case VT_ARRAY | VT_DECIMAL:
    case VT_ARRAY | VT_BSTR:
    case VT_ARRAY | VT_VARIANT:
    {
        SAFEARRAY * pSaSrc  = var[0].parray;
        SAFEARRAY * pSaDest = 0;

        cb += SaComputeSize( var[0].vt & ~VT_ARRAY, *pSaSrc );

        ciDebugOut(( DEB_ITRACE, "fetch safearray, *pcb, cb: %d, %d\n", *pcb, cb ));

        if ( cb <= *pcb )
        {
            CNonAlignAllocator ma( *pcb - sizeof (PROPVARIANT), PastHeader(pbData) );

            if ( SaCreateAndCopy( ma, pSaSrc, &pSaDest ) &&
                 SaCreateDataUsingMA( ma,
                                      var[0].vt & ~VT_ARRAY,
                                      *pSaSrc,
                                      *pSaDest,
                                      TRUE) )
            {
                pbData->parray = pSaDest;
                ciDebugOut(( DEB_ITRACE, "  pSaDest: %#x\n", pSaDest ));
            }
            else
            {
                // We've been guaranteed by SaComputeSize and *pcb that there
                // is sufficient memory to copy the array.  There must be a
                // bug if we can't.

                ciDebugOut(( DEB_ERROR,
                             "  can't copy SA %#x using %d bytes\n",
                             pSaSrc, cb ));
                Win4Assert( !"can't copy safearray" );
            }
        }

        break;
    }

    case VT_VARIANT|VT_VECTOR:
    {
        vqDebugOut(( DEB_WARN,
                     "COLEPropManager::FetchProperty - variant vector fetch %x\n",
                     &var[0] ));
        //Win4Assert( !"Fetch of variant vector not yet implemented" );

        pbData->vt = VT_EMPTY;
        *pcb = sizeof( *pbData );

        break;
    }

    case VT_STREAM:
    case VT_STREAMED_OBJECT:
    case VT_STORED_OBJECT:
    case VT_BLOB_OBJECT:
    {
        //
        // We don't support these datatypes.  Some make since to support
        // some day, but users can always retrieve the path and load the
        // values themselves.  Performance-wise it makes no since for us
        // to remote the values from our process.
        //

        pbData->vt = VT_EMPTY;
        cb = sizeof( *pbData );
        break;
    }

    default:
        Win4Assert( !"Unhandled variant type!" );
    }

    //
    // Cleanup
    //

    FreePropVariantArray( 1, &var[0] );

    *pcb = cb;
} //FetchProperty

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::CPropSetMap::isOpen, public
//
//  Synopsis:   Opens a property storage if it isn't already open
//
//  Arguments:  [ppsstg]     - property set storage from which property
//                             storage is opened.
//
//  History:     13-Dec-95       dlee   Created
//
//----------------------------------------------------------------------------

BOOL COLEPropManager::CPropSetMap::isOpen(
    IPropertySetStorage * ppsstg )
{
    if ( 0 != _pstg )
        return TRUE;

    if ( _fOpenAttempted )
        return FALSE;

    _fOpenAttempted = TRUE;

    SCODE sc = ppsstg->Open( _guid,
                             STGM_READ | STGM_SHARE_EXCLUSIVE, // BChapman said to use these
                             & _pstg );

    if ( FAILED( sc ) )
    {
        // don't fail the entire query if the property set doesn't
        // exist or if access is not allowed for this user, or if the
        // file was reverted after being opened.

        if ( STG_E_FILENOTFOUND != sc &&
             STG_E_ACCESSDENIED != sc &&
             NS_E_UNRECOGNIZED_STREAM_TYPE != sc && // The Shell enumeration routines do this
             NS_E_INVALID_DATA != sc &&             // 
             NS_E_FILE_INIT_FAILED != sc &&         // ""
             NS_E_FILE_OPEN_FAILED != sc &&         // ""
             E_FAIL != sc &&                        // ""
             STG_E_REVERTED != sc )
        {
            vqDebugOut(( DEB_WARN, "psstg->open failed: 0x%x\n", sc ));

            // this would be a coding bug in CI

            Win4Assert( STG_E_INVALIDPARAMETER != sc );

            Win4Assert( E_UNEXPECTED == sc ||
                        E_OUTOFMEMORY == sc ||
                        STG_E_INSUFFICIENTMEMORY == sc ||
                        STG_E_INVALIDHEADER == sc ||
                        STG_E_DOCFILECORRUPT == sc ||
                        ( HRESULT_FROM_WIN32( ERROR_NOT_READY ) == sc ) );

            THROW( CException( sc ) );
        }
    }

    return SUCCEEDED( sc );
} //isOpen

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::CPropSetMap::Close, public
//
//  Synopsis:   Closes a property storage
//
//  History:     13-Dec-95       dlee   Created
//
//----------------------------------------------------------------------------

void COLEPropManager::CPropSetMap::Close()
{
    if ( 0 != _pstg )
    {
        _pstg->Release();
        _pstg = 0;
    }

    _fOpenAttempted = FALSE;
} //Close

//+---------------------------------------------------------------------------
//
//  Member:     COLEPropManager::ReadProperty, public
//
//  Synopsis:   Reads an OLE property value using CoTaskMem memory
//
//  Arguments:  [ps]  -- property spec to read
//              [Var] -- where to put the value
//
//  Returns:    TRUE if a value found, FALSE otherwise, or throws on error
//
//  History:    18-Dec-97       dlee   Created
//
//----------------------------------------------------------------------------

BOOL COLEPropManager::ReadProperty(
    CFullPropSpec const & ps,
    PROPVARIANT &         Var )
{
    Var.vt = VT_EMPTY;

    if ( 0 == _ppsstg )
        return FALSE;

    //
    // Open the property storage for the given guid
    //

    IPropertyStorage * pPropStg;
    SCODE sc = _ppsstg->Open( ps.GetPropSet(), // guid
                              STGM_READ | STGM_SHARE_EXCLUSIVE, // BChapman said to use these...
                              &pPropStg );

    if ( SUCCEEDED(sc) )
    {
        XInterface<IPropertyStorage> xPropStg( pPropStg );

        //
        // Read the value
        //

        //
        // HACK #274: Translate the Ole summary information LPSTR in LPWSTR
        //            Makes these properties compatible with HTML filter
        //            equivalents.
        //

        if ( ps.GetPropSet() == FMTID_SummaryInformation )
        {
            PROPVARIANT var[2];
            PropVariantInit( &var[0] );
            PropVariantInit( &var[1] );

            PROPSPEC aps[2];
            aps[0] = ps.GetPropSpec();
            aps[1].ulKind = PRSPEC_PROPID;
            aps[1].propid = PID_CODEPAGE;

            sc = xPropStg->ReadMultiple( 2,
                                         aps,
                                         var );

            if ( FAILED(sc) )
                return DBSTATUS_S_ISNULL;

            //
            // Did we get a codepage?
            //

            DWORD dwCodepage = ( var[1].vt == VT_I2 && CP_WINUNICODE != var[1].iVal ) ?
                               (unsigned short) var[1].iVal :
                               CP_ACP;

            if ( VT_LPWSTR == var[0].vt )
            {
                //
                // Convert to Unicode
                //

                unsigned cc = strlen( var[0].pszVal ) + 1;
                XGrowable<WCHAR> xwcsProp( cc + (cc * 10 / 100) );  // 10% fluff
                unsigned ccT = 0;

                while ( 0 == ccT )
                {
                    ccT = MultiByteToWideChar( dwCodepage,
                                               0, // precomposed implied if the codepage supports it
                                               var[0].pszVal,
                                               cc,
                                               xwcsProp.Get(),
                                               xwcsProp.Count() );

                    if ( 0 == ccT )
                    {
                        if ( ERROR_INSUFFICIENT_BUFFER == GetLastError() )
                        {
                            unsigned ccNeeded = MultiByteToWideChar( dwCodepage,
                                                                     0, // precomposed implied if the codepage supports it
                                                                     var[0].pszVal,
                                                                     cc,
                                                                     0,
                                                                     0 );
                            Win4Assert( ccNeeded > 0 );
                            xwcsProp.SetSize( ccNeeded );
                        }
                        else
                        {
                            vqDebugOut(( DEB_ERROR, "Error %d converting %s to codepage 0x%x\n",
                                         GetLastError(), var[0].pszVal, dwCodepage ));
                            ccT = 0;
                            break;
                        }
                    }
                }

                if ( ccT != 0 )
                {
                    Var.vt = VT_LPWSTR;
                    Var.pwszVal = (WCHAR *)CoTaskMemAlloc( ccT * sizeof(WCHAR) );

                    if ( 0 == Var.pwszVal )
                    {
                        FreePropVariantArray( 2, var );
                        THROW( CException( E_OUTOFMEMORY ) );
                    }

                    RtlCopyMemory( Var.pwszVal, xwcsProp.Get(), ccT * sizeof(WCHAR) );

                    FreePropVariantArray( 2, var );
                }
                else
                    Var = var[0];
            }
            else
                Var = var[0];
        }
        else
        {
            sc = xPropStg->ReadMultiple( 1,  // 1 value to retrieve
                                         &ps.GetPropSpec(),
                                         &Var );
        }
    }

    if ( STG_E_FILENOTFOUND == sc ||
         STG_E_ACCESSDENIED == sc )
        return FALSE;

    if ( FAILED( sc ) )
        THROW( CException( sc ) );

    return TRUE;
} //ReadProperty