You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1207 lines
37 KiB
1207 lines
37 KiB
//+------------------------------------------------------------------
|
|
//
|
|
// 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
|
|
|