|
|
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994
//
// File: ntpropb.cxx
//
// Contents: Nt property set implementation based on OLE Appendix B.
//
// History:
// 5-Dec-94 vich created
// 09-May-96 MikeHill Use the 'boolVal' member of PropVariant,
// rather than the member named 'bool'
// (which is a reserved keyword).
// 22-May-96 MikeHill - Get the OSVersion during a CreatePropSet.
// - Let CPropSetStm allocate prop name buffers.
// 07-Jun-96 MikeHill - Correct ClipData.cbSize to include
// sizeof(ulClipFmt).
// - Removed unnecessary Flushes.
// - Take the psstm lock on RtlClosePropSet.
// 12-Jun-96 MikeHill - Fix locking in RtlClosePropertySet.
// - VT_I1 support (under ifdefs)
// 25-Jul-96 MikeHill - Removed Win32 SEH.
// - BSTRs & prop names: WCHAR => OLECHAR.
// - Added RtlOnMappedStreamEvent
// - Enabled for use in "iprop.dll".
// 03-Mar-98 MikeHill - Chagned "Pr" routines to "Stg".
// 06-May-98 MikeHill - Removed UnicodeCallouts.
// - Use CoTaskMem rather than new/delete.
// - Added support for VT_VECTOR|VT_I1
// 18-May-98 MikeHill - Fixed typos.
// 11-June-98 MikeHIll - Removed some old Cairo code.
// - Dbg output.
// - Add a pCodePage to PrSetProperties.
//
//---------------------------------------------------------------------------
#include <pch.cxx>
#include "propvar.h"
#include <olechar.h>
#include <stgprop.h>
#define Dbg DEBTRACE_NTPROP
#define DbgS(s) (NT_SUCCESS(s)? Dbg : DEBTRACE_ERROR)
#if DBG
ULONG DebugLevel = DEBTRACE_ERROR;//ULONG DebugLevel = DEBTRACE_ERROR | DEBTRACE_CREATESTREAM;
//ULONG DebugLevel = DEBTRACE_ERROR | MAXULONG;
ULONG DebugIndent;ULONG cAlloc;ULONG cFree;#endif
#if defined(WINNT) && !defined(IPROPERTY_DLL)
GUID guidStorage = PSGUID_STORAGE;
#endif // #if defined(WINNT) && !defined(IPROPERTY_DLL)
//+---------------------------------------------------------------------------
// Function: UnLock, private
//
// Synopsis: Unlock a PropertySetStream, and return the
// more severe of two NTSTATUSs; the result of
// the Unlock, or the one passed in by the caller.
//
// Arguments: [ppsstm] -- The CPropertySetStream to unlock
// [Status] -- NTSTATUS
//
// Returns: NTSTATUS
//---------------------------------------------------------------------------
inline NTSTATUSUnlock( CPropertySetStream *ppsstm, NTSTATUS Status ){ NTSTATUS StatusT = ppsstm->Unlock();
// Note that the statement below preserves
// success codes in the original Status unless
// there was an error in the Unlock.
if( NT_SUCCESS(Status) && !NT_SUCCESS(StatusT) ) Status = StatusT;
return( Status );}
//+---------------------------------------------------------------------------
// Function: PrCreatePropertySet, public
//
// Synopsis: Allocate and initialize a property set context
//
// Arguments: [ms] -- Nt Mapped Stream
// [Flags] -- *one* of READ/WRITE/CREATE/CREATEIF/DELETE
// [pguid] -- property set guid (create only)
// [pclsid] -- CLASSID of propset code (create only)
// [ma] -- caller's memory allocator
// [LocaleId] -- Locale Id (create only)
// [pOSVersion] -- pointer to the OS Version header field
// [pCodePage] -- pointer to new/returned CodePage of propset
// [pgrfBehavior] -- pointer to PROPSET_BEHAVIOR_* flags
// [pnp] -- pointer to returned property set context
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrCreatePropertySet( IN NTMAPPEDSTREAM ms, // Nt Mapped Stream
IN USHORT Flags, // *one* of READ/WRITE/CREATE/CREATEIF/DELETE
OPTIONAL IN GUID const *pguid, // property set guid (create only)
OPTIONAL IN GUID const *pclsid, // CLASSID of propset code (create only)
IN NTMEMORYALLOCATOR ma, // caller's memory allocator
IN ULONG LocaleId, // Locale Id (create only)
OPTIONAL OUT ULONG *pOSVersion, // OS Version from the propset header
IN OUT USHORT *pCodePage, // IN: CodePage of property set (create only)
// OUT: CodePage of property set (always)
IN OUT DWORD *pgrfBehavior, // IN: Behavior of property set (create only)
// OUT: Behavior of property set (always)
OUT NTPROP *pnp) // pointer to return prop set context
{ NTSTATUS Status; IMappedStream *pmstm = (IMappedStream *) ms; CPropertySetStream *ppsstm = NULL; BOOLEAN fLocked = FALSE; BOOLEAN fOpened = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrCreatePropertySet" ); propTraceParameters(( "ms=%p, f=0x%x, codepage=0x%x)", ms, Flags, *pCodePage ));
*pnp = NULL; Status = STATUS_INVALID_PARAMETER;
if( pOSVersion != NULL ) *pOSVersion = PROPSETHDR_OSVERSION_UNKNOWN;
// Validate the input flags
if (Flags & ~(CREATEPROP_MODEMASK | CREATEPROP_NONSIMPLE)) { propDbg(( DEB_ERROR, "PrCreatePropertySet(ms=%x, Flags=%x) ==> bad flags!\n", ms, Flags)); goto Exit; }
PROPASSERT( (0 == *pgrfBehavior) || (CREATEPROP_CREATE & Flags) ); PROPASSERT( !(*pgrfBehavior & ~PROPSET_BEHAVIOR_CASE_SENSITIVE) );
switch (Flags & CREATEPROP_MODEMASK) { case CREATEPROP_DELETE: case CREATEPROP_CREATE: case CREATEPROP_CREATEIF: case CREATEPROP_WRITE:
if (!pmstm->IsWriteable()) { Status = STATUS_ACCESS_DENIED; goto Exit; } // FALLTHROUGH
case CREATEPROP_READ: case CREATEPROP_UNKNOWN: if (ma == NULL) { goto Exit; } break;
default: propDbg(( DEB_ERROR, "PrCreatePropertySet(ms=%x, Flags=%x) ==> invalid mode!\n", ms, Flags)); goto Exit; }
Status = pmstm->Lock((Flags & CREATEPROP_MODEMASK) != CREATEPROP_READ); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm = new CPropertySetStream( Flags, pmstm, (PMemoryAllocator *) ma); if (ppsstm == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto Exit; } else { ppsstm->Open(pguid, pclsid, LocaleId, pOSVersion, *pCodePage, *pgrfBehavior, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
}
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
// If we were successfull with everything, set the
// out-parameters.
if( NT_SUCCESS(Status) ) { // pOSVersion has already been set.
*pCodePage = ppsstm->GetCodePage(); *pgrfBehavior = ppsstm->GetBehavior(); *pnp = (NTPROP) ppsstm; }
// Otherwise, if we created a CPropertySetStream object, but
// the overall operation failed, we must close/delete
// the object. Note that we must do this after
// the above unlock, since ppsstm will be gone after
// this call.
else if( NULL != ppsstm ) { PrClosePropertySet((NTPROP) ppsstm); }
if( STATUS_PROPSET_NOT_FOUND == Status ) propSuppressExitErrors();
return(Status);}
//+---------------------------------------------------------------------------
// Function: PrClosePropertySet, public
//
// Synopsis: Delete a property set context
//
// Arguments: [np] -- property set context
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrClosePropertySet( IN NTPROP np) // property set context
{ NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE; CPropertySetStream *ppsstm = (CPropertySetStream *) np;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrClosePropertySet" ); propTraceParameters(( "np=%p", np ));
// Lock the mapped stream, because this close
// may trigger a Write.
Status = ppsstm->Lock(TRUE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
// Note that we haven't ReOpen-ed the mapped stream. This
// isn't required for the CPropertySetStream::Close method.
ppsstm->Close(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
if( STG_E_REVERTED == Status ) propSuppressExitErrors();
delete ppsstm;
return(Status);}
//+---------------------------------------------------------------------------
// Function: PrOnMappedStreamEvent, public
//
// Synopsis: Handle a MappedStream event. Every such
// event requires a byte-swap of the property set
// headers.
//
// Arguments: [np] -- property set context
// [pbuf] -- property set buffer
// [cbstm] -- size of mapped stream (or CBSTM_UNKNOWN)
//
// NOTE: It is assumed that the caller has already taken
// the CPropertySetStream::Lock.
//
// Returns: Status code
//---------------------------------------------------------------------------
#ifdef BIGENDIAN
NTSTATUSPrOnMappedStreamEvent( IN VOID * np, // property set context (an NTPROP)
IN VOID *pbuf, // property set buffer
IN ULONG cbstm ){ NTSTATUS Status = STATUS_SUCCESS; CPropertySetStream *ppsstm = (CPropertySetStream *) np;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrOnMappedStreamEvent" ); propTraceParameters(( "np=%p, pbuf=%p, cbstm=%lu", np, pbuf, cbstm ));
// Byte-swap the property set headers.
ppsstm->ByteSwapHeaders((PROPERTYSETHEADER*) pbuf, cbstm, &Status ); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
return(Status);
} // PrOnMappedStreamEvent()
#endif
//+---------------------------------------------------------------------------
// Function: PrFlushPropertySet, public
//
// Synopsis: Flush property set changes to disk
//
// Arguments: [np] -- property set context
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrFlushPropertySet( IN NTPROP np) // property set context
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrFlushPropertySet" ); propTraceParameters(( "np=%p", np ));
Status = ppsstm->Lock(TRUE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
if (ppsstm->IsModified()) { ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); // (Debug only)
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Flush(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit; }
Exit:
if( fLocked ) Status = Unlock( ppsstm, Status );
return(Status);}
//+---------------------------------------------------------------------------
// Function: MapNameToPropId, private
//
// Synopsis: Find an available propid and map it to the passed name
//
// Arguments: [ppsstm] -- property set stream
// [CodePage] -- property set codepage
// [aprs] -- array of property specifiers
// [cprop] -- count of property specifiers
// [iprop] -- index of propspec with name to map
// [pidStart] -- first PROPID to start mapping attempts
// [pstatus] -- NTSTATUS code
//
// Returns: PROPID mapped to passed name
//
// Note: Find the first unused propid starting at pidStart.
//---------------------------------------------------------------------------
PROPIDMapNameToPropId( IN CPropertySetStream *ppsstm, // property set stream
IN USHORT CodePage, IN PROPSPEC const aprs[], // array of property specifiers
IN ULONG cprop, IN ULONG iprop, IN PROPID pidStart, OUT NTSTATUS *pstatus){ PROPID pid = PID_ILLEGAL; const OLECHAR *poszName = NULL; OLECHAR *poszNameFromDictionary = NULL; ULONG cbName;
*pstatus = STATUS_SUCCESS;
PROPASSERT(aprs[iprop].ulKind == PRSPEC_LPWSTR); poszName = aprs[iprop].lpwstr; PROPASSERT(IsOLECHARString( poszName, MAXULONG ));
IFDBG( HRESULT &hr = *pstatus ); propITraceStatic( "MapNameToPropId" ); propTraceParameters(( "ppsstm=%p, CodePage=%d, aprs=%p, cprop=%d, iprop=%d, pidStart=%d", ppsstm, CodePage, aprs, cprop, iprop, pidStart ));
// Starting with the caller-provided PID, search sequentially
// until we find a PID we can use.
for (pid = pidStart; ; pid++) { ULONG i;
// The caller must specify a starting propid of 2 or larger, and we
// must not increment into the reserved propids.
if (pid == PID_DICTIONARY || pid == PID_CODEPAGE || pid < PID_FIRST_USABLE) { *pstatus = STATUS_INVALID_PARAMETER; goto Exit; }
// Do not assign any propids that explitly appear in the array of
// propspecs involved in this PrSetProperties call, nor any propids
// that are associated with any names in the propspec array.
for (i = 0; i < cprop; i++) { if (i != iprop) // skip the entry we are mapping
{ // Is the current PID in the PropSpec[]?
if (aprs[i].ulKind == PRSPEC_PROPID && aprs[i].propid == pid) { goto nextpid; // skip colliding pid
}
// Is the current PID already used in the property set?
if (aprs[i].ulKind == PRSPEC_LPWSTR && ppsstm->QueryPropid(aprs[i].lpwstr, pstatus) == pid) { goto nextpid; // skip colliding pid
} if( !NT_SUCCESS(*pstatus) ) goto Exit; } } // for (i = 0; i < cprop; i++)
// Do not assign any propids that currently map to any name.
// Note that the property name we are mapping does not appear in the
// dictionary -- the caller checked for this case already.
if( ppsstm->QueryPropertyNames( 1, &pid, &poszNameFromDictionary, pstatus )) { CoTaskMemFree( poszNameFromDictionary ); poszNameFromDictionary = NULL; } else { // The property name could not be found in the dictionary.
ULONG cbT; SERIALIZEDPROPERTYVALUE const *pprop;
PROPASSERT( NULL == poszNameFromDictionary );
// Was the name not found due to an error in QueryPropertyNames?
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Do not assign any propids that currently have a property value.
pprop = ppsstm->GetValue(pid, &cbT, pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (pprop == NULL) { // There was no property value corresponding to this PID.
DebugTrace(0, Dbg, ( "MapNameToPropId(Set Entry: pid=%x, name=L'%ws')\n", pid, poszName));
// Add the caller-provided name to the dictionary, using
// the PID that we now know is nowhere in use.
ppsstm->SetPropertyNames(1, &pid, &poszName, pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit;
ppsstm->Validate(pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit;
break;
} // if (pprop == NULL)
} // if( ppsstm->QueryPropertyNames( 1, &pid, &poszNameFromDictionary, pstatus ))
nextpid: ; } // for (pid = pidStart; ; pid++)
Exit:
if( NULL != poszNameFromDictionary ) CoTaskMemFree( poszNameFromDictionary );
return(pid);}
//+---------------------------------------------------------------------------
// Function: ConvertVariantToPropInfo, private
//
// Synopsis: Convert variant property values to PROPERTY_INFORMATION values
//
// Arguments: [ppsstm] -- property set stream
// [cprop] -- property count
// [pidNameFirst] -- first PROPID for new named properties
// [aprs] -- array of property specifiers
// [apid] -- buffer for array of propids
// [avar] -- array of PROPVARIANTs
// [apinfo] -- output array of property info
// [pcIndirect] -- output count of indirect properties
//
// Returns: None
//
// Note: If pcIndirect is NULL,
//---------------------------------------------------------------------------
VOIDConvertVariantToPropInfo( IN CPropertySetStream *ppsstm, // property set stream
IN ULONG cprop, // property count
IN PROPID pidNameFirst, // first PROPID for new named properties
IN PROPSPEC const aprs[], // array of property specifiers
OPTIONAL OUT PROPID apid[], // buffer for array of propids
OPTIONAL IN PROPVARIANT const avar[],// array of properties+values
OUT PROPERTY_INFORMATION *apinfo, // output array of property info
OUT ULONG *pcIndirect, // output count of indirect properties
OUT NTSTATUS *pstatus ){ *pstatus = STATUS_SUCCESS;
USHORT CodePage = ppsstm->GetCodePage(); PROPID pidStart = pidNameFirst; ULONG iprop;
IFDBG( HRESULT &hr = *pstatus ); propITraceStatic( "ConvertVariantToPropInfo" ); propTraceParameters(( "ppsstm=%p, cprop=%d, pidNameFirst=%d, aprs=%p, apid=%p, avar=%p, apinfo=%p, pcIndirect=%p", ppsstm, cprop, pidNameFirst, aprs, apid, avar, apinfo, pcIndirect ));
if (pcIndirect != NULL) { *pcIndirect = 0; }
// Loop through each of the input propvariants and put it's info
// in the apinfo array.
for (iprop = 0; iprop < cprop; iprop++) { PROPID pid; ULONG cbprop;
// Get the PROPID into 'pid' (harder if this is a name)
// If a property is being written with a new name, we'll
// add it to the dictionary here.
switch(aprs[iprop].ulKind) { // For names, we have to work with the dictionary.
case PRSPEC_LPWSTR: { PROPASSERT(IsOLECHARString(aprs[iprop].lpwstr, MAXULONG));
// Is this property already in the dictionary?
pid = ppsstm->QueryPropid(aprs[iprop].lpwstr, pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If it's not in the dictionary, add it.
if (pid == PID_ILLEGAL && avar != NULL) { pid = MapNameToPropId( ppsstm, CodePage, aprs, cprop, iprop, pidStart, pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit;
pidStart = pid + 1; } break; }
// Otherwise, the caller has already explicitely given us the PID.
case PRSPEC_PROPID: pid = aprs[iprop].propid; break;
default: PROPASSERT(!"Bad ulKind"); *pstatus = STATUS_INVALID_PARAMETER; goto Exit;
break;
} // switch(aprs[iprop].ulKind)
// Store the PROPID in the apid array.
if (apid != NULL) { apid[iprop] = pid; }
// Calculate the size of the serialized property (cbprop).
// StgConvertVariantToProperty returns NULL on overflow and
// Raises on bad data.
cbprop = 0; // Assume property deletion
if (pid != PID_ILLEGAL && avar != NULL) { StgConvertVariantToPropertyNoEH( &avar[iprop], CodePage, NULL, // Don't actualy convert. We just want to calc cbprop.
&cbprop, pid, FALSE, FALSE, // Not a vector or array recursive call
pcIndirect, NULL, // Don't check for min format version required yet
pstatus); if( !NT_SUCCESS(*pstatus) ) goto Exit; PROPASSERT(cbprop == DwordAlign(cbprop)); }
// Store the size & PROPID into the PROPINFO array.
apinfo[iprop].cbprop = cbprop; apinfo[iprop].pid = pid;
} // for (iprop = 0; iprop < cprop; iprop++)
// ----
// Exit
// ----
Exit:
if( STATUS_NOT_SUPPORTED == *pstatus ) propSuppressExitErrors();
return;}
//+---------------------------------------------------------------------------
// Function: BuildIndirectIndexArray, private
//
// Synopsis: Set property values for a property set
//
// Arguments: [cprop] -- count of properties in avar
// [cAlloc] -- max count of indirect properties
// [cIndirect] -- count of indirect properties in avar
// [avar] -- array of PROPVARIANTs
// [ppip] -- ptr to ptr to Indirect property structures
//
// Returns: None
//---------------------------------------------------------------------------
VOIDBuildIndirectIndexArray( IN ULONG cprop, // count of properties in avar
IN ULONG cAlloc, // max count of indirect properties
IN ULONG cIndirect, // count of indirect properties in avar
IN PROPVARIANT const avar[],// array of properties+values
OPTIONAL OUT INDIRECTPROPERTY **ppip, // pointer to returned pointer to
// MAXULONG terminated array of Indirect
// properties w/indexes into aprs & avar
OUT NTSTATUS *pstatus){ *pstatus = STATUS_SUCCESS;
IFDBG( HRESULT &hr = *pstatus ); propITraceStatic( "BuildIndirectIndexArray" ); propTraceParameters(( "cprop=%d, cAlloc=%d, cIndirect=%d, avar=%p", cprop, cAlloc, cIndirect, avar ));
PROPASSERT(cIndirect > 0); PROPASSERT(cAlloc >= cIndirect); PROPASSERT(cprop >= cAlloc);
if (ppip != NULL) { INDIRECTPROPERTY *pip; ULONG iprop;
// Get a pointer to an INDIRECTPROPERTY array. If there
// is only one entry, then the caller has provided us the buffer.
// Otherwise, we need to allocate it.
if (cprop == 1) { pip = (INDIRECTPROPERTY *) ppip; } else { // Allocate the indrect property array
pip = (INDIRECTPROPERTY *) CoTaskMemAlloc( (cAlloc+1) * sizeof(INDIRECTPROPERTY) ); if (pip == NULL) { *pstatus = STATUS_INSUFFICIENT_RESOURCES; goto Exit; } *ppip = pip; }
// Loop through the properties, and for each that is indirect,
// put it's index into the INDIRECTPROPERTY array.
for (iprop = 0; iprop < cprop; iprop++) { if (IsIndirectVarType(avar[iprop].vt)) { PROPASSERT(cprop == 1 || (ULONG) (pip - *ppip) < cIndirect);
pip->Index = iprop; pip->poszName = NULL;
pip++; } }
// For the case where we allocated an array, we allocated an extra entry
// so that we could put a terminator at the end of the array.
if (cprop > 1) { pip->Index = MAXULONG; PROPASSERT((ULONG) (pip - *ppip) == cIndirect); }
} // if (ppip != NULL)
// ----
// Exit
// ----
Exit:
return;}
//+---------------------------------------------------------------------------
// Function: PrSetProperties, public
//
// Synopsis: Set property values for a property set
//
// Arguments: [np] -- property set context
// [cprop] -- property count
// [pidNameFirst] -- first PROPID for new named properties
// [aprs] -- array of property specifiers
// [apid] -- buffer for array of propids
// -- values to write in place of indirect properties
// [ppip] -- ptr to ptr to Indirect property structures
// [avar] -- array of PROPVARIANTs
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrSetProperties( IN NTPROP np, // property set context
IN ULONG cprop, // property count
IN PROPID pidNameFirst, // first PROPID for new named properties
IN PROPSPEC const aprs[], // array of property specifiers
OUT USHORT *pCodePage, OPTIONAL OUT PROPID apid[], // buffer for array of propids
OPTIONAL OUT INDIRECTPROPERTY **ppip, // pointer to returned pointer to
// MAXULONG terminated array of Indirect
// properties w/indexes into aprs & avar
IN PROPVARIANT const avar[]) // array of properties+values
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE;
PROPERTY_INFORMATION apinfoStack[6]; PROPERTY_INFORMATION *apinfo = apinfoStack; ULONG cIndirect = 0;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrSetProperties" ); propTraceParameters(( "np=%p, cprop=%d, pidNameFirst=%d, aprs=%p, CodePage=%d, apid=%p, ppip=%p, avar=%p", np, cprop, pidNameFirst, aprs, *pCodePage, apid, ppip, avar ));
// Initialize the INDIRECTPROPERTY structure.
if (ppip != NULL) { *ppip = NULL;
// If cprop is 1, ppip is actually pip (one level
// of indirection).
if (cprop == 1) { // Default the index.
((INDIRECTPROPERTY *) ppip)->Index = MAXULONG; } }
// Lock the property set.
Status = ppsstm->Lock(TRUE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
// Is the stack-based apinfo big enough?
if (cprop > sizeof(apinfoStack)/sizeof(apinfoStack[0])) { // No - we need to allocate an apinfo.
apinfo = reinterpret_cast<PROPERTY_INFORMATION*> ( CoTaskMemAlloc( sizeof(PROPERTY_INFORMATION) * cprop ));
if( NULL == apinfo ) { Status = STATUS_INSUFFICIENT_RESOURCES; goto Exit; } }
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// Describe the request into the apinfo array. This also writes the names
// to the dictionary.
ConvertVariantToPropInfo( ppsstm, cprop, pidNameFirst, aprs, apid, avar, apinfo, ppip == NULL? NULL : &cIndirect, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
// Write the value. If there are indirect properties, ppip will hold
// the stream/storage names.
ppsstm->SetValue(cprop, ppip, avar, apinfo, pCodePage, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
// If we allocated a temporary apinfo buffer, free it.
if (apinfo != apinfoStack) { CoTaskMemFree( apinfo ); }
// Clean up the PIP array on error.
if (!NT_SUCCESS(Status)) { if (ppip != NULL) { if (cprop == 1) { ((INDIRECTPROPERTY *) ppip)->Index = MAXULONG; } else if (*ppip != NULL) { CoTaskMemFree( *ppip ); *ppip = NULL; } } }
if (fLocked) Status = Unlock( ppsstm, Status );
if( STATUS_NOT_SUPPORTED == Status ) propSuppressExitErrors();
return(Status);}
//+---------------------------------------------------------------------------
// Function: PrQueryProperties, public
//
// Synopsis: Query property values from a property set
//
// Arguments: [np] -- property set context
// [cprop] -- property count
// [aprs] -- array of property specifiers
// [apid] -- buffer for array of propids
// [ppip] -- ptr to ptr to Indirect property structures
// [avar] -- array of PROPVARIANTs
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrQueryProperties( IN NTPROP np, // property set context
IN ULONG cprop, // property count
IN PROPSPEC const aprs[], // array of property specifiers
OPTIONAL OUT PROPID apid[], // buffer for array of propids
OPTIONAL OUT INDIRECTPROPERTY **ppip, // pointer to returned pointer to
// MAXULONG terminated array of Indirect
// properties w/indexes into aprs & avar
IN OUT PROPVARIANT *avar, // IN: array of uninitialized PROPVARIANTs,
// OUT: may contain pointers to alloc'd memory
OUT ULONG *pcpropFound) // count of property values retrieved
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; SERIALIZEDPROPERTYVALUE const *pprop = NULL; NTSTATUS Status = STATUS_SUCCESS; ULONG cIndirect = 0; ULONG iprop; BOOL fLocked = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrQueryProperties" ); propTraceParameters(( "np=%p, cprop=%d, aprs=%p, apid=%p, ppip=%p)", np, cprop, aprs, apid, ppip ));
// Initialize the variant array enough to allow it to be cleaned up
// by the caller (even on partial failure).
*pcpropFound = 0; if (ppip != NULL) { *ppip = NULL; if (cprop == 1) { ((INDIRECTPROPERTY *) ppip)->Index = MAXULONG; } }
// Zero-ing out the caller-provided PropVariants, essentially
// sets them all to VT_EMPTY. It also zeros out the data portion,
// which prevents cleanup problems in error paths.
RtlZeroMemory(avar, cprop * sizeof(avar[0]));
Status = ppsstm->Lock(FALSE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// Loop through and get all the property values.
for (iprop = 0; iprop < cprop; iprop++) { PROPID pid; ULONG cbprop;
// Get the PROPID to query
switch(aprs[iprop].ulKind) { // Query the PROPID from the caller-provided name.
case PRSPEC_LPWSTR: pid = ppsstm->QueryPropid(aprs[iprop].lpwstr, &Status); if( !NT_SUCCESS(Status) ) goto Exit; break;
// The caller already gave us the PROPID
case PRSPEC_PROPID: pid = aprs[iprop].propid; break;
default: PROPASSERT(!"Bad ulKind"); Status = STATUS_INVALID_PARAMETER; goto Exit;
}
// Get a pointer to the value in the serialized stream
// (into pprop). If this succeeds, pprop will point
// to the value, and we will know that the value fits within
// the section (so e.g. there's no corrupt length fields).
pprop = ppsstm->GetValue(pid, &cbprop, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
if (pprop != NULL) { // We got the property value.
BOOL fIndirect;
// De-serialize the property value from pprop to
// a PROPVARIANT (into an entry in the avar array).
(*pcpropFound)++; fIndirect = StgConvertPropertyToVariantNoEH( pprop, cbprop, ppsstm->GetCodePage(), &avar[iprop], ppsstm->GetAllocator(), &Status); if( !NT_SUCCESS(Status) ) goto Exit;
PROPASSERT( ( !(VT_ARRAY & avar[iprop].vt) && !(VT_BYREF & avar[iprop].vt) && VT_DECIMAL != avar[iprop].vt && VT_I1 != avar[iprop].vt && VT_INT != avar[iprop].vt && VT_UINT != avar[iprop].vt ) || PROPSET_WFORMAT_EXPANDED_VTS <= ppsstm->GetFormatVersion() );
// Keep a count of the number of indirect (aka non-simple) properties.
if( fIndirect ) { cIndirect++; }
} // if (pprop != NULL)
// Pass the actual PROPID back to the caller.
if (apid != NULL) { apid[iprop] = pid; }
} // for (iprop = 0; iprop < cprop; iprop++)
// If the caller wants to know about indirect streams and
// storages (and if there were any), allocate memory for a
// MAXULONG terminated array of indexes to the indirect
// variant structures, and fill it in.
if (cIndirect != 0) { BuildIndirectIndexArray( cprop, cIndirect, cIndirect, avar, ppip, &Status); if( !NT_SUCCESS(Status) ) goto Exit; }
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if( !NT_SUCCESS(Status) ) { if (ppip != NULL) { if (cprop == 1) { ((INDIRECTPROPERTY *) ppip)->Index = MAXULONG; } else if (*ppip != NULL) { CoTaskMemFree( *ppip ); *ppip = NULL; } }
CleanupVariants(avar, cprop, ppsstm->GetAllocator()); }
if (fLocked) Status = Unlock( ppsstm, Status );
if( STATUS_NOT_SUPPORTED == Status ) propSuppressExitErrors();
return(Status);}
//+---------------------------------------------------------------------------
// Function: PrEnumerateProperties, public
//
// Synopsis: Enumerate properties in a property set
//
// Arguments: [np] -- property set context
// [cskip] -- count of properties to skip
// [pcprop] -- pointer to property count
// [Flags] -- flags: No Names (propids only), etc.
// [asps] -- array of STATPROPSTGs
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrEnumerateProperties( IN NTPROP np, // property set context
IN ULONG Flags, // flags: No Names (propids only), etc.
IN ULONG *pkey, // count of properties to skip
IN OUT ULONG *pcprop, // pointer to property count
OPTIONAL OUT PROPSPEC aprs[],// IN: array of uninitialized PROPSPECs
// OUT: may contain pointers to alloc'd strings
OPTIONAL OUT STATPROPSTG asps[]) // IN: array of uninitialized STATPROPSTGs
// OUT: may contain pointers to alloc'd strings
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; SERIALIZEDPROPERTYVALUE const *pprop = NULL; PROPSPEC *pprs; STATPROPSTG *psps; PROPID *ppidBase = NULL; ULONG i; ULONG cpropin; BOOL fLocked = FALSE;
PROPID apidStack[20]; PROPID *ppid; ULONG cprop; PMemoryAllocator *pma = ppsstm->GetAllocator();
// PERF: It'd be good to rewrite this name code so that it uses
// a default-sized stack buffer where possible, which will be most of
// the time.
OLECHAR *poszName = NULL;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrEnumerateProperties" ); propTraceParameters(( "np=%p, Flags=0x%x, key=0x%x, cprop=%d, aprs=%p, asps=%p)\n", np, Flags, *pkey, *pcprop, aprs, asps));
cpropin = *pcprop;
// Eliminate confusion for easy cleanup
if (aprs != NULL) { // Set all the PropSpecs to PROPID (which require
// no cleanup).
for (i = 0; i < cpropin; i++) { aprs[i].ulKind = PRSPEC_PROPID; } }
// Zero all pointers in the array for easy cleanup
if (asps != NULL) { RtlZeroMemory(asps, cpropin * sizeof(asps[0])); }
Status = ppsstm->Lock(FALSE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppidBase = NULL;
cprop = ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
if (cprop > cpropin) { cprop = cpropin; }
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// Point ppid to an array of PROPIDs (either on stack for perf, or in heap
// if too big).
ppid = NULL; if (aprs != NULL || asps != NULL) { ppid = apidStack;
if (cprop > sizeof(apidStack)/sizeof(apidStack[0])) { // Too big for the stack, alloc it out of heap.
ppidBase = reinterpret_cast<PROPID*>( CoTaskMemAlloc( cprop * sizeof(PROPID) )); if (ppidBase == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto Exit; }
ppid = ppidBase; } }
// Enumerate the PROPIDs and put them into the PROPID array we
// just set up (ppid)
ppsstm->EnumeratePropids(pkey, &cprop, ppid, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
*pcprop = cprop;
// Load the STATPROPSTG array (asps) and PROPSPEC array (aprs)
if (ppid != NULL) { psps = asps; pprs = aprs;
while (cprop-- > 0) { ULONG cbprop; BOOLEAN fHasName; PROPASSERT(*ppid != PID_DICTIONARY && *ppid != PID_CODEPAGE); fHasName = FALSE;
// Unless the caller doesn't want names, get this property's name.
if ((Flags & ENUMPROP_NONAMES) == 0) { fHasName = ppsstm->QueryPropertyNames( 1, ppid, &poszName, &Status ); if( !NT_SUCCESS(Status) ) goto Exit; }
// If we're filling in the PROPSPEC array, load the
// name or PROPID now.
if (pprs != NULL) { PROPASSERT(pprs->ulKind == PRSPEC_PROPID); if (fHasName) { pprs->lpwstr = ppsstm->DuplicatePropertyName( poszName, &Status ); if( !NT_SUCCESS(Status) ) goto Exit; PROPASSERT(pprs->lpwstr != NULL);
// Make this assignment *after* memory allocation
// succeeds so we free only valid pointers in below
// cleanup code.
pprs->ulKind = PRSPEC_LPWSTR; } else { pprs->propid = *ppid; } pprs++;
} // if (pprs != NULL)
// If we're passing back the STATPROPSTGs, fill it in for
// this property.
if (psps != NULL) { pprop = ppsstm->GetValue(*ppid, &cbprop, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
PROPASSERT(psps->lpwstrName == NULL); if (fHasName) { psps->lpwstrName = ppsstm->DuplicatePropertyName( poszName, &Status); if( !NT_SUCCESS(Status) ) goto Exit; PROPASSERT(psps->lpwstrName != NULL); }
psps->propid = *ppid; psps->vt = (VARTYPE) PropByteSwap( pprop->dwType );
psps++;
} // if (psps != NULL)
ppid++; CoTaskMemFree( poszName ); poszName = NULL;
} // while (cprop-- > 0)
} // if (ppid != NULL)
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
if( NULL != poszName ) CoTaskMemFree( poszName );
CoTaskMemFree( ppidBase );
if (!NT_SUCCESS(Status)) { PMemoryAllocator *pma2 = ppsstm->GetAllocator();
if (aprs != NULL) { for (i = 0; i < cpropin; i++) { if (aprs[i].ulKind == PRSPEC_LPWSTR) { pma2->Free(aprs[i].lpwstr); aprs[i].ulKind = PRSPEC_PROPID; } } }
if (asps != NULL) { for (i = 0; i < cpropin; i++) { if (asps[i].lpwstrName != NULL) { pma2->Free(asps[i].lpwstrName); asps[i].lpwstrName = NULL; } } } } // if (!NT_SUCCESS(Status))
#if DBG
if (NT_SUCCESS(Status)) { if (aprs != NULL) { for (i = 0; i < cpropin; i++) { if (aprs[i].ulKind == PRSPEC_LPWSTR) { PROPASSERT(aprs[i].lpwstr != NULL); PROPASSERT(ocslen(aprs[i].lpwstr) > 0); } } } if (asps != NULL) { for (i = 0; i < cpropin; i++) { if (asps[i].lpwstrName != NULL) { PROPASSERT(ocslen(asps[i].lpwstrName) > 0); } } } }#endif // DBG
return(Status);}
//+---------------------------------------------------------------------------
// Function: PrQueryPropertyNames, public
//
// Synopsis: Read property names for PROPIDs in a property set
//
// Arguments: [np] -- property set context
// [cprop] -- property count
// [apid] -- array of PROPIDs
// [aposz] -- array of pointers to WCHAR strings
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrQueryPropertyNames( IN NTPROP np, // property set context
IN ULONG cprop, // property count
IN PROPID const *apid, // PROPID array
OUT OLECHAR *aposz[]) // OUT pointers to allocated strings
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; NTSTATUS StatusQuery = STATUS_SUCCESS; BOOL fLocked = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrQueryPropertyNames" ); propTraceParameters(( "np=%p, cprop=%d, apid=%p, aposz=%p)", np, cprop, apid, aposz ));
RtlZeroMemory(aposz, cprop * sizeof(aposz[0]));
Status = ppsstm->Lock(FALSE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// We'll save the Status from the following call. If there
// are no other errors, we'll return it to the caller (it
// might contain a useful success code).
ppsstm->QueryPropertyNames(cprop, apid, aposz, &StatusQuery); if( !NT_SUCCESS(StatusQuery) ) { Status = StatusQuery; goto Exit; }
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
if( NT_SUCCESS(Status) ) Status = StatusQuery;
return(Status);
} // PrQueryPropertyNames()
//+---------------------------------------------------------------------------
// Function: PrSetPropertyNames, public
//
// Synopsis: Write property names for PROPIDs in a property set
//
// Arguments: [np] -- property set context
// [cprop] -- property count
// [apid] -- array of PROPIDs
// [aposz] -- array of pointers to OLECHAR strings
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrSetPropertyNames( IN NTPROP np, // property set context
IN ULONG cprop, // property count
IN PROPID const *apid, // PROPID array
IN OLECHAR const * const aposz[]) // pointers to property names
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrSetPropertyNames" ); propTraceParameters(( "np=%p, cprop=%d, apid=%p, aposz=%p", np, cprop, apid, aposz ));
Status = ppsstm->Lock(TRUE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->SetPropertyNames(cprop, apid, aposz, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
return(Status);
} // PrSetPropertyNames()
//+---------------------------------------------------------------------------
// Function: PrSetPropertySetClassId, public
//
// Synopsis: Set the property set's ClassId
//
// Arguments: [np] -- property set context
// [pspss] -- pointer to STATPROPSETSTG
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrSetPropertySetClassId( IN NTPROP np, // property set context
IN GUID const *pclsid) // new CLASSID of propset code
{ CPropertySetStream *ppsstm = (CPropertySetStream *) np; NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrSetPropertySetClassId" ); propTraceParameters(( "np=%p, pclsid=%p", np, pclsid ));
Status = ppsstm->Lock(TRUE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->SetClassId(pclsid, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
return(Status);
} // PrSetPropertySetClassId()
//+---------------------------------------------------------------------------
// Function: PrQueryPropertySet, public
//
// Synopsis: Query the passed property set
//
// Arguments: [np] -- property set context
// [pspss] -- pointer to STATPROPSETSTG
//
// Returns: Status code
//---------------------------------------------------------------------------
NTSTATUSPrQueryPropertySet( IN NTPROP np, // property set context
OUT STATPROPSETSTG *pspss) // buffer for property set stat information
{ NTSTATUS Status = STATUS_SUCCESS; BOOL fLocked = FALSE; CPropertySetStream *ppsstm = (CPropertySetStream *) np;
IFDBG( HRESULT &hr = Status ); propITraceStatic( "PrQueryPropertySet" ); propTraceParameters(( "np=%p, pspss=%p", np, pspss ));
RtlZeroMemory(pspss, sizeof(*pspss));
Status = ppsstm->Lock(FALSE); if( !NT_SUCCESS(Status) ) goto Exit; fLocked = TRUE;
ppsstm->ReOpen(&Status); // Reload header/size info
if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->QueryPropertySet(pspss, &Status); if( !NT_SUCCESS(Status) ) goto Exit;
ppsstm->Validate(&Status); if( !NT_SUCCESS(Status) ) goto Exit;
// ----
// Exit
// ----
Exit:
if (fLocked) Status = Unlock( ppsstm, Status );
return(Status);
} // PrQueryPropertySet()
inline BOOLEAN_Compare_VT_BOOL(VARIANT_BOOL bool1, VARIANT_BOOL bool2){ // Allow any non-zero value to match any non-zero value
return((bool1 == FALSE) == (bool2 == FALSE));}
BOOLEAN_Compare_VT_CF(CLIPDATA *pclipdata1, CLIPDATA *pclipdata2){ BOOLEAN fSame;
if (pclipdata1 != NULL && pclipdata2 != NULL) { fSame = ( pclipdata1->cbSize == pclipdata2->cbSize && pclipdata1->ulClipFmt == pclipdata2->ulClipFmt );
if (fSame) { if (pclipdata1->pClipData != NULL && pclipdata2->pClipData != NULL) { fSame = memcmp( pclipdata1->pClipData, pclipdata2->pClipData, CBPCLIPDATA(*pclipdata1) ) == 0; } else { // They're the same if both are NULL, or if
// they have a zero length (if they have a zero
// length, either one may or may not be NULL, but they're
// still considered the same).
// Note that CBPCLIPDATA(*pclipdata1)==CBPCLIPDATA(*pclipdata2).
fSame = pclipdata1->pClipData == pclipdata2->pClipData || CBPCLIPDATA(*pclipdata1) == 0; } } } else { fSame = pclipdata1 == pclipdata2; } return(fSame);}
//+---------------------------------------------------------------------------
// Function: PrCompareVariants, public
//
// Synopsis: Compare two passed PROPVARIANTs -- case sensitive for strings
//
// Arguments: [CodePage] -- CodePage
// [pvar1] -- pointer to PROPVARIANT
// [pvar2] -- pointer to PROPVARIANT
//
// Returns: TRUE if identical, else FALSE
//---------------------------------------------------------------------------
#ifdef _MAC
EXTERN_C // The Mac linker doesn't seem to be able to export with C++ decorations
#endif
BOOLEANPrCompareVariants( USHORT CodePage, PROPVARIANT const *pvar1, PROPVARIANT const *pvar2){ if (pvar1->vt != pvar2->vt) { return(FALSE); }
BOOLEAN fSame; ULONG i;
switch (pvar1->vt) { case VT_EMPTY: case VT_NULL: fSame = TRUE; break;
case VT_I1: case VT_UI1: fSame = pvar1->bVal == pvar2->bVal; break;
case VT_I2: case VT_UI2: fSame = pvar1->iVal == pvar2->iVal; break;
case VT_BOOL: fSame = _Compare_VT_BOOL(pvar1->boolVal, pvar2->boolVal); break;
case VT_I4: case VT_UI4: case VT_R4: case VT_ERROR: fSame = pvar1->lVal == pvar2->lVal; break;
case VT_I8: case VT_UI8: case VT_R8: case VT_CY: case VT_DATE: case VT_FILETIME: fSame = pvar1->hVal.HighPart == pvar2->hVal.HighPart && pvar1->hVal.LowPart == pvar2->hVal.LowPart; break;
case VT_CLSID: fSame = memcmp(pvar1->puuid, pvar2->puuid, sizeof(CLSID)) == 0; break;
case VT_BLOB: case VT_BLOB_OBJECT: fSame = ( pvar1->blob.cbSize == pvar2->blob.cbSize ); if (fSame) { fSame = memcmp( pvar1->blob.pBlobData, pvar2->blob.pBlobData, pvar1->blob.cbSize) == 0; } break;
case VT_CF: fSame = _Compare_VT_CF(pvar1->pclipdata, pvar2->pclipdata); break;
case VT_BSTR: if (pvar1->bstrVal != NULL && pvar2->bstrVal != NULL) { fSame = ( BSTRLEN(pvar1->bstrVal) == BSTRLEN(pvar2->bstrVal) ); if (fSame) { fSame = memcmp( pvar1->bstrVal, pvar2->bstrVal, BSTRLEN(pvar1->bstrVal)) == 0; } } else { fSame = pvar1->bstrVal == pvar2->bstrVal; } break;
case VT_LPSTR: if (pvar1->pszVal != NULL && pvar2->pszVal != NULL) { fSame = strcmp(pvar1->pszVal, pvar2->pszVal) == 0; } else { fSame = pvar1->pszVal == pvar2->pszVal; } break;
case VT_STREAM: case VT_STREAMED_OBJECT: case VT_STORAGE: case VT_STORED_OBJECT: case VT_LPWSTR: if (pvar1->pwszVal != NULL && pvar2->pwszVal != NULL) { fSame = Prop_wcscmp(pvar1->pwszVal, pvar2->pwszVal) == 0; } else { fSame = pvar1->pwszVal == pvar2->pwszVal; } break;
case VT_VECTOR | VT_I1: case VT_VECTOR | VT_UI1: fSame = ( pvar1->caub.cElems == pvar2->caub.cElems ); if (fSame) { fSame = memcmp( pvar1->caub.pElems, pvar2->caub.pElems, pvar1->caub.cElems * sizeof(pvar1->caub.pElems[0])) == 0; } break;
case VT_VECTOR | VT_I2: case VT_VECTOR | VT_UI2: fSame = ( pvar1->cai.cElems == pvar2->cai.cElems ); if (fSame) { fSame = memcmp( pvar1->cai.pElems, pvar2->cai.pElems, pvar1->cai.cElems * sizeof(pvar1->cai.pElems[0])) == 0; } break;
case VT_VECTOR | VT_BOOL: fSame = ( pvar1->cabool.cElems == pvar2->cabool.cElems ); if (fSame) { for (i = 0; i < pvar1->cabool.cElems; i++) { fSame = _Compare_VT_BOOL( pvar1->cabool.pElems[i], pvar2->cabool.pElems[i]); if (!fSame) { break; } } } break;
case VT_VECTOR | VT_I4: case VT_VECTOR | VT_UI4: case VT_VECTOR | VT_R4: case VT_VECTOR | VT_ERROR: fSame = ( pvar1->cal.cElems == pvar2->cal.cElems ); if (fSame) { fSame = memcmp( pvar1->cal.pElems, pvar2->cal.pElems, pvar1->cal.cElems * sizeof(pvar1->cal.pElems[0])) == 0; } break;
case VT_VECTOR | VT_I8: case VT_VECTOR | VT_UI8: case VT_VECTOR | VT_R8: case VT_VECTOR | VT_CY: case VT_VECTOR | VT_DATE: case VT_VECTOR | VT_FILETIME: fSame = ( pvar1->cah.cElems == pvar2->cah.cElems ); if (fSame) { fSame = memcmp( pvar1->cah.pElems, pvar2->cah.pElems, pvar1->cah.cElems * sizeof(pvar1->cah.pElems[0])) == 0; } break;
case VT_VECTOR | VT_CLSID: fSame = ( pvar1->cauuid.cElems == pvar2->cauuid.cElems ); if (fSame) { fSame = memcmp( pvar1->cauuid.pElems, pvar2->cauuid.pElems, pvar1->cauuid.cElems * sizeof(pvar1->cauuid.pElems[0])) == 0; } break;
case VT_VECTOR | VT_CF: fSame = ( pvar1->caclipdata.cElems == pvar2->caclipdata.cElems ); if (fSame) { for (i = 0; i < pvar1->caclipdata.cElems; i++) { fSame = _Compare_VT_CF( &pvar1->caclipdata.pElems[i], &pvar2->caclipdata.pElems[i]); if (!fSame) { break; } } } break;
case VT_VECTOR | VT_BSTR: fSame = ( pvar1->cabstr.cElems == pvar2->cabstr.cElems ); if (fSame) { for (i = 0; i < pvar1->cabstr.cElems; i++) { if (pvar1->cabstr.pElems[i] != NULL && pvar2->cabstr.pElems[i] != NULL) { fSame = ( BSTRLEN(pvar1->cabstr.pElems[i]) == BSTRLEN(pvar2->cabstr.pElems[i]) ); if (fSame) { fSame = memcmp( pvar1->cabstr.pElems[i], pvar2->cabstr.pElems[i], BSTRLEN(pvar1->cabstr.pElems[i])) == 0; } } else { fSame = pvar1->cabstr.pElems[i] == pvar2->cabstr.pElems[i]; } if (!fSame) { break; } } } break;
case VT_VECTOR | VT_LPSTR: fSame = ( pvar1->calpstr.cElems == pvar2->calpstr.cElems ); if (fSame) { for (i = 0; i < pvar1->calpstr.cElems; i++) { if (pvar1->calpstr.pElems[i] != NULL && pvar2->calpstr.pElems[i] != NULL) { fSame = strcmp( pvar1->calpstr.pElems[i], pvar2->calpstr.pElems[i]) == 0; } else { fSame = pvar1->calpstr.pElems[i] == pvar2->calpstr.pElems[i]; } if (!fSame) { break; } } } break;
case VT_VECTOR | VT_LPWSTR: fSame = ( pvar1->calpwstr.cElems == pvar2->calpwstr.cElems ); if (fSame) { for (i = 0; i < pvar1->calpwstr.cElems; i++) { if (pvar1->calpwstr.pElems[i] != NULL && pvar2->calpwstr.pElems[i] != NULL) { fSame = Prop_wcscmp( pvar1->calpwstr.pElems[i], pvar2->calpwstr.pElems[i]) == 0; } else { fSame = pvar1->calpwstr.pElems[i] == pvar2->calpwstr.pElems[i]; } if (!fSame) { break; } } } break;
case VT_VECTOR | VT_VARIANT: fSame = ( pvar1->capropvar.cElems == pvar2->capropvar.cElems ); if (fSame) { for (i = 0; i < pvar1->capropvar.cElems; i++) { fSame = PrCompareVariants( CodePage, &pvar1->capropvar.pElems[i], &pvar2->capropvar.pElems[i]); if (!fSame) { break; } } } break;
default: PROPASSERT(!"Invalid type for PROPVARIANT Comparison"); fSame = FALSE; break;
} return(fSame);}
|
