//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 2000.
//
// File: propfilt.cxx
//
// Contents: Code to filter properties on files
//
// Classes: COLEPropertyEnum
// CDocStatPropertyEnum
//
// History: 93-Oct-18 DwightKr Created
// 94-May-23 DwightKr Converted OFS to use OLE interfaces
// 95-Feb-07 KyleP Rewrote
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <propspec.hxx>
#include <ciguid.hxx>
#include <tgrow.hxx>
#include "propfilt.hxx"
static CFullPropSpec psAttr( guidStorage, PID_STG_ATTRIBUTES );
static CFullPropSpec psSize( guidStorage, PID_STG_SIZE );
//+-------------------------------------------------------------------------
//
// Function: CheckResult
//
// Synopsis: DebugOut and Throw on an error
//
// Arguments: [hr] -- result code to be tested
// [pcError] -- debugout string for debug builds
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
static inline void CheckResult(
HRESULT hr,
char * pcError )
{
if ( !SUCCEEDED( hr ) )
{
ciDebugOut(( DEB_IERROR, pcError, hr ));
THROW( CException( hr ) );
}
} //CheckResult
//+-------------------------------------------------------------------------
//
// Member: CDocStatPropertyEnum::CDocStatPropertyEnum, public
//
// Synopsis: Constructor
//
//--------------------------------------------------------------------------
CDocStatPropertyEnum::CDocStatPropertyEnum( ICiCOpenedDoc * Document )
: _PropertyStorage( 0 )
{
//
// Safely get property storage
//
{
IPropertyStorage *PropertyStorage;
HRESULT hr = Document->GetStatPropertyEnum( &PropertyStorage );
CheckResult( hr, "Could not get stat property storage %x\n" );
_PropertyStorage.Set( PropertyStorage );
}
//
// Safely get property enumerator
//
{
IEnumSTATPROPSTG *PropertyEnum;
HRESULT hr = _PropertyStorage->Enum( &PropertyEnum );
CheckResult( hr, "Could not get property enum %x\n" );
_PropertyEnum.Set( PropertyEnum );
}
}
//+-------------------------------------------------------------------------
//
// Member: CDocStatPropertyEnum::~CDocStatPropertyEnum, public
//
// Synopsis: Destructor
//
// History: 93-Nov-27 DwightKr Created
//
//--------------------------------------------------------------------------
CDocStatPropertyEnum::~CDocStatPropertyEnum()
{
}
//+-------------------------------------------------------------------------
//
// Member: CDocStatPropertyEnum::GetPropertySetLocale, public
//
// Synopsis: Get locale if available
//
// Arguments: [locale] - Locale
//
// Returns: HRESULT from property storage
//
//--------------------------------------------------------------------------
HRESULT CDocStatPropertyEnum::GetPropertySetLocale(LCID & locale)
{
return ::GetPropertySetLocale(_PropertyStorage.GetPointer(), locale);
}
//+-------------------------------------------------------------------------
//
// Member: CDocStatPropertyEnum::CacheVariant, public
//
// Synopsis: Load a specfied variant into the cache
//
// Arguments: [propid] - PROPID specifying what to load
//
// Returns: HRESULT from property storage
//
//--------------------------------------------------------------------------
HRESULT CDocStatPropertyEnum::CacheVariant( PROPID propid )
{
//
// Set up propspec for property read
//
PROPSPEC prspec;
prspec.ulKind = PRSPEC_PROPID;
prspec.propid = propid;
//
// Read out the property value
//
PROPVARIANT var;
HRESULT hr = _PropertyStorage->ReadMultiple( 1, &prspec, &var );
if (!SUCCEEDED( hr )) {
return hr;
}
//
// Set up storage variant
//
switch ( var.vt )
{
case VT_I8:
_varCurrent.SetI8( var.hVal );
break;
case VT_LPWSTR:
_varCurrent.SetLPWSTR( var.pwszVal );
if ( !_varCurrent.IsValid() )
return E_OUTOFMEMORY;
break;
case VT_UI4:
_varCurrent.SetUI4( var.lVal );
break;
case VT_FILETIME:
_varCurrent.SetFILETIME( var.filetime );
break;
default:
ciDebugOut(( DEB_IERROR, "Unknown storage type %x\n", var.vt ));
break;
}
PropVariantClear( &var );
return hr;
}
//+-------------------------------------------------------------------------
//
// Member: CDocStatPropertyEnum::Next, public
//
// Synopsis: Move to next property
//
// Arguments: [ps] -- Property Specification returned
//
// Returns: Property value, or 0 if end of properties.
//
// History: 95-Feb-07 KyleP Created
//
//--------------------------------------------------------------------------
CStorageVariant const * CDocStatPropertyEnum::Next( CFullPropSpec & ps )
{
//
// Get the next property in the enumeration
//
STATPROPSTG StatPropStg;
ULONG cFetched;
HRESULT hr = _PropertyEnum->Next( 1, &StatPropStg, &cFetched );
//
// If we failed or there were no more to fetch, then we're done
//
if (!SUCCEEDED( hr ) || 0 == cFetched)
return 0;
Win4Assert( NULL == StatPropStg.lpwstrName );
//
// Load the property returned by the enumeration
//
hr = CacheVariant( StatPropStg.propid );
if (!SUCCEEDED( hr ))
return 0;
//
// Set guid and propid for full property set
//
ps.SetPropSet( guidStorage );
ps.SetProperty( StatPropStg.propid );
//
// Return the cached property
//
return &_varCurrent;
} //Next
//+-------------------------------------------------------------------------
//
// Member: COLEPropertySetEnum::Next, public
//
// Synopsis: Move to next property set
//
// Returns: Pointer to GUID of property set. 0 if at end of sets.
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
GUID const * COLEPropertySetEnum::Next()
{
if ( 0 == _xPropSetEnum.GetPointer() )
return 0;
// Have we exhaused the current buffer of property sets? If so, then
// load up another buffer.
if ( _iPropSet == _cPropSets )
{
_iPropSet = 0;
_cPropSets = 0;
HRESULT hr = _xPropSetEnum->Next( cMaxSetsCached,
_aPropSets,
&_cPropSets );
CheckResult( hr, "PropSetEnum->Next failed hr = 0x%x\n" );
}
if ( _cPropSets > 0 )
{
_iPropSet++;
return &_aPropSets[ _iPropSet - 1 ].fmtid;
}
else
{
return 0;
}
} //Next
//+-------------------------------------------------------------------------
//
// Member: COLEPropertySetEnum::COLEPropertySetEnum, public
//
// Synopsis: Opens a storage, property set storage, and enumerator
//
// Arguments: [Document] -- opened document
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
COLEPropertySetEnum::COLEPropertySetEnum(
ICiCOpenedDoc *Document )
: _cPropSets( 0 ),
_iPropSet( 0 ),
_fIsStorage( FALSE )
{
IPropertySetStorage * pPropertySetStorage;
HRESULT hr = Document->GetPropertySetEnum( &pPropertySetStorage );
if ( SUCCEEDED( hr ) )
{
if (FILTER_S_NO_PROPSETS != hr)
{
_fIsStorage = TRUE;
// Save away property set storage
_xPropSetStg.Set( pPropertySetStorage );
IEnumSTATPROPSETSTG *pPropSetEnum;
hr = _xPropSetStg->Enum( &pPropSetEnum );
if ( E_NOTIMPL == hr )
{
_fIsStorage = FALSE;
_xPropSetStg.Free();
}
else
{
CheckResult( hr, "PropSetStg->Enum() failed hr = 0x%x\n" );
_xPropSetEnum.Set( pPropSetEnum );
}
}
}
else
{
// don't raise just because it wasn't a docfile
if ( STG_E_FILEALREADYEXISTS != hr )
CheckResult( hr, "StgOpenStorage() failed hr = 0x%x\n" );
}
} //COLEPropertySetEnum
//+-------------------------------------------------------------------------
//
// Member: COLEPropertyEnum::COLEPropertyEnum, public
//
// Synopsis: Constructor for class that enumerates all properties on
// a docfile.
//
// Arguments: [Document] -- opened document
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
COLEPropertyEnum::COLEPropertyEnum( ICiCOpenedDoc * Document )
: _pguidCurrent( 0 ),
_PropSetEnum( Document ),
_Codepage( CP_ACP ),
_cValues( 0 ),
_iCurrent( 0 ),
_fCustomOfficePropset( FALSE )
{
Document->AddRef( );
_xDocument.Set( Document );
_pguidCurrent = _PropSetEnum.Next();
END_CONSTRUCTION( COLEPropertyEnum );
} //COLEPropertyEnum
//+-------------------------------------------------------------------------
//
// Member: COLEPropertyEnum::GetPropertySetLocale, public
//
// Synopsis: Gets locale, if any.
//
// Arguments: [locale] -- locale, if any
//
// History 99-Mar-24 KrishnaN created
//
//--------------------------------------------------------------------------
HRESULT COLEPropertyEnum::GetPropertySetLocale(LCID & locale)
{
XInterface<IPropertyStorage> xPropStorage;
IPropertyStorage *pPropStg = 0;
HRESULT hr = _PropSetEnum.GetPSS()->Open( FMTID_UserDefinedProperties,
STGM_READ |
STGM_SHARE_EXCLUSIVE,
&pPropStg );
if (FAILED(hr))
{
Win4Assert(0 == pPropStg);
ciDebugOut(( DEB_IERROR, "PropSetStg->Open() failed hr = 0x%x\n", hr ));
return hr;
}
Win4Assert( 0 != pPropStg );
xPropStorage.Set( pPropStg );
return ::GetPropertySetLocale(xPropStorage.GetPointer(), locale);
}
//+-------------------------------------------------------------------------
//
// Member: COLEPropertyEnum::FillCache, private
//
// Synopsis: Loads the next property values for the current or next
// property set.
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
BOOL COLEPropertyEnum::FillCache()
{
do
{
// all out of property sets?
if ( 0 == _pguidCurrent )
{
//
// If we are to filter the custom office propertyset, then do it
// after we've filtered all other properties.
//
if ( _fCustomOfficePropset )
{
_fCustomOfficePropset = FALSE;
_pguidCurrent = &FMTID_UserDefinedProperties;
}
else
{
return FALSE;
}
}
FreeCache();
//
// If this is the office property set, then we need to also try
// to filter the office CUSTOM property set.
//
if ( *_pguidCurrent == FMTID_SummaryInformation )
{
_fCustomOfficePropset = TRUE;
}
// Open the property storage if not yet open
if ( 0 == _xPropStorage.GetPointer() )
{
IPropertyStorage *pPropStg;
HRESULT hr = _PropSetEnum.GetPSS()->Open( *_pguidCurrent,
STGM_READ |
STGM_SHARE_EXCLUSIVE,
&pPropStg );
//
// The special second-section property set will return a
// special failure code if it doesn't exist. Check for this
// code and ignore the property set.
// OLE returns STG_E_FILENOTFOUND and the shell returns E_FAIL
//
if ( ( ( E_FAIL == hr ) || ( STG_E_FILENOTFOUND == hr ) ) &&
( FMTID_UserDefinedProperties == *_pguidCurrent ) )
{
return FALSE;
}
CheckResult( hr, "PropSetStg->Open() failed hr = 0x%x\n" );
Win4Assert( 0 != pPropStg );
if ( 0 == pPropStg )
{
ciDebugOut(( DEB_WARN,
"IPropertySetStorage::Open( ) returned null property set and hr = 0x%x\n",
hr ));
_pguidCurrent = _PropSetEnum.Next();
continue;
}
_xPropStorage.Set( pPropStg );
//
// Look for codepage
//
PROPSPEC psCodepage = { PRSPEC_PROPID, PID_CODEPAGE };
PROPVARIANT varCodepage;
hr = _xPropStorage->ReadMultiple( 1, &psCodepage, &varCodepage );
if ( SUCCEEDED(hr) && VT_I2 == varCodepage.vt && varCodepage.iVal != CP_WINUNICODE )
_Codepage = (unsigned short) varCodepage.iVal;
else
_Codepage = CP_ACP;
Win4Assert( 0 == _xPropEnum.GetPointer() );
IEnumSTATPROPSTG *pPropEnum;
hr = pPropStg->Enum( &pPropEnum );
CheckResult( hr, "PropStg->Enum() failed hr = 0x%x\n" );
_xPropEnum.Set( pPropEnum );
}
HRESULT hr = _xPropEnum->Next( cMaxValuesCached, _aSPS, &_cValues );
CheckResult( hr, "PropEnum->Next failed sc = 0x%x\n" );
if ( _cValues > 0 )
{
for ( unsigned i = 0; i < _cValues; i++ )
{
if ( 0 != _aSPS[i].lpwstrName)
{
_aPropSpec[i].ulKind = PRSPEC_LPWSTR;
_aPropSpec[i].lpwstr = _aSPS[i].lpwstrName;
}
else
{
_aPropSpec[i].ulKind = PRSPEC_PROPID;
_aPropSpec[i].propid = _aSPS[i].propid;
}
}
hr = _xPropStorage->ReadMultiple( _cValues,
_aPropSpec,
_aPropVals );
CheckResult( hr, "ReadMultiple failed sc = 0x%x\n" );
//
// HACK #274: Translate the Ole summary information LPSTR in LPWSTR
// Makes these properties compatible with HTML filter
// equivalents.
//
if ( FMTID_SummaryInformation == *_pguidCurrent )
{
for ( i = 0; i < _cValues; i++ )
{
if ( ( VT_LPSTR == _aPropVals[i].Type() ) &&
( 0 != _aPropVals[i].GetLPSTR() ) )
{
// ciDebugOut(( DEB_ITRACE, "Converting \"%s\" to Unicode\n", _aPropVals[i].GetLPSTR() ));
unsigned cc = strlen( _aPropVals[i].GetLPSTR() ) + 1;
XGrowable<WCHAR> xwcsProp( cc + (cc * 10 / 100) ); // 10% fluff
unsigned ccT = 0;
while ( 0 == ccT )
{
ccT = MultiByteToWideChar( _Codepage,
0, // precomposed used of the codepage supports it
_aPropVals[i].GetLPSTR(),
cc,
xwcsProp.Get(),
xwcsProp.Count() );
if ( 0 == ccT )
{
if ( ERROR_INSUFFICIENT_BUFFER == GetLastError() )
{
unsigned ccNeeded = MultiByteToWideChar( _Codepage,
0, // precomposed used of the codepage supports it
_aPropVals[i].GetLPSTR(),
cc,
0,
0 );
Win4Assert( ccNeeded > 0 );
xwcsProp.SetSize( ccNeeded );
}
else
{
ciDebugOut(( DEB_ERROR, "Error %d converting %s to codepage 0x%x\n",
GetLastError(), _aPropVals[i].GetLPSTR(), _Codepage ));
ccT = 0;
break;
}
}
}
if ( ccT != 0 )
_aPropVals[i].SetLPWSTR( xwcsProp.Get() );
}
}
}
return TRUE;
}
else
{
// move on to the next property set
_xPropEnum.Acquire()->Release();
_xPropStorage.Acquire()->Release();
_pguidCurrent = _PropSetEnum.Next();
}
} while ( TRUE );
Win4Assert( !"never-never code path" );
return FALSE;
} //FillCache
//+-------------------------------------------------------------------------
//
// Member: COLEPropertyEnum::Next, public
//
// Synopsis: Moves to next property
//
// Arguments: [ps] -- Content index propspec returned here
//
// Returns: Pointer to property value. 0 if at end.
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
CStorageVariant const * COLEPropertyEnum::Next(
CFullPropSpec & ps )
{
//
// If we have exhausted the cache, then try to fill it
//
if ( _cValues == _iCurrent && !FillCache() ) {
return 0;
}
//
// If the document is being requested, bail out
//
BOOL fInUse;
_xDocument->IsInUseByAnotherProcess( &fInUse );
if ( fInUse )
{
ciDebugOut(( DEB_ITRACE, "Oplock broken while filtering OLE properties\n" ));
QUIETTHROW( CException( STATUS_OPLOCK_BREAK_IN_PROGRESS ) );
}
//
// Set up the full property spec
//
ps.SetPropSet( *_pguidCurrent );
if ( PRSPEC_LPWSTR == _aPropSpec[_iCurrent].ulKind )
ps.SetProperty( _aPropSpec[_iCurrent].lpwstr );
else
ps.SetProperty( _aPropSpec[_iCurrent].propid );
_iCurrent++;
return( (CStorageVariant const *) &_aPropVals[_iCurrent-1] );
} //Next
//+-------------------------------------------------------------------------
//
// Member: COLEPropertyEnum::FreeCache, private
//
// Synopsis: Frees memory for the loaded properties and their specs
//
// History 95-Dec-19 dlee created
//
//--------------------------------------------------------------------------
void COLEPropertyEnum::FreeCache()
{
for ( unsigned i = 0; i < _cValues; i++ )
{
PropVariantClear( (PROPVARIANT *) (void *) ( & _aPropVals[ i ] ) );
if ( PRSPEC_LPWSTR == _aPropSpec[i].ulKind )
CoTaskMemFree( _aSPS[i].lpwstrName );
}
_iCurrent = 0;
_cValues = 0;
} //FreeCache
//+-------------------------------------------------------------------------
//
// Member: GetPropertySetLocale
//
// Synopsis: Reads the locale, if any, from property storage
//
// History 99-Mar-24 KrishnaN created
//
//--------------------------------------------------------------------------
HRESULT GetPropertySetLocale(IPropertyStorage *pPropStorage, LCID & locale)
{
Win4Assert(0 != pPropStorage );
PROPSPEC ps;
PROPVARIANT prop;
ps.ulKind = PRSPEC_PROPID;
ps.propid = PID_LOCALE;
// Get the locale for properties
HRESULT hr = pPropStorage->ReadMultiple (1,
&ps,
&prop);
if(SUCCEEDED(hr))
{
if(prop.vt == VT_EMPTY)
{
hr = E_FAIL;
}
else
{
Win4Assert(prop.vt == VT_UI4);
locale = prop.ulVal;
// PropVariantClear(&prop);
}
}
return hr;
}