Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/ole32/stg/props/propstm.cxx

7972 lines
240 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1993
//
// File: propstm.cxx
//
// Contents: property set value extraction code
//
// History: 15-Jul-94 brianb created
// 12-Aug-94 SethuR Included Assertions for # of sections
// split PropertySet class into
// CPropertySetStream & CPropertySetStorage
// Included Update methods on the property
// stream.
// 22-Feb-96 MikeHill DWORD-align the dictionary entries,
// & use char-counts for dict entries.
// 29-Feb-96 MikeHill Moved _DictionaryEntryLength and _NextDictionaryEntry
// inlines here from propstm.hxx.
// 09-May-96 MikeHill - Keep the dictionary in the UserDef propset
// immediately after the last entry in the PID/Offset
// array (for Office95 compatibility).
// - Create an empty dictionary in the UD propset
// when it is created. If we wait till later,
// we can't make the dictionary the first property,
// which is required by Office95.
// - Provide compatibility with Publisher95 (which doesn't
// DWORD-align the section/stream size).
// - Provide compatibility with PowerPoint 4.0 (which
// over-pads some properties, and under-pads others).
// - Don't try to unpack the DocParts and HeadingPair
// DocSumInfo properties in Ansi property sets.
// 22-May-96 MikeHill - Return the OSVersion on an Open.
// - Use the PropSet's code page, not the system's.
// 11-Jun-96 MikeHill - Initialize all members in the constructor.
// 25-Jul-96 MikeHill - Removed usage of Win32 SEH.
// - BSTRs & prop names: WCHAR => OLECHAR.
// - Added big-endian support.
// - Determine the OSVer at run-time.
// - Fix for Excel 5.0a compatibility.
// 26-Nov-96 MikeHill Handle invalid oSection values.
//
// Notes:
//
// The OLE 2.0 Appendix B property set specifies multiple sections in the
// property stream specification. Multiple sections were intended to allow
// the schema associated with the property set to evolve over a period of time,
// but there is no reason that new PROPIDs cannot serve the same purpose. The
// current implementation of the property stream is limited to one section,
// except for the Office DocumentSummaryInformation property set's specific use
// of a second section. Other property sets with multiple sections can only be
// accessed in read-only mode, and then only for the first property section.
//
// The current implementation of property set stream is built around a class
// called CPropertySetStream. The various details of the OLE property spec is
// confined to this class. Since the property set streams need to be parsed
// in the kernel mode (OFS driver) as well as the user mode, this class
// encapsulates a stream implementation (CMappedStream). This is different
// from other stream implementations in that the fundamental mechanism provided
// for acessing the contents is Map/Unmap rather than Read/Write. There are
// two user mode implementations of this CMappedStream interface, one for
// docfile streams, and another for native streams. There is one
// implementation in kernel mode for the OFS driver. For more details,
// refer to propstm.hxx.
//---------------------------------------------------------------------------
#include <pch.cxx>
#include <olechar.h>
#if DBGPROP
#include <stdio.h> // for sprintf/strcpy
#endif
#include "propvar.h"
#define Dbg DEBTRACE_PROPERTY
#define szX "x" // allows radix change for offsets & sizes
//#define szX "d" // allows radix change for offsets & sizes
#ifndef newk
#define newk(Tag, pCounter) new
#endif
#ifndef IsDwordAligned
#define IsDwordAligned(p) (((ULONG) (p) & (sizeof(ULONG) - 1)) == 0)
#endif
#ifndef DwordRemain
#define DwordRemain(cb) \
((sizeof(ULONG) - ((cb) % sizeof(ULONG))) % sizeof(ULONG))
#endif
// Information for the the OS Version field of the
// property set header.
#if !defined(IPROPERTY_DLL)
# define PROPSETVER_CURRENT MAKEPSVER(OSKIND_WIN32, WINVER >> 8, WINVER & 0xff)
#endif
#define PROPSETVER_WIN310 MAKEPSVER(OSKIND_WINDOWS, 3, 10)
#define PROPSETVER_WIN333 MAKEPSVER(OSKIND_WIN32, 3, 0x33)
extern GUID guidSummary;
extern GUID guidDocumentSummary;
extern GUID guidDocumentSummarySection2;
#define CP_DEFAULT_NONUNICODE 1252 // ANSI Latin1 (US, Western Europe)
#ifdef KERNEL
#define CP_CREATEDEFAULT(state) \
((state & CPSS_PROPHEADER)? CP_DEFAULT_NONUNICODE : CP_WINUNICODE)
#else
extern "C" UNICODECALLOUTS UnicodeCallouts;
#define CP_CREATEDEFAULT(state) (*UnicodeCallouts.pfnGetACP)()
#endif
#if DBGPROP
#define StatusCorruption(pstatus, szReason) \
_StatusCorruption(szReason " ", pstatus)
#else
#define StatusCorruption(pstatus, szReason) \
_StatusCorruption(pstatus)
#endif
#ifndef KERNEL
VOID RtlpConvertToUnicode(
IN CHAR const *pch,
IN ULONG cb,
IN USHORT CodePage,
OUT WCHAR **ppwc,
OUT ULONG *pcb,
OUT NTSTATUS *pstatus);
VOID RtlpConvertToMultiByte(
IN WCHAR const *pwc,
IN ULONG cb,
IN USHORT CodePage,
OUT CHAR **ppch,
OUT ULONG *pcb,
OUT NTSTATUS *pstatus);
#endif
//
// Re-direct RtlEqual[Unicode]String routines
//
// These macros redirect two NTDLL routines which don't exist in
// the IProperty DLL. They are redirected to CRT calls.
//
// Note: These redirections assume that the Length and
// MaximumLength fields, on both String structures, are the
// same (e.g. s1.len == s1.maxlen == s2.len == s2.maxlen).
//
#ifdef IPROPERTY_DLL
#define RtlEqualString(String1,String2,fCaseInSensitive) \
fCaseInSensitive \
? ( !_strnicmp( (String1)->Buffer, \
(String2)->Buffer, \
(String1)->MaximumLength) ) \
: ( !strncmp( (String1)->Buffer, \
(String2)->Buffer, \
(String1)->MaximumLength) )
#define RtlEqualUnicodeString(String1,String2,fCaseInSensitive) \
fCaseInSensitive \
? ( !_wcsnicmp( (String1)->Buffer, \
(String2)->Buffer, \
(String1)->MaximumLength / sizeof(WCHAR) )) \
: ( !wcsncmp( (String1)->Buffer, \
(String2)->Buffer, \
(String1)->MaximumLength / sizeof(WCHAR) ))
#endif // #ifdef IPROPERTY_DLL
#if DBGPROP
#define CB_VALUEDISPLAY 8 // Number of bytes to display
#define CB_VALUESTRING (CB_VALUEDISPLAY * 3 + 3) // "xx xx xx xx...\0"
char *
ValueToString(SERIALIZEDPROPERTYVALUE const *pprop, ULONG cbprop, char buf[])
{
char *p = buf;
BYTE const *pb = pprop->rgb;
BOOLEAN fOverflow = FALSE;
static char szDots[] = "...";
if (cbprop >= FIELD_OFFSET(SERIALIZEDPROPERTYVALUE, rgb))
{
cbprop -= FIELD_OFFSET(SERIALIZEDPROPERTYVALUE, rgb);
if (cbprop > CB_VALUEDISPLAY)
{
cbprop = CB_VALUEDISPLAY;
fOverflow = TRUE;
}
while (cbprop-- > 0)
{
if (p != buf)
{
*p++ = ' ';
}
p += PropSprintfA( p, "%02.2x", *pb++ );
}
}
*p = '\0';
PROPASSERT(p - buf + sizeof(szDots) <= CB_VALUESTRING);
if (fOverflow)
{
strcpy(p, szDots);
}
return(buf);
}
#define CB_VARIANT_TO_STRING 35
char *
VariantToString(PROPVARIANT const &var, char buf[], ULONG cbprop)
{
char *p = buf;
PROPASSERT( cbprop >= CB_VARIANT_TO_STRING );
// Add the VT to the output buffer.
p += PropSprintfA( p, "vt=%04.4x", var.vt );
p += PropSprintfA( p, ", val=(%08.8x, %08.8x)", var.uhVal.LowPart, var.uhVal.HighPart );
*p = '\0';
PROPASSERT( (p - buf) == CB_VARIANT_TO_STRING);
return(buf);
}
#endif
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_DictionaryEntryLength
//
// Synopsis: Calculate the length of an entry in the
// dictionary. This is non-trivial because
// it is codepage-dependent.
//
// Arguments: [pent] -- pointer to a dictionary entry.
//
// Returns: The entry's length.
//+--------------------------------------------------------------------------
inline ULONG
CPropertySetStream::_DictionaryEntryLength(
IN ENTRY UNALIGNED const * pent
) const
{
// If this is a Unicode property set, it should be DWORD-aligned.
PROPASSERT( _CodePage != CP_WINUNICODE
||
IsDwordAligned( (ULONG) pent ));
// The size consists of the length of the
// PROPID and character count ...
ULONG ulSize = CB_ENTRY;
// Plus the length of the string ...
ulSize += PropByteSwap( pent->cch )
*
( _CodePage == CP_WINUNICODE ? sizeof( WCHAR )
: sizeof( CHAR )
);
// Plus, possibly, padding to make the entry DWORD-aligned
// (for Unicode property sets).
if( _CodePage == CP_WINUNICODE )
{
ulSize = DwordAlign( ulSize );
}
return( ulSize );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_NextDictionaryEntry
//
// Synopsis: Given a pointer to an entry in the dictionary,
// create a pointer to the next entry.
//
// Arguments: [pent] -- pointer to a dictionary entry.
//
// Returns: Pointer to the next entry. If the input
// points to the last entry in the dictionary,
// then return a pointer to just beyond the
// end of the dictionary.
//+--------------------------------------------------------------------------
inline ENTRY UNALIGNED *
CPropertySetStream::_NextDictionaryEntry(
IN ENTRY UNALIGNED const * pent
) const
{
return (ENTRY UNALIGNED *)
Add2Ptr( pent, _DictionaryEntryLength( pent ));
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_SignalCorruption
//
// Synopsis: possibly PROPASSERT and return data corrupt error
//
// Arguments: [szReason] -- string explanation (DBGPROP only)
// [pstatus] -- NTSTATUS code.
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_StatusCorruption(
#if DBGPROP
char *szReason,
#endif
OUT NTSTATUS *pstatus
) const
{
#if DBGPROP
DebugTrace(0, DEBTRACE_ERROR, (
"_StatusCorruption(%s, psstm=%lx, mapstm=%lx, %s, flags=%x)\n",
szReason,
this,
KERNELSELECT(&_mstm, _pmstm),
KERNELSELECT("Kernel", _MSTM(IsNtMappedStream)()? "Nt" : "DocFile"),
_Flags));
#ifdef KERNEL
if ((_Flags & CREATEPROP_MODEMASK) != CREATEPROP_READ)
#endif
{
PROPASSERTMSG(szReason, FALSE);
DebugTrace(0, DEBTRACE_WARN, (
"_StatusCorruption(%s, psstm=%lx, mapstm=%lx, %s, flags=%x)\n",
szReason,
this,
KERNELSELECT(&_mstm, _pmstm),
KERNELSELECT("Kernel", _MSTM(IsNtMappedStream)()? "Nt" : "DocFile"),
_Flags));
if (DebugLevel & DEBTRACE_WARN)
{
PROPASSERTMSG(szReason, FALSE);
}
}
#endif
*pstatus = STATUS_INTERNAL_DB_CORRUPTION;
return;
}
//+--------------------------------------------------------------------------
// Function: _PropMoveMemory
//
// Synopsis: call DebugTrace and RtlMoveMemory
//
// Arguments: [pszReason] -- string explanation (Debug only)
// [pvSection] -- base of section (Debug only)
// [pvDst] -- destination
// [pvSrc] -- source
// [cbMove] -- byte count to move
//
// Returns: None
//+--------------------------------------------------------------------------
#if DBGPROP
#define PropMoveMemory(pszReason, pvSection, pvDst, pvSrc, cbMove) \
_PropMoveMemory(pszReason, pvSection, pvDst, pvSrc, cbMove)
#else
#define PropMoveMemory(pszReason, pvSection, pvDst, pvSrc, cbMove) \
_PropMoveMemory(pvDst, pvSrc, cbMove)
#endif
inline VOID
_PropMoveMemory(
#if DBGPROP
char *pszReason,
VOID *pvSection,
#endif
VOID *pvDst,
VOID const *pvSrc,
ULONG cbMove)
{
DebugTrace(0, Dbg, (
"%s: Moving Dst=%lx(%l" szX ") Src=%lx(%l" szX ") Size=%l" szX "\n",
pszReason,
pvDst,
(BYTE *) pvDst - (BYTE *) pvSection,
pvSrc,
(BYTE *) pvSrc - (BYTE *) pvSection,
cbMove));
RtlMoveMemory(pvDst, pvSrc, cbMove);
}
inline BOOLEAN
IsReadOnlyPropertySet(BYTE flags, BYTE state)
{
return(
(flags & CREATEPROP_MODEMASK) == CREATEPROP_READ ||
(state & CPSS_USERDEFINEDDELETED) ||
(state & (CPSS_MULTIPLESECTIONS | CPSS_DOCUMENTSUMMARYINFO)) ==
CPSS_MULTIPLESECTIONS);
}
inline BOOLEAN
IsReadOnlyPropid(PROPID pid)
{
return(
pid == PID_DICTIONARY ||
pid == PID_CODEPAGE ||
pid == PID_LOCALE ||
pid == PID_MODIFY_TIME ||
pid == PID_SECURITY);
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::CStreamChunkList
//
// Synopsis: constructor
//
// Arguments: [cChunks] -- count of chunks that will be needed
//
// Returns: None
//+--------------------------------------------------------------------------
CStreamChunkList::CStreamChunkList(
ULONG cChunks,
CStreamChunk *ascnk) :
_cMaxChunks(cChunks),
_cChunks(0),
_ascnk(ascnk),
_fDelete(FALSE)
{
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::Delete
//
// Synopsis: destructor
//
// Arguments: None
//
// Returns: None
//+--------------------------------------------------------------------------
inline
VOID
CStreamChunkList::Delete(VOID)
{
if (_fDelete)
{
delete [] _ascnk;
}
#if DBGPROP
_cMaxChunks = _cChunks = 0;
_ascnk = NULL;
_fDelete = FALSE;
#endif
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::GetChunk
//
// Synopsis: retrieves a chunk given the index
//
// Arguments: [i] -- index of the chunk to retrieve
//
// Returns: specified chunk pointer
//+--------------------------------------------------------------------------
inline
CStreamChunk const *
CStreamChunkList::GetChunk(ULONG i) const
{
PROPASSERT(i < _cChunks);
PROPASSERT(i < _cMaxChunks);
PROPASSERT(_ascnk != NULL);
return(&_ascnk[i]);
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::Count
//
// Synopsis: returns the count of chunks
//
// Arguments: None
//
// Returns: the number of chunks.
//+--------------------------------------------------------------------------
inline ULONG
CStreamChunkList::Count(VOID) const
{
return(_cChunks);
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::GetFreeChunk
//
// Synopsis: gets a unused chunk descriptor
//
// Arguments: [pstatus] -- NTSTATUS code
//
// Returns: a ptr to a stream chunk descriptor.
// This will be NULL if there was an
// error.
//+--------------------------------------------------------------------------
CStreamChunk *
CStreamChunkList::GetFreeChunk(OUT NTSTATUS *pstatus)
{
CStreamChunk *pscnk = NULL;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_cChunks < _cMaxChunks);
if (_ascnk == NULL)
{
PROPASSERT(_cChunks == 0);
_ascnk = newk(mtPropSetStream, NULL) CStreamChunk[_cMaxChunks];
if (_ascnk == NULL)
{
StatusNoMemory(pstatus, "GetFreeChunk");
goto Exit;
}
_fDelete = TRUE;
}
pscnk = &_ascnk[_cChunks++];
// ----
// Exit
// ----
Exit:
return( pscnk );
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::AssertCbChangeTotal
//
// Synopsis: make sure the computed cbChangeTotal is correct for the chunk
//
// Arguments: None
//
// Returns: Nothing
//+--------------------------------------------------------------------------
#if DBGPROP
VOID
CStreamChunkList::AssertCbChangeTotal(
CStreamChunk const *pscnk,
ULONG cbChangeTotal) const
{
ULONG cb = 0;
ULONG i;
for (i = 0; i < Count(); i++)
{
CStreamChunk const *pscnkT = GetChunk(i);
cb += pscnkT->cbChange;
if (pscnk == pscnkT)
{
PROPASSERT(cb == cbChangeTotal);
return;
}
}
PROPASSERT(i < Count());
}
#endif
//+--------------------------------------------------------------------------
// Member: fnChunkCompare
//
// Synopsis: qsort helper to compare chunks in the chunk list.
//
// Arguments: [pscnk1] -- pointer to chunk1
// [pscnk2] -- pointer to chunk2
//
// Returns: difference
//+--------------------------------------------------------------------------
INT _CRTAPI1
fnChunkCompare(VOID const *pscnk1, VOID const *pscnk2)
{
return(((CStreamChunk const *) pscnk1)->oOld -
((CStreamChunk const *) pscnk2)->oOld);
}
//+--------------------------------------------------------------------------
// Member: CStreamChunkList::SortByStartAddress
//
// Synopsis: sort all the chunks that are being modified in a stream in the
// ascending order.
//
// Arguments: None
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CStreamChunkList::SortByStartAddress(VOID)
{
DebugTrace(0, Dbg, ("Sorting %l" szX " Chunks @%lx\n", _cChunks, _ascnk));
qsort(_ascnk, _cChunks, sizeof(_ascnk[0]), fnChunkCompare);
#if DBGPROP
LONG cbChangeTotal;
ULONG i;
cbChangeTotal = 0;
for (i = 0; i < _cChunks; i++)
{
cbChangeTotal += _ascnk[i].cbChange;
DebugTrace(0, Dbg, (
"Chunk[%l" szX "] oOld=%l" szX " cbChange=%s%l" szX
" cbChangeTotal=%s%l" szX "\n",
i,
_ascnk[i].oOld,
_ascnk[i].cbChange < 0? "-" : "",
_ascnk[i].cbChange < 0? -_ascnk[i].cbChange : _ascnk[i].cbChange,
cbChangeTotal < 0? "-" : "",
cbChangeTotal < 0? -cbChangeTotal : cbChangeTotal));
}
#endif
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_GetFormatidOffset
//
// Synopsis: Get a pointer to the (first) section header
//
// Arguments: None
//
// Returns: pointer to section header
//+--------------------------------------------------------------------------
inline FORMATIDOFFSET *
CPropertySetStream::_GetFormatidOffset(ULONG iSection) const
{
return(&((FORMATIDOFFSET *) Add2Ptr(_pph, sizeof(*_pph)))[iSection]);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_GetSectionHeader
//
// Synopsis: Get a pointer to the (first) section header
//
// Arguments: None
//
// Returns: pointer to section header
//+--------------------------------------------------------------------------
inline PROPERTYSECTIONHEADER *
CPropertySetStream::_GetSectionHeader(VOID) const
{
return((PROPERTYSECTIONHEADER *) Add2Ptr(_pph, _oSection));
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_GetSectionHeader
//
// Synopsis: Get a pointer to the specified section header
//
// Arguments: [iSection] -- section number
// [pstatus] -- Pointer to NTSTATUS code.
//
// Returns: pointer to specified section header
//+--------------------------------------------------------------------------
PROPERTYSECTIONHEADER *
CPropertySetStream::_GetSectionHeader(ULONG iSection, OUT NTSTATUS *pstatus)
{
*pstatus = STATUS_SUCCESS;
PROPERTYSECTIONHEADER *psh = NULL;
ULONG oSection = 0; // Assume no header
ULONG cbstm = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Don't assume *any* class variables (except _pph) are loaded yet!
PROPASSERT(iSection < _pph->reserved );
// Get the section offset, after verifying that we can read all
// of the FmtID/Offset table.
if (cbstm >= CB_PROPERTYSETHEADER + (iSection + 1) * CB_FORMATIDOFFSET)
oSection = _GetFormatidOffset(iSection)->dwOffset;
else
StatusCorruption (pstatus, "GetSectionHeader(i): stream size too short to read section offset");
// Create a pointer to the section header, after verifying that we can
// read all of the section header. We don't verify that we can actually
// read the whole section (using cbSection), the caller must be responsible
// for this.
// We have to check oSection first, then oSection+cb_psh, because oSection
// could be a negative number (such as 0xffffffff), so adding it to cb_psh
// could make it look valid.
if (cbstm >= oSection
&&
cbstm >= oSection + CB_PROPERTYSECTIONHEADER)
{
psh = (PROPERTYSECTIONHEADER *) Add2Ptr(_pph, oSection);
}
else
StatusCorruption (pstatus, "GetSectionHeader(i): stream size too short to read section header");
// Finally, ensure that the section is 32 bit aligned. We handle several
// compatibility problems in the _Fix* routines, but not a misaligned
// section header.
if( !IsDwordAligned( psh ))
StatusCorruption( pstatus, "GetSectionHeader(i): section header is misaligned" );
// ----
// Exit
// ----
Exit:
return(psh);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_SearchForCodePage, private
//
// Synopsis: Searches a section of a property set for the code page.
//
// This routine searches for the code page by iterating
// through the PID/Offset array in search of
// PID_CODEPAGE. The difference between calling
// this routine, and calling GetValue(PID_CODEPAGE),
// is that this routine does not assume that the
// property set is formatted correctly; it only assumes
// that the PID/Offset array is correct.
//
// Note that this routine is like a specialized _LoadProperty(),
// the important difference is that this routine must use
// unaligned pointers, since it cannot assume that the
// property set is aligned properly.
//
// Pre-Conditions:
// The PID/Offset array is correct.
// &&
// _oSection & _cSection are set correctly.
//
// Post-Conditions:
// If PID_CODEPAGE exists, it is put into _CodePage.
// If it doesn't exist, _CodePage is left unchanged.
//
// Arguments: [pstatus] -- Pointer to NTSTATUS code.
//
// Notes: We do *not* assume that the property set's
// cbSection field is valid (this was added to handle a
// special-case compatibility problem).
//
// Returns: None.
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_SearchForCodePage( OUT NTSTATUS *pstatus )
{
PROPERTYSECTIONHEADER UNALIGNED *psh;
PROPERTYIDOFFSET UNALIGNED *ppo;
PROPERTYIDOFFSET UNALIGNED *ppoMax;
ULONG cbstm;
*pstatus = STATUS_SUCCESS;
// Verify the pre-conditions.
PROPASSERT( _oSection != 0 );
PROPASSERT( _cSection != 0 );
// It's invalid to call any function on a deleted
// DocSumInfo user-defined (section section) section.
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "GetValue: deleted");
goto Exit;
}
// Get the section's header.
psh = _GetSectionHeader();
// Ensure that we can at least read the section header and
// PID/Offset table.
cbstm = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (cbstm < _oSection + CB_PROPERTYSECTIONHEADER
||
cbstm < _oSection + CB_PROPERTYSECTIONHEADER
+ psh->cProperties * CB_PROPERTYIDOFFSET
)
{
StatusCorruption(pstatus, "_SearchForCodePage: stream too short to read section header");
goto Exit;
}
// Calculate the first & last PID/Offset pointers.
// We can't use _LoadPropertyOffsetPointers, because it assumes
// alignment.
ppo = psh->rgprop;
ppoMax = psh->rgprop + psh->cProperties;
// Search the PID/Offset array for PID_CODEPAGE
for ( ; ppo < ppoMax; ppo++)
{
if (ppo->propid == PID_CODEPAGE)
{
SERIALIZEDPROPERTYVALUE UNALIGNED *pprop;
// Get the real address of serialized property.
pprop = (SERIALIZEDPROPERTYVALUE *)
_MapOffsetToAddress( ppo->dwOffset );
// Check for corruption.
if ( ( (_oSection + ppo->dwOffset + CB_SERIALIZEDPROPERTYVALUE + sizeof(DWORD))
>
cbstm
)
||
PropByteSwap(pprop->dwType) != VT_I2
)
{
StatusCorruption(pstatus, "_SearchForCodePage");
goto Exit;
}
// Set the member code page from the serialized property.
// (The codepage is an I2).
_CodePage = PropByteSwap( *(UNALIGNED USHORT *) &pprop->rgb );
break;
} // if (ppo->propid == PID_CODEPAGE)
} // for ( ; ppo < ppoMax; ppo++)
// ----
// Exit
// ----
Exit:
return;
} // CPropertySetStream::_SearchForCodePage()
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_MapOffsetToAddress, private
//
// Synopsis: maps an offset to an address
//
// Arguments: [Offset] -- the offset in the section
//
// Returns: ptr to the offset mapped
//+--------------------------------------------------------------------------
inline VOID *
CPropertySetStream::_MapOffsetToAddress(ULONG Offset) const
{
PROPASSERT(_cSection != 0);
return(Add2Ptr(_GetSectionHeader(), Offset));
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_MapAddressToOffset, private
//
// Synopsis: maps an address to an offset
//
// Arguments: [pvAddr] -- the address in the section
//
// Returns: section-relative offset for passed pointer
//+--------------------------------------------------------------------------
inline ULONG
CPropertySetStream::_MapAddressToOffset(VOID const *pvAddr) const
{
PROPASSERT(_cSection != 0);
// Get a ptr to the section header.
VOID const *pvSectionHeader = _GetSectionHeader();
PROPASSERT((BYTE const *) pvAddr >= (BYTE const *) pvSectionHeader);
return((BYTE const *) pvAddr - (BYTE const *) pvSectionHeader);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_MapAbsOffsetToAddress, private
//
// Synopsis: maps an address to an offset
//
// Arguments: [oAbsolute] -- the absolute offset
//
// Returns: a ptr to the offset mapped
//+--------------------------------------------------------------------------
inline VOID *
CPropertySetStream::_MapAbsOffsetToAddress(ULONG oAbsolute) const
{
return(Add2Ptr(_pph, oAbsolute));
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_MapAddressToAbsOffset, private
//
// Synopsis: maps an address to an offset
//
// Arguments: [pvAddr] -- the address
//
// Returns: the absolute offset
//+--------------------------------------------------------------------------
inline ULONG
CPropertySetStream::_MapAddressToAbsOffset(VOID const *pvAddr) const
{
PROPASSERT((BYTE const *) pvAddr >= (BYTE *) _pph);
return((BYTE const *) pvAddr - (BYTE *) _pph);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::CPropertySetStream
//
// Synopsis: constructor for property set class
//
// Arguments:UK [Flags] -- NONSIMPLE|*1* of READ/WRITE/CREATE/CREATEIF/DELETE
// K [pscb] -- SCB for property stream
// K [pirpc] -- pointer to Irp Context
// K [State] -- CPSS_PROPHEADER
// U [pmstm] -- mapped stream implementation
// U [pma] -- caller's memory allocator
//
// Returns: None
//---------------------------------------------------------------------------
CPropertySetStream::CPropertySetStream(
IN USHORT Flags, // NONSIMPLE|*1* of READ/WRITE/CREATE/CREATEIF/DELETE
#ifdef KERNEL
IN SCB *pscb,
IN IRPCONTEXT *pirpc,
IN BYTE State
#else
IN CMappedStream *pmstm, // mapped stream impelementation
IN PMemoryAllocator *pma // caller's memory allocator
#endif
) :
_Flags((BYTE) Flags),
#ifdef KERNEL
_State(State),
_mstm(
pscb,
pirpc,
(Flags & CREATEPROP_MODEMASK) == CREATEPROP_READ?
KMS_PROPSET : (KMS_PROPSET | KMS_WRITE)),
#else
_State(0),
_pmstm(pmstm),
_pma(pma),
#endif
_pph(NULL)
{
_CodePage = CP_CREATEDEFAULT(_State); // Default if not present
PROPASSERT(_Flags == Flags); // Should fit in a byte
#ifdef KERNEL
PROPASSERT((_State & ~CPSS_PROPHEADER) == 0);
#endif
_oSection = 0;
_cSection = 0;
_cbTail = 0;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::Close
//
// Synopsis: shutdown property set prior to calling destructor
//
// Arguments: [pstatus] -- Pointer to NTSTATUS code.
//
// Returns: None
//---------------------------------------------------------------------------
VOID
CPropertySetStream::Close(OUT NTSTATUS *pstatus)
{
*pstatus = STATUS_SUCCESS;
// Validate the byte-order (_pph could be NULL in certain
// close scenarios, e.g. an RtlCreatePropertySet fails).
PROPASSERT(NULL == _pph || PROPSET_BYTEORDER == _pph->wByteOrder);
PROPASSERT(
(_Flags & CREATEPROP_MODEMASK) != CREATEPROP_READ ||
!IsModified());
_MSTM(Unmap)(IsModified(), (VOID **) &_pph);
_MSTM(Close)(pstatus);
// if( !NT_SUCCESS(*pstatus) ) goto Exit;
//Exit:
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::Open
//
// Synopsis: Open property set image
//
// Arguments: None
//
// Returns: None
//---------------------------------------------------------------------------
VOID
CPropertySetStream::Open(
IN GUID const *pfmtid, // property set fmtid
OPTIONAL IN GUID const *pclsid, // CLASSID of propset code (create only)
IN ULONG LocaleId, // Locale Id (create only)
OPTIONAL OUT ULONG *pOSVersion, // OS Version from header
IN USHORT CodePage, // CodePage of property set (create only)
OUT NTSTATUS *pstatus
)
{
*pstatus = STATUS_SUCCESS;
LOADSTATE LoadState;
PROPASSERT(!_IsMapped());
if( pOSVersion != NULL )
*pOSVersion = PROPSETHDR_OSVERSION_UNKNOWN;
// Open the underlying stream which holds the property set.
// We give it a callback pointer so that it can call
// RtlOnMappedStreamEvent.
_MSTM(Open)(this, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Load the header, including fixing the in-memory image of
// poorly-formatted property sets.
LoadState = _LoadHeader(pfmtid, _Flags & CREATEPROP_MODEMASK, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (LoadState != LOADSTATE_DONE)
{
switch (_Flags & CREATEPROP_MODEMASK)
{
case CREATEPROP_READ:
case CREATEPROP_WRITE:
if (LoadState == LOADSTATE_FAIL)
{
StatusCorruption(pstatus, "Open: _LoadHeader");
goto Exit;
}
PROPASSERT(
LoadState == LOADSTATE_BADFMTID ||
LoadState == LOADSTATE_USERDEFINEDNOTFOUND);
DebugTrace(0, DEBTRACE_ERROR, (
"_LoadHeader: LoadState=%x\n", LoadState));
*pstatus = STATUS_PROPSET_NOT_FOUND;
goto Exit;
}
_Create(
pfmtid,
pclsid,
LocaleId,
CodePage,
LoadState,
pstatus
);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
} // if (LoadState != LOADSTATE_DONE)
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
if (_HasPropHeader() &&
(_pph->dwOSVer == PROPSETVER_WIN310 ||
_pph->dwOSVer == PROPSETVER_WIN333))
{
DebugTrace(0, DEBTRACE_PROPPATCH, (
"Open(%s) downlevel: %x\n",
(_Flags & CREATEPROP_MODEMASK) == CREATEPROP_READ? "Read" : "Write",
_Flags));
_State |= CPSS_DOWNLEVEL;
}
if ((_Flags & CREATEPROP_MODEMASK) != CREATEPROP_READ)
{
if (_State & CPSS_PACKEDPROPERTIES)
{
StatusAccessDenied(pstatus, "Open: writing Unaligned propset");
goto Exit;
}
if ((_State & (CPSS_MULTIPLESECTIONS | CPSS_DOCUMENTSUMMARYINFO)) ==
CPSS_MULTIPLESECTIONS)
{
StatusAccessDenied(pstatus, "Open: writing unknown multiple section propset");
goto Exit;
}
}
// Return the OS Version to the caller.
if( pOSVersion != NULL )
*pOSVersion = _pph->dwOSVer;
// ----
// Exit
// ----
Exit:
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::ReOpen
//
// Synopsis: ReOpen property set image
//
// Arguments: [pstatus] -- Pointer to NSTATUS code.
//
// Returns: Number of properties.
//---------------------------------------------------------------------------
ULONG
CPropertySetStream::ReOpen(OUT NTSTATUS *pstatus)
{
LOADSTATE LoadState;
PROPERTYSECTIONHEADER const *psh;
ULONG cProperties = 0;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
_MSTM(ReOpen)((VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (_State & CPSS_USERDEFINEDDELETED)
{
goto Exit;
}
LoadState = _LoadHeader(NULL,
CREATEPROP_READ, // all we need is !create
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (LoadState != LOADSTATE_DONE)
{
DebugTrace(0, DEBTRACE_ERROR, (
"ReOpen: LoadState=%lx\n",
LoadState));
StatusCorruption(pstatus, "ReOpen: _LoadHeader");
goto Exit;
}
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
psh = _GetSectionHeader();
PROPASSERT(psh != NULL);
cProperties = psh->cProperties;
// ----
// Exit
// ----
Exit:
return( cProperties );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_InitSection
//
// Synopsis: Initialize a section header and the default properties.
//
// Arguments: [pfo] -- pointer to section info
// [LocaleId] -- Locale Id
//
// Returns: None
//---------------------------------------------------------------------------
// Serialized Code-Page size
#define CB_CODEPAGE (sizeof(ULONG) + DwordAlign(sizeof(USHORT)))
// Serialized Locale ID (LCID) size.
#define CB_LOCALE (sizeof(ULONG) + sizeof(ULONG))
// Minimum section size (minimum has Code Page & LCID)
#define CB_MINSECTIONSIZE (CB_PROPERTYSECTIONHEADER \
+ 2 * CB_PROPERTYIDOFFSET \
+ CB_CODEPAGE \
+ CB_LOCALE)
// Minimum serialized dictionary size (a dict with no entries).
#define CB_EMPTYDICTSIZE (sizeof(DWORD)) // Entry count
// Minimum User-Defined section size (in DocumentSummaryInformation propset).
// (Must include an empty dictionary & a PID/Offset for it.)
#define CB_MINUSERDEFSECTIONSIZE \
(CB_MINSECTIONSIZE \
+ \
CB_PROPERTYIDOFFSET \
+ \
CB_EMPTYDICTSIZE)
VOID
CPropertySetStream::_InitSection(
IN FORMATIDOFFSET *pfo,
IN ULONG LocaleId,
IN BOOL fCreateDictionary // Create an empty dictionary?
)
{
PROPERTYSECTIONHEADER *psh;
ULONG ulPropIndex; // Index into the PID/Offset array.
DWORD dwPropValOffset; // The offset to where the next prop val will be written.
// Pointer to a serialized property value.
SERIALIZEDPROPERTYVALUE *pprop;
psh = (PROPERTYSECTIONHEADER *) _MapAbsOffsetToAddress(pfo->dwOffset);
// Set the property count and section size in the section header.
// This must account for the Code Page and Locale ID properties, and
// might need to account for an empty dictionary property.
// dwPropValOffset identifies the location of the next property value
// to be written.
if( fCreateDictionary )
{
// Three properties: Code Page, LCID, and Dictionary.
psh->cProperties = 3;
dwPropValOffset = CB_PROPERTYSECTIONHEADER + 3 * CB_PROPERTYIDOFFSET;
psh->cbSection = CB_MINUSERDEFSECTIONSIZE;
}
else
{
// Two properties: Code Page and LCID (no dictionary).
psh->cProperties = 2;
dwPropValOffset = CB_PROPERTYSECTIONHEADER + 2 * CB_PROPERTYIDOFFSET;
psh->cbSection = CB_MINSECTIONSIZE;
}
ulPropIndex = 0;
// If requested by the caller, create a dictionary property, but
// leave the dictionary empty. We always create this first. It shouldn't
// matter where it's located, but Office95 requires it
// and it doesn't do any harm to put it there.
if( fCreateDictionary )
{
// Fill in the PID/Offset table.
psh->rgprop[ ulPropIndex ].propid = PID_DICTIONARY;
psh->rgprop[ ulPropIndex ].dwOffset = dwPropValOffset;
// Fill in the property value.
pprop = (SERIALIZEDPROPERTYVALUE *) Add2Ptr( psh, dwPropValOffset );
pprop->dwType = 0L; // For the dictonary, this is actually the entry count.
// Advance the table & value indices.
ulPropIndex++;
dwPropValOffset += CB_EMPTYDICTSIZE;
} // if( fCreateDictionary )
// Write the code page. We write a zero first to initialize
// the padding bytes.
psh->rgprop[ ulPropIndex ].propid = PID_CODEPAGE;
psh->rgprop[ ulPropIndex ].dwOffset = dwPropValOffset;
pprop = (SERIALIZEDPROPERTYVALUE *) Add2Ptr( psh, dwPropValOffset );
pprop->dwType = PropByteSwap((DWORD) VT_I2);
*(DWORD *) pprop->rgb = 0; // Zero out extra two bytes.
*(WORD *) pprop->rgb = PropByteSwap( _CodePage );
ulPropIndex++;
dwPropValOffset += CB_CODEPAGE;
// Write the Locale ID.
psh->rgprop[ ulPropIndex ].propid = PID_LOCALE;
psh->rgprop[ ulPropIndex ].dwOffset = dwPropValOffset;
pprop = (SERIALIZEDPROPERTYVALUE *) Add2Ptr(psh, dwPropValOffset );
pprop->dwType = PropByteSwap( (DWORD) VT_UI4 );
*(DWORD *) pprop->rgb = PropByteSwap( (DWORD) LocaleId );
}
//+---------------------------------------------------------------------------
// Member: _MultiByteToWideChar, private
//
// Synopsis: Convert a MultiByte string to a Unicode string,
// using the _pma memory allocator if necessary.
//
// Arguments: [pch] -- pointer to MultiByte string
// [cb] -- byte length of MultiByte string
// (-1 if null terminated)
// [CodePage] -- Codepage of input string.
// [ppwc] -- pointer to pointer to converted string
// (if *ppwc is NULL, it will be alloced,
// if non-NULL, *ppwc must be *pcb bytes long).
// [pcb] -- IN: byte length of *ppwc
// OUT: byte length of Unicode string.
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: Nothing
//---------------------------------------------------------------------------
VOID
CPropertySetStream::_MultiByteToWideChar(
IN CHAR const *pch,
IN ULONG cb,
IN USHORT CodePage,
OUT WCHAR **ppwc,
OUT ULONG *pcb,
OUT NTSTATUS *pstatus)
{
// ------
// Locals
// ------
// Did we allocate *ppwc?
BOOL fAlloc = FALSE;
// --------------
// Initialization
// --------------
*pstatus = STATUS_SUCCESS;
PROPASSERT(pch != NULL);
PROPASSERT(ppwc != NULL);
PROPASSERT(pcb != NULL);
PROPASSERT(IsAnsiString(pch, ((ULONG)-1 == cb ) ? MAXULONG : cb));
PROPASSERT(NULL != *ppwc || 0 == *pcb);
PROPASSERT(UnicodeCallouts.pfnMultiByteToWideChar != NULL);
// ------------------
// Convert the String
// ------------------
// We will pass through this loop once (if the caller provided a buffer
// or twice (otherwise).
while (TRUE)
{
// Attempt to convert the string.
*pcb = (*UnicodeCallouts.pfnMultiByteToWideChar)(
CodePage, // Source codepage
0, // Flags
pch, // Source string
cb, // Source string length
*ppwc, // Target string
*pcb); // Size of target string buffer
// The converted length should never be zero.
if (0 == *pcb)
{
// If we alloced a buffer, free it now.
if( fAlloc )
{
_pma->Free( *ppwc );
*ppwc = NULL;
}
// If there was an error, assume that it was a code-page
// incompatibility problem.
StatusError(pstatus, "_MultiByteToWideChar error",
STATUS_UNMAPPABLE_CHARACTER);
goto Exit;
}
// There was no error. If we provided a non-NULL buffer,
// then the conversion was performed and we're done.
*pcb *= sizeof(WCHAR); // cch => cb
if (*ppwc != NULL)
{
DebugTrace(0, DEBTRACE_PROPERTY, (
"_MultiByteToWideChar: pch='%s'[%x] pwc='%ws'[%x->%x]\n",
pch,
cb,
*ppwc,
*pcb,
*pcb * sizeof(WCHAR)));
break;
}
// We haven't actually the string yet. Now that
// we know the length, we can allocate a buffer and try the
// conversion for real.
*ppwc = (WCHAR *) _pma->Allocate( *pcb );
if (NULL == *ppwc)
{
StatusNoMemory(pstatus, "_MultiByteToWideChar: no memory");
goto Exit;
}
fAlloc = TRUE;
} // while(TRUE)
// ----
// Exit
// ----
Exit:
return;
} // CPropertySetStream::_MultiByteToWideChar
//+---------------------------------------------------------------------------
// Member: _WideCharToMultiByte, private
//
// Synopsis: Convert a Unicode string to a MultiByte string,
// using the _pma memory allocator if necessary.
//
// Arguments: [pwc] -- pointer to Unicode string
// [cch] -- character length of Unicode string
// (-1 if null terminated)
// [CodePage] -- codepage of target string
// [ppch] -- pointer to pointer to converted string
// (if *ppch is NULL, it will be alloced,
// if non-NULL, *ppch must be *pcb bytes long).
// [pcb] -- IN: byte length of *ppch
// OUT: byte length of MultiByte string
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: Nothing
//---------------------------------------------------------------------------
VOID
CPropertySetStream::_WideCharToMultiByte(
IN WCHAR const *pwc,
IN ULONG cch,
IN USHORT CodePage,
OUT CHAR **ppch,
OUT ULONG *pcb,
OUT NTSTATUS *pstatus)
{
// ------
// Locals
// ------
// Did we allocate *ppch?
BOOL fAlloc = FALSE;
// --------------
// Initialization
// --------------
*pstatus = STATUS_SUCCESS;
PROPASSERT(pwc != NULL);
PROPASSERT(ppch != NULL);
PROPASSERT(pcb != NULL);
PROPASSERT(IsUnicodeString(pwc, ((ULONG)-1 == cch ) ? MAXULONG : cch*sizeof(WCHAR)));
PROPASSERT(NULL != *ppch || 0 == *pcb);
PROPASSERT(UnicodeCallouts.pfnWideCharToMultiByte != NULL);
// ------------------
// Convert the String
// ------------------
// We will pass through this loop once (if the caller provided a buffer
// or twice (otherwise).
while (TRUE)
{
// Attempt the conversion.
*pcb = (*UnicodeCallouts.pfnWideCharToMultiByte)(
CodePage, // Codepage to convert to
0, // Flags
pwc, // Source string
cch, // Size of source string
*ppch, // Target string
*pcb, // Size of target string buffer
NULL, // lpDefaultChar
NULL); // lpUsedDefaultChar
// A converted length of zero indicates an error.
if (0 == *pcb)
{
// If we allocated a buffer in this routine, free it.
if( fAlloc )
{
_pma->Free( *ppch );
*ppch = NULL;
}
// If there was an error, assume that it was a code-page
// incompatibility problem.
StatusError(pstatus, "_WideCharToMultiByte: WideCharToMultiByte error",
STATUS_UNMAPPABLE_CHARACTER);
goto Exit;
}
// If we have a non-zero length, and we provided a buffer,
// then we're done (successfully).
if (*ppch != NULL)
{
DebugTrace(0, DEBTRACE_PROPERTY, (
"_WideCharToMultiByte: pwc='%ws'[%x] pch='%s'[%x->%x]\n",
pwc,
cch,
*ppch,
*pcb,
*pcb));
break;
}
// There were no errors, but we need to allocate a buffer
// to do the actual conversion.
*ppch = (CHAR*) _pma->Allocate( *pcb );
if (*ppch == NULL)
{
StatusNoMemory(pstatus, "_WideCharToMultiByte: no memory");
goto Exit;
}
fAlloc = TRUE;
} // while (TRUE)
// ----
// Exit
// ----
Exit:
return;
} // CPropertySetStream::_WideCharToMultiByte
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::ByteSwapHeaders
//
// Synopsis: Byte-swap the headers of a property set header
// (both the propset header and any section headers).
//
// Arguments: [PROPERTYSETHEADER*] pph
// Pointer to the beginning of the property set.
// [ULONG] cbstm
// Total size of the property stream.
// [NTSTATUS*] pstatus
// Pointer to NTSTATUS code.
//
// Pre-Conditions:
// There are no more than two sections.
//
// Note that this routine does not assume anything
// about the current state of the CPropertySetStream
// (it accesses no member variables).
//
// Post-Conditions:
// If the property set headers are valid, the
// propset and section headers are byte-swapped.
// Note that if the property set is invalid, this
// routine may only partially swap it. Therefore,
// the caller must ensure in this case that no
// attempt is made to use the property set.
//
// Returns: None. *pstatus will only be non-successful
// if the Stream was too small for the property set
// (i.e, the property set is corrupt). If the caller
// knows this not to be the case, then it can assume
// that this routine will return STATUS_SUCCESS.
//
//---------------------------------------------------------------------------
VOID
CPropertySetStream::ByteSwapHeaders( IN PROPERTYSETHEADER *pph,
IN DWORD cbstm,
OUT NTSTATUS *pstatus )
{
#if LITTLEENDIAN
*pstatus = STATUS_SUCCESS;
return;
#else
// ------
// Locals
// ------
ULONG cSections;
ULONG ulIndex, ulSectionIndex;
// pfoPropSet points into pph, pfoReal is a local copy
// in the system's endian-ness.
FORMATIDOFFSET *pfoPropSet, pfoReal[2];
// Pointers into pph.
PROPERTYSECTIONHEADER *psh = NULL;
PROPERTYIDOFFSET *po = NULL;
// Are we converting *to* the system's endian-ness?
BOOL fToSystemEndian;
// ----------
// Initialize
// ----------
*pstatus = STATUS_SUCCESS;
PROPASSERT( NULL != pph );
PROPASSERT(PROPSET_BYTEORDER == pph->wByteOrder
||
PROPSET_BYTEORDER == ByteSwap( pph->wByteOrder )
);
// ----------------------------
// Swap the Property Set header
// ----------------------------
// Validate the stream length.
if( sizeof(*pph) > cbstm )
{
StatusCorruption(pstatus, "CPropertySetStream::ByteSwapHeaders: PropertySet header size");
goto Exit;
}
// Swap the fields in place.
PropByteSwap( &pph->wByteOrder );
PropByteSwap( &pph->wFormat );
PropByteSwap( &pph->dwOSVer );
PropByteSwap( &pph->clsid );
PropByteSwap( &pph->reserved );
// Are we converting to little-endian?
if( PROPSET_BYTEORDER == pph->wByteOrder)
fToSystemEndian = TRUE;
else
{
fToSystemEndian = FALSE;
PROPASSERT( PROPSET_BYTEORDER == PropByteSwap(pph->wByteOrder) );
}
// Get the correctly-endianed section count and validate.
cSections = fToSystemEndian ? pph->reserved
: PropByteSwap( pph->reserved );
if( cSections > 2 )
{
StatusCorruption(pstatus, "CPropertySetStream::ByteSwapHeaders: PropertySet header size");
goto Exit;
}
// -------------------------
// Swap the per-section data
// -------------------------
pfoPropSet = (FORMATIDOFFSET*) ((BYTE*) pph + sizeof(*pph));
for( ulSectionIndex = 0; ulSectionIndex < cSections; ulSectionIndex++ )
{
ULONG cbSection, cProperties;
// ------------------------------
// Swap the FormatID/Offset entry
// ------------------------------
// Is the Stream long enough for the array?
if( cbstm < (ULONG) &pfoPropSet[ulSectionIndex]
+ sizeof(*pfoPropSet)
- (ULONG) pph )
{
StatusCorruption(pstatus,
"CPropertySetStream::_ByteSwapHeaders: FormatID/Offset size");
goto Exit;
}
// Get a local copy of this FMTID/Offset array entry
// If it is propset-endian format, swap to make usable.
pfoReal[ ulSectionIndex ].fmtid = pfoPropSet[ulSectionIndex].fmtid;
pfoReal[ ulSectionIndex ].dwOffset = pfoPropSet[ulSectionIndex].dwOffset;
if( fToSystemEndian )
{
PropByteSwap( &pfoReal[ulSectionIndex].fmtid );
PropByteSwap( &pfoReal[ulSectionIndex].dwOffset );
}
// Swap this FMTID/Offset entry in place.
PropByteSwap( &pfoPropSet[ulSectionIndex].fmtid );
PropByteSwap( &pfoPropSet[ulSectionIndex].dwOffset );
// -----------------------
// Swap the section header
// -----------------------
// Locate the section header and the first entry in the
// PID/Offset table.
psh = (PROPERTYSECTIONHEADER*)
( (BYTE*) pph + pfoReal[ ulSectionIndex ].dwOffset );
po = (PROPERTYIDOFFSET*)
( (BYTE*) psh + sizeof(psh->cbSection) + sizeof(psh->cProperties) );
// Validate that we can see up to the PID/Offset table.
if( cbstm < (ULONG) ((BYTE*) po - (BYTE*) pph) )
{
StatusCorruption(pstatus,
"CPropertySetStream::ByteSwapHeaders: Section header size");
goto Exit;
}
// Get local copies of the section & property counts.
// Again we may need to swap them from propset-endian format
// in order to make them usable.
cbSection = psh->cbSection;
cProperties = psh->cProperties;
if( fToSystemEndian)
{
PropByteSwap( &cbSection );
PropByteSwap( &cProperties );
}
// Swap the two fields at the top of the section header.
PropByteSwap( &psh->cbSection );
PropByteSwap( &psh->cProperties );
// -------------------------
// Swap the PID/Offset table
// -------------------------
// Validate that we can see the whole table.
if( cbstm < (BYTE*) po - (BYTE*) pph + cProperties * sizeof(*po) )
{
StatusCorruption(pstatus,
"CPropertySetStream::ByteSwapHeaders: Section header size");
goto Exit;
}
// Swap each of the array entries.
for( ulIndex = 0; ulIndex < cProperties; ulIndex++ )
{
PropByteSwap( &po[ulIndex].propid );
PropByteSwap( &po[ulIndex].dwOffset );
}
} // for( ulSectionIndex = 0; ulSectionIndex < cSections, ulIndex++ )
// ----
// Exit
// ----
Exit:
return;
#endif // #if LITTLEENDIAN ... #else
} // CPropertySetStream::ByteSwapHeaders
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_CreateUserDefinedSection
//
// Synopsis: Create second property section
//
// Arguments: [LoadState] -- _LoadHeader returned state
// [LocaleId] -- Locale Id
// [pstatus] -- Pointer to NTSTATUS code.
//
// Returns: TRUE if LoadState handled successfully. If TRUE,
// *pstatus will be STATUS_SUCCESS.
//---------------------------------------------------------------------------
#ifndef KERNEL
BOOLEAN
CPropertySetStream::_CreateUserDefinedSection(
IN LOADSTATE LoadState,
IN ULONG LocaleId,
OUT NTSTATUS *pstatus)
{
BOOL fSuccess = FALSE;
FORMATIDOFFSET *pfo;
ULONG cbstmNew;
PROPERTYSECTIONHEADER *psh;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_State & CPSS_USERDEFINEDPROPERTIES);
switch (_Flags & CREATEPROP_MODEMASK)
{
case CREATEPROP_CREATEIF:
case CREATEPROP_CREATE:
if (LoadState == LOADSTATE_USERDEFINEDNOTFOUND)
{
ULONG cbmove;
PROPASSERT(_cSection == 1);
pfo = _GetFormatidOffset(0);
PROPASSERT(pfo->fmtid == guidDocumentSummary);
PROPASSERT(IsDwordAligned(pfo->dwOffset));
// Get a pointer to the first section header, using the
// FmtID/Offset array.
psh = (PROPERTYSECTIONHEADER *) _MapAbsOffsetToAddress(pfo->dwOffset);
// Determine if we need to move the first section back in order
// to make room for this new entry in the FmtID/Offset array.
cbmove = 0;
if (pfo->dwOffset < CB_PROPERTYSETHEADER + 2 * CB_FORMATIDOFFSET)
{
cbmove = CB_PROPERTYSETHEADER + 2*CB_FORMATIDOFFSET - pfo->dwOffset;
}
// How big should the Stream be?
cbstmNew = pfo->dwOffset // The offset of the first section
+
cbmove // Room for new FormatID/Offset array entry
+ // Size of first section
DwordAlign(psh->cbSection)
+ // Size of User-Defined section.
CB_MINUSERDEFSECTIONSIZE;
// Set the stream size.
_MSTM(SetSize)(cbstmNew, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// reload all pointers into mapped image:
pfo = _GetFormatidOffset(0);
psh = (PROPERTYSECTIONHEADER *) _MapAbsOffsetToAddress(pfo->dwOffset);
if (cbmove != 0)
{
// Move section back to make room for new FORMATIDOFFSET entry
PropMoveMemory(
"_AddSection",
psh,
Add2Ptr(psh, cbmove),
psh,
psh->cbSection);
pfo->dwOffset += cbmove;
PROPASSERT(IsDwordAligned(pfo->dwOffset));
}
psh->cbSection = DwordAlign(psh->cbSection);
PROPASSERT(_oSection == 0);
PROPASSERT(_cSection == 1);
PROPASSERT(_pph->reserved == 1);
_cSection++;
_pph->reserved++;
_oSection = pfo->dwOffset + psh->cbSection;
pfo = _GetFormatidOffset(1);
pfo->fmtid = guidDocumentSummarySection2;
pfo->dwOffset = _oSection;
_InitSection(pfo,
LocaleId,
TRUE ); // Create an empty dictionary.
fSuccess = TRUE;
}
break;
case CREATEPROP_DELETE:
PROPASSERT(
LoadState == LOADSTATE_USERDEFINEDDELETE ||
LoadState == LOADSTATE_USERDEFINEDNOTFOUND);
if (LoadState == LOADSTATE_USERDEFINEDDELETE)
{
PROPASSERT(_cSection == 2);
PROPASSERT(_pph->reserved == 2);
pfo = _GetFormatidOffset(1);
RtlZeroMemory(pfo, sizeof(*pfo));
_cSection--;
_pph->reserved--;
pfo = _GetFormatidOffset(0);
PROPASSERT(pfo->fmtid == guidDocumentSummary);
PROPASSERT(IsDwordAligned(pfo->dwOffset));
psh = (PROPERTYSECTIONHEADER *)
_MapAbsOffsetToAddress(pfo->dwOffset);
psh->cbSection = DwordAlign(psh->cbSection);
cbstmNew = pfo->dwOffset + psh->cbSection;
_MSTM(SetSize)(cbstmNew, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
_State |= CPSS_USERDEFINEDDELETED;
fSuccess = TRUE;
break;
default:
PROPASSERT(!"_Flags: bad open mode");
}
// ----
// Exit
// ----
Exit:
return( fSuccess );
}
#endif
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_Create
//
// Synopsis: Create property set image
//
// Arguments: [pfmtid] -- format id
// [pclsid] -- class id
// [LocaleId] -- Locale Id
// [CodePage] -- CodePage
// [LoadState] -- _LoadHeader returned state
//
// Returns: None
//---------------------------------------------------------------------------
VOID
CPropertySetStream::_Create(
IN GUID const *pfmtid,
OPTIONAL IN GUID const *pclsid,
IN ULONG LocaleId, // Locale Id (create only)
IN USHORT CodePage,
IN LOADSTATE LoadState,
OUT NTSTATUS *pstatus
)
{
ULONG cb;
FORMATIDOFFSET *pfo;
*pstatus = STATUS_SUCCESS;
_SetModified();
// Set the size of the stream to correspond to the header for the
// property set as well as the section.
_CodePage = CodePage;
ULONG cSectionT = 1;
// Are we creating the UserDefined property set
// (the second section of the DocumentSummaryInformation
// property set)?
if (_State & CPSS_USERDEFINEDPROPERTIES)
{
// Create the UD propset, and set the cSection.
// If this routine returns TRUE, it means that
// the first section already existed, and we're done.
// Otherwise, we must continue and create the first section.
if (_CreateUserDefinedSection(LoadState, LocaleId, pstatus))
{
// If we get here, we know that *pstatus is Success.
if (pclsid != NULL)
{
_pph->clsid = *pclsid;
}
goto Exit;
}
if( !NT_SUCCESS(*pstatus) ) goto Exit;
cSectionT = 2;
}
// Calculate the exact size of the Stream (we know exactly
// what it will be because we only initialize the set(s) with
// fixed size data).
PROPASSERT( 1 <= cSectionT && cSectionT <= 2 );
cb = CB_PROPERTYSETHEADER // The size of the propset header.
+ // The size of the FmtID/Offset array
cSectionT * CB_FORMATIDOFFSET
+
CB_MINSECTIONSIZE // The size of the first section
+ // Maybe the size of the User-Defined section
( cSectionT <= 1 ? 0 : CB_MINUSERDEFSECTIONSIZE );
DebugTrace(0, Dbg, ("SetSize(%x) init\n", cb));
// Set the size of the stream
_MSTM(SetSize)(cb, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// And get a mapping of the Stream.
_MSTM(Map)(TRUE, (VOID **) &_pph);
RtlZeroMemory(_pph, cb); // Zeros classid, fmtid(s), etc
// Initialize the OS Version in the header.
// Getting the current OS version depends on the OS.
#if defined(_MAC)
{
// Get the Mac System Version (e.g., 7.53). If we get an API error,
// we won't treat it as fatal, we'll just set the version to 0.
OSErr oserr;
SysEnvRec theWorld;
oserr = SysEnvirons( curSysEnvVers, &theWorld );
PROPASSERT( noErr == oserr );
if( noErr == oserr )
{
_pph->dwOSVer = MAKEPSVER( OSKIND_MACINTOSH,
HIBYTE(theWorld.systemVersion), // Major
LOBYTE(theWorld.systemVersion) );// Minor
}
else
{
_pph->dwOSVer = MAKEPSVER( OSKIND_MACINTOSH, 0, 0 );
}
}
#elif defined(IPROPERTY_DLL)
{
// Get the Windows version.
DWORD dwWinVersion = GetVersion();
// Use it to set the OSVersion
_pph->dwOSVer = MAKEPSVER( OSKIND_WIN32,
LOBYTE(LOWORD( dwWinVersion )), // Major
HIBYTE(LOWORD( dwWinVersion )) ); // Minor
}
#else // #if defined(_MAC) ... #elif defined(IPROPERTY_DLL)
// Since we're part of the system, we can hard-code the OSVersion,
// and save the expense of an API call.
_pph->dwOSVer = PROPSETVER_CURRENT;
#endif // #if defined(_MAC) ... #elif ... #else
// Initialize the rest of the header.
_pph->wByteOrder = 0xfffe;
//_pph->wFormat = 0; // RtlZeroMemory does this
PROPASSERT(_pph->wFormat == 0);
if (pclsid != NULL)
{
_pph->clsid = *pclsid;
}
_pph->reserved = cSectionT;
// Initialize the format id offset for the section(s).
pfo = _GetFormatidOffset(0);
pfo->dwOffset = CB_PROPERTYSETHEADER + cSectionT * CB_FORMATIDOFFSET;
// Are we creating the second section of the DocSumInfo property set?
if (cSectionT == 2)
{
// We need to initialize any empty first section.
pfo->fmtid = guidDocumentSummary;
_InitSection(pfo,
LocaleId,
FALSE); // Don't create an empty dictionary.
// Advance the FmtID/Offset table pointer to the second entry,
// and set it's offset to just beyond the first section.
pfo = _GetFormatidOffset(1);
pfo->dwOffset = CB_PROPERTYSETHEADER +
cSectionT * CB_FORMATIDOFFSET +
CB_MINSECTIONSIZE;
}
// Initialize the requested property set.
PROPASSERT(pfmtid != NULL);
pfo->fmtid = *pfmtid;
_InitSection(pfo,
LocaleId,
// TRUE => Create an empty dictionary
pfo->fmtid == guidDocumentSummarySection2 );
_cSection = cSectionT;
_oSection = pfo->dwOffset;
// ----
// Exit
// ----
Exit:
return;
} // CPropertySetStream::_Create
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_LoadHeader
//
// Synopsis: verify header of a property set and read the code page
//
// Arguments: [pfmtid] -- format id
// [Mode] -- open mode
// [pstatus] -- Pointer to NTSTATUS code.
//
// Returns: LOADSTATE
//---------------------------------------------------------------------------
LOADSTATE
CPropertySetStream::_LoadHeader(
OPTIONAL IN GUID const *pfmtid,
IN BYTE Mode,
OUT NTSTATUS *pstatus)
{
LOADSTATE loadstate = LOADSTATE_FAIL;
ULONG cbstm, cbMin;
PROPERTYSECTIONHEADER *psh;
FORMATIDOFFSET const *pfo;
BOOLEAN fSummaryInformation = FALSE;
#if DBGPROP
BOOLEAN fFirst = _pph == NULL;
#endif
*pstatus = STATUS_SUCCESS;
PROPASSERT((_State & CPSS_USERDEFINEDDELETED) == 0);
// If this is one of the DocSumInfo property sets,
// we need to set some _State bits. If this is an
// Open, rather than a Create, pfmtid may be NULL.
// In that case, we'll set these bits after the open
// (since we can then get the fmtid from the header).
if( pfmtid != NULL && *pfmtid == guidDocumentSummary )
{
_State |= CPSS_DOCUMENTSUMMARYINFO;
}
if (pfmtid != NULL && *pfmtid == guidDocumentSummarySection2)
{
_State |= CPSS_USERDEFINEDPROPERTIES;
}
else
{
// If this isn't the UD property set, the Mode
// better not be "Delete" (all other property sets
// are deleted simply be deleting the underlying
// stream).
if (Mode == CREATEPROP_DELETE)
{
DebugTrace(0, Dbg, ("_LoadHeader: CREATEPROP_DELETE\n"));
StatusInvalidParameter(pstatus, "_LoadHeader: CREATEPROP_DELETE");
goto Exit;
}
if (Mode == CREATEPROP_CREATE)
{
goto Exit; // We're going to overwrite it anyway
}
}
// Get the size of the underlying stream.
cbstm = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Map the serialized property set to a pointer.
_MSTM(Map)(FALSE, (VOID **) &_pph);
// Compute the minimum size of this property set, as specified
// by the property set header and the section headers. This call
// will fail if any part of these headers is beyond the end of the
// the stream (as determined from cbstm). It will *not* fail if
// a section's cbSection indicates that the section goes beyond the
// end of the stream.
cbMin = _ComputeMinimumSize(cbstm, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// The following assert should technically ASSERT equality. However,
// to avoid unmapping and closing sections for every property operation,
// we allow shrinks to fail when other instances of the same property
// set are active. So we on occasion will legitimately see streams larger
// than necessary. The wasted space will be cleaned up when the property
// set is next modified.
//PROPASSERT(cbMin == cbstm);
// The following assert should be valid, but it isn't for some
// older property sets which we fix in the _Fix* routines, which
// are called below.
//PROPASSERT(cbMin <= cbstm);
DebugTrace(0, KERNELSELECT(Dbg, Dbg | DEBTRACE_CREATESTREAM), (
"ComputeMinimumSize: cbMin=%l" szX " cbstm=%l" szX " cbUnused=%l" szX "\n",
cbMin,
cbstm,
cbstm - cbMin));
_oSection = 0;
_cSection = 1;
_cbTail = 0;
#ifdef KERNEL
_CodePage = CP_WINUNICODE;
#endif
if (_HasPropHeader())
{
// The first expression must be TRUE before we can dereference _pph
// for the second expression.
if (cbstm < CB_PROPERTYSETHEADER + CB_FORMATIDOFFSET ||
cbstm < CB_PROPERTYSETHEADER + _pph->reserved * CB_FORMATIDOFFSET ||
_pph->wByteOrder != 0xfffe ||
_pph->wFormat != 0 ||
_pph->reserved < 1)
{
_cSection = 0; // Mark property set invalid
DebugTrace(0, cbstm != 0? DEBTRACE_ERROR : Dbg, (
"_LoadHeader: %s (ver=%lx)\n",
cbstm == 0? "Empty Stream" :
cbstm < CB_PROPERTYSETHEADER + CB_FORMATIDOFFSET?
"Stream too small for header" :
_pph->wByteOrder != 0xfffe? "Bad wByteOrder field" :
_pph->wFormat != 0? "Bad wFormat field" :
_pph->reserved < 1? "Bad reserved field" :
"Bad dwOSVer field",
_pph != NULL? _pph->dwOSVer : 0));
goto Exit;
}
// Now that we've loaded the property set, check again
// to see if this is a SumInfo or DocSumInfo set.
pfo = _GetFormatidOffset(0);
if (pfo->fmtid == guidDocumentSummary)
{
_State |= CPSS_DOCUMENTSUMMARYINFO;
}
else if (pfo->fmtid == guidSummary)
{
fSummaryInformation = TRUE;
}
// If what we're after is the property set in the
// second section, verify that it's there.
if (_State & CPSS_USERDEFINEDPROPERTIES)
{
// Ensure that this is the second section of
// the DocSumInfo property set; that's the only
// two-section property set we support.
if ((_State & CPSS_DOCUMENTSUMMARYINFO) == 0)
{
DebugTrace(0, DEBTRACE_ERROR, ("Not DocumentSummaryInfo 1st FMTID\n"));
goto Exit;
}
// Verify that this property set has two sections, and that
// the second section is the UD propset.
if (_pph->reserved < 2 ||
(pfo = _GetFormatidOffset(1))->fmtid != guidDocumentSummarySection2)
{
DebugTrace(
0,
_pph->reserved < 2? Dbg : DEBTRACE_ERROR,
("Bad/missing 2nd section FMTID\n"));
loadstate = LOADSTATE_USERDEFINEDNOTFOUND;
goto Exit;
}
}
else if (pfmtid != NULL)
{
// This isn't the UserDefined property set, so it
// should be the first section, so it should match
// the caller-requested format ID.
if (*pfmtid != pfo->fmtid)
{
// The propset's FmtID doesn't match, but maybe that's
// because it's a MacWord6 SumInfo property set, in which
// the FmtID isn't byte-swapped. Otherwise, it's a problem.
if( OSKIND_MACINTOSH == PROPSETHDR_OSVER_KIND(_pph->dwOSVer)
&&
guidSummary == *pfmtid
&&
IsEqualFMTIDByteSwap( *pfmtid, pfo->fmtid )
)
{
fSummaryInformation = TRUE;
}
else
{
_cSection = 0;
DebugTrace(0, DEBTRACE_ERROR, ("Bad FMTID\n"));
loadstate = LOADSTATE_BADFMTID;
goto Exit;
}
} // if (*pfmtid != pfo->fmtid)
} // else if (pfmtid != NULL)
_oSection = pfo->dwOffset;
_cSection = _pph->reserved;
} // if (_HasPropHeader())
psh = _GetSectionHeader();
// Scan the property set for a code page, and set _CodePage.
_SearchForCodePage( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If we have multiple sections, record the tail length
// (the size of the property set beyond this section).
if (_cSection > 1)
{
_State |= CPSS_MULTIPLESECTIONS;
_cbTail = cbMin - (_oSection + psh->cbSection);
DebugTrace(0, Dbg, ("_LoadHeader: cbTail=%x\n", _cbTail));
}
// Fix all header-related problems in the in-memory representation.
// The only header-related problems we fix are with SummaryInformation
// property sets.
if (fSummaryInformation)
{
_FixSummaryInformation(&cbstm, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// Now that, to the best of our ability, the headers are good,
// let's validate them against the actual stream size.
if (cbstm < _oSection + CB_PROPERTYSECTIONHEADER ||
psh->cbSection < CB_PROPERTYSECTIONHEADER +
psh->cProperties * CB_PROPERTYIDOFFSET ||
cbstm < _oSection + CB_PROPERTYSECTIONHEADER +
psh->cProperties * CB_PROPERTYIDOFFSET ||
cbstm < _oSection + psh->cbSection)
{
_cSection = 0;
DebugTrace(0, Dbg, ("_LoadHeader: too small for section\n"));
goto Exit;
}
// Now we know the headers are OK, so let's see if there are any
// problems in the properties themselves that we know how
// to fix.
if (fSummaryInformation || (_State & CPSS_DOCUMENTSUMMARYINFO))
{
_FixPackedPropertySet( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
if (Mode == CREATEPROP_DELETE)
{
loadstate = LOADSTATE_USERDEFINEDDELETE;
goto Exit;
}
// ----
// Exit
// ----
loadstate = LOADSTATE_DONE;
Exit:
return( loadstate );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixSummaryInformation
//
// Synopsis: Fix up the memory image of a SummaryInformation propset,
// except for packing or padding problems (which are fixed
// in _FixPackedPropertySet).
//
// Arguments: [pcbstm] - The size of the mapped stream. This may
// be updated by this routine.
// [pstatus] - Pointer to NTSTATUS code.
//
// Returns: None
//
//---------------------------------------------------------------------------
#define PID_THUMBNAIL 0x00000011 // SummaryInformation thumbnail property
VOID
CPropertySetStream::_FixSummaryInformation(IN OUT ULONG *pcbstm,
OUT NTSTATUS *pstatus)
{
PROPERTYSECTIONHEADER *psh;
PROPERTYIDOFFSET *ppo, *ppoMax;
*pstatus = STATUS_SUCCESS;
// If this property set has multiple sections, then it's not one
// of the ones we know how to fix in this routine.
if (1 != _cSection) goto Exit;
// Load pointers to the section header and the PID/Offset array.
psh = _LoadPropertyOffsetPointers(&ppo, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) || NULL == psh ) goto Exit;
// Look for the MS Publisher problem. Pub only writes
// a Thumbnail, but it sets the section size too short (by 4 bytes).
// Pub95 has the additional problem that it doesn't DWORD-align the
// section and stream size. We fix both of these problems below.
if (*pcbstm == _oSection + psh->cbSection + sizeof(ULONG))
{
// Look for the thumbnail property.
for ( ; ppo < ppoMax; ppo++)
{
if (ppo->propid == PID_THUMBNAIL)
{
SERIALIZEDPROPERTYVALUE const *pprop;
// If this property isn't properly aligned, then ignore it.
if (ppo->dwOffset & (sizeof(DWORD) - 1))
{
break;
}
// Get a pointer to the property.
pprop = (SERIALIZEDPROPERTYVALUE *)
_MapOffsetToAddress(ppo->dwOffset);
// Look specifically for the Publisher's Thumbnail property.
// If this is a Publisher set, the lengths won't add
// up correctly. For the lengths to add up correctly,
// the offset of the property, plus
// the length of the thumbnail, plus the size of the VT
// DWORD and the size of the length DWORD should be the
// size of the Section. But In the case of Publisher,
// the section length is 4 bytes short.
if (PropByteSwap(pprop->dwType) == VT_CF // It's in a clipboard format
&& // For Windows
*(ULONG *) &pprop->rgb[sizeof(ULONG)] == PropByteSwap((ULONG)MAXULONG)
&&
ppo->dwOffset + // And the lengths don't add up
PropByteSwap( *(ULONG *) pprop->rgb ) +
(3 - 2) * sizeof(ULONG) == psh->cbSection)
{
// We've found the Publisher problem.
// For Pub95 files, we must dword-align the section
// and stream size. We don't change the size of the underlying
// stream, however, just the mapping. This is because if the caller
// doesn't make any explicit changes, we don't want the mapped Stream
// to be modified. We do this step before fixing the section-size
// problem, so if it should fail we haven't touched anything.
if( !IsDwordAligned( *pcbstm ))
{
// Increase the size of the buffer, and reload the
// psh pointer.
*pcbstm += DwordRemain(*pcbstm);
_MSTM(SetSize)(*pcbstm, // The new size
FALSE, // Don't update the underlying stream
(VOID **) &_pph, // The new mapping
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
psh = _LoadPropertyOffsetPointers(&ppo, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Align the section size.
psh->cbSection += DwordRemain(psh->cbSection);
}
// Now correct the section size.
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixSummaryInformation: Patch section size: %x->%x\n",
psh->cbSection,
psh->cbSection + sizeof(ULONG)));
psh->cbSection += sizeof(ULONG);
} // if (pprop->dwType == VT_CF ...
break;
} // if (ppo->propid == PID_THUMBNAIL)
} // for ( ; ppo < ppoMax; ppo++)
} // if (cbstm == _oSection + psh->cbSection + sizeof(ULONG))
// Look for the Excel 5.0a problem.
// Excel 5.0a set the cbSection field to be 4 bytes too
// high. This code handles the more general case where the
// cbSection is too long for the stream. In such cases, if
// all the properties actually fit within the stream, the
// cbSection field is corrected.
if (*pcbstm < _oSection + psh->cbSection)
{
// We'll fix this problem by adjusting the cbSection
// value. We have to be careful, though,
// that the entire section fits within this new cbSection
// value. For efficiency, we'll just find the property
// which is at the highest offset, and verify that it's
// within the new section size.
// Get what we think is the actual section length.
ULONG cbSectionActual = *pcbstm - _oSection;
ULONG dwHighestOffset = 0;
ULONG cbProperty;
// Find the property with the highest offset.
for ( ; ppo < ppoMax; ppo++)
{
if( ppo->dwOffset > dwHighestOffset )
dwHighestOffset = ppo->dwOffset;
}
// How long is this property?
cbProperty = PropertyLengthNoEH(
// Pointer to property
(SERIALIZEDPROPERTYVALUE *)
_MapOffsetToAddress(dwHighestOffset),
// Bytes between above ptr & end of stream
*pcbstm - _oSection - dwHighestOffset,
0, // Flags
pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Does this property fit within the section? If so, then fix this
// property set.
if( dwHighestOffset + DwordAlign(cbProperty) <= cbSectionActual )
{
psh->cbSection = dwHighestOffset + DwordAlign(cbProperty);
}
else
{
StatusCorruption(pstatus, "SumInfo cbSection is too long for the Stream.");
}
} // if (*pcbstm < _oSection + psh->cbSection)
// ----
// Exit
// ----
Exit:
return;
} // CPropertySetStream::_FixSummaryInformation()
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixPackedPropertySet
//
// Synopsis: Align the memory image of a propset.
//
// Algorithm: We need to move the properties within the
// property set so that they are properly aligned,
// and we need to adjust the PID/Offset array accordingly.
// This is complicated by the fact that we may have to
// grow some propertes (which are not properly padded
// for alignement) and at the same time we may have to
// shrink some properties (which are over-padded).
//
// To handle these two constraints, and to
// avoid growing the underlying stream any more
// than necessary, we process the property set in
// two phases. In the Compaction phase, we shrink
// properties which are over-padded. In the Expansion
// phase, we grow properties which are under-padded.
// For example, say we have a property set with 3
// properties, all of which should be 4 bytes. But
// say they are currently 2, 4, and 6 bytes. Thus
// we must grow the first property, hold the second
// constant, and shrink the third property. In this
// example, after the Compaction phase, the 3 properties
// will be 2, 4, and 4 bytes. After the Expansion phase,
// the properties will be 4, 4, and 4 bytes.
//
// To do all of this, we make a copy of the PID/Offset
// array (apoT) and sort it. We then proceed to make
// two arrays of just offsets (no PIDs) - aopropShrink
// and aopropFinal. aopropShrink holds the offset for
// each property after the Compaction phase. aopropFinal
// holds the offset for each property after the
// Expansion phase. (Note that each of these phases
// could be skipped if they aren't necessary.)
//
// Finally, we perform the Compaction and Expansion,
// using aopropShrink and aopropFinal, respectively,
// as our guide.
//
// Arguments: [pstatus] -- Pointer to NTSTATUS code.
//
// Returns: None
//---------------------------------------------------------------------------
INT _CRTAPI1 fnOffsetCompare(VOID const *ppo1, VOID const *ppo2);
// DocumentSummaryInformation special case properties (w/packed vector elements)
#define PID_HEADINGPAIR 0x0000000c // heading pair (VT_VECTOR | VT_VARIANT):
// {VT_LPSTR, VT_I4} pairs
#define PID_DOCPARTS 0x0000000d // docparts (VT_VECTOR | VT_LPSTR)
//#define PID_HLINKS 0x00000015 // hlinks vector
VOID
CPropertySetStream::_FixPackedPropertySet(OUT NTSTATUS *pstatus)
{
// ------
// Locals
// ------
BOOLEAN fPacked = FALSE;
BOOLEAN fDocSummaryInfo = FALSE;
#if DBGPROP
BOOLEAN fExpandDocSummaryInfo = FALSE;
#endif
PROPERTYSECTIONHEADER *psh = NULL;
PROPERTYIDOFFSET *ppoT, *ppoTMax;
PROPERTYIDOFFSET *ppo, *ppoBase, *ppoMax;
PROPERTYIDOFFSET *apoT = NULL;
ULONG *aopropShrink = NULL;
ULONG *aopropFinal = NULL;
ULONG cbprop;
ULONG cCompact, cExpand;
ULONG *poprop = NULL;
#if i386 == 0
SERIALIZEDPROPERTYVALUE *ppropbuf = NULL;
ULONG cbpropbuf = 0;
#endif
ULONG cbtotal = 0;
// -----
// Begin
// -----
*pstatus = STATUS_SUCCESS;
// Determine if this is the first section of the DocSumInfo
// property set.
if ((_State & (CPSS_USERDEFINEDPROPERTIES | CPSS_DOCUMENTSUMMARYINFO)) ==
CPSS_DOCUMENTSUMMARYINFO)
{
fDocSummaryInfo = TRUE;
}
// Get pointers into this section's header.
psh = _LoadPropertyOffsetPointers(&ppoBase, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// We know it's packed if the section-length isn't aligned.
fPacked = !IsDwordAligned(psh->cbSection);
// If we don't already know it's packed, check each of the properties in
// the PID/Offset array to see if one is not properly aligned, if so we'll
// assume that it's packed. Also, if this is an Ansi DocSumInfo property set,
// (first section), we'll assume that the HeadingPair and DocParts properties
// are packed (vectors).
if (!fPacked && psh != NULL)
{
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
if ( !IsDwordAligned(ppo->dwOffset)
||
( fDocSummaryInfo
&&
_CodePage != CP_WINUNICODE
&&
( ppo->propid == PID_HEADINGPAIR
||
ppo->propid == PID_DOCPARTS
)
)
)
{
fPacked = TRUE;
break;
}
}
}
// ----------------------------------------------------
// Fix the properties if they are packed or if there is
// unnecessary padding.
// ----------------------------------------------------
// If we know there's a problem, set a _State flag
// now. If we can fix the problem below, we'll clear it.
// Otherwise, the rest of the Class will know that there's
// an unresolved problem.
if (fPacked)
{
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixPackedPropertySet: packed properties\n"));
_State |= CPSS_PACKEDPROPERTIES;
}
// ---------------------------------------------------------
// Create apoT (a sorted array of PID/Offsets), aopropShrink
// (the offsets for the Compaction phase) and aopropFinal
// (the offsets for the Expansion phase).
// ---------------------------------------------------------
// Create a buffer for a temporary PID/Offset array.
apoT = newk(mtPropSetStream, NULL) PROPERTYIDOFFSET[psh->cProperties + 1];
if (apoT == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
// Copy the PID/offset pairs from the property set to the
// temporary PID/Offset array.
RtlCopyMemory(
apoT,
psh->rgprop,
psh->cProperties * CB_PROPERTYIDOFFSET);
// Mark the end of the temporary array.
ppoTMax = apoT + psh->cProperties;
ppoTMax->propid = PID_ILLEGAL;
ppoTMax->dwOffset = psh->cbSection;
// Sort the PID/Offset array by offset and check for overlapping values:
qsort(apoT, psh->cProperties, sizeof(apoT[0]), fnOffsetCompare);
// Create two arrays which will hold property offsets.
// aopropShrink holds the offsets for the Compaction phase where
// we shrink the property set. aopropFinal holds the offsets
// of the final property set, which will be achieved in the
// Expansion phase.
aopropShrink = newk(mtPropSetStream, NULL) ULONG[psh->cProperties + 1];
if (aopropShrink == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
aopropFinal = newk(mtPropSetStream, NULL) ULONG[psh->cProperties + 1];
if (aopropFinal == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
#if i386 == 0
// On non-x86 machines, we can't directly access unaligned
// properties. So, allocate enough (aligned) memory to hold
// the largest unaligned property. We'll copy properties here
// when we need to access them.
for (ppoT = apoT; ppoT < ppoTMax; ppoT++)
{
if (!IsDwordAligned(ppoT->dwOffset))
{
cbprop = DwordAlign(ppoT[1].dwOffset - ppoT->dwOffset);
if (cbpropbuf < cbprop)
{
cbpropbuf = cbprop;
}
}
}
if (cbpropbuf != 0)
{
ppropbuf = (SERIALIZEDPROPERTYVALUE *)
newk(mtPropSetStream, NULL) BYTE[cbpropbuf];
if (ppropbuf == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
}
#endif // i386==0
// ----------------------------------------------
// Iterate through the properties, filling in the
// entries of aopropShrink and aopropFinal.
// ----------------------------------------------
// We'll also count the number of compacts and expands
// necessary.
aopropShrink[0] = aopropFinal[0] = apoT[0].dwOffset;
PROPASSERT(IsDwordAligned(aopropShrink[0]));
cExpand = 0;
cCompact = 0;
for (ppoT = apoT; ppoT < ppoTMax; ppoT++)
{
SERIALIZEDPROPERTYVALUE *pprop;
BOOLEAN fDocSumLengthComputed = FALSE;
ULONG cbpropOriginal;
// How much space does the property take up in the current
// property set?
cbpropOriginal = cbprop = ppoT[1].dwOffset - ppoT->dwOffset;
pprop = (SERIALIZEDPROPERTYVALUE *)
_MapOffsetToAddress(ppoT->dwOffset);
#if i386 == 0
// If necessary, put this property into an aligned buffer.
if (!IsDwordAligned(ppoT->dwOffset))
{
DebugTrace(0, Dbg, (
"_FixPackedPropertySet: unaligned pid=%x off=%x\n",
ppoT->propid,
ppoT->dwOffset));
PROPASSERT(DwordAlign(cbprop) <= cbpropbuf);
RtlCopyMemory((VOID *) ppropbuf, pprop, cbprop);
pprop = ppropbuf;
}
#endif
// Calculate the actual length of this property, including
// the necessary padding. This might be bigger than the
// property's current length (if the propset wasn't properly
// padded), and it might be smaller than the property's current
// length (if the propset was over-padded).
if (ppoT->propid == PID_DICTIONARY)
{
// Get the size of the dictionary.
cbprop = DwordAlign(_DictionaryLength(
(DICTIONARY const *) pprop,
cbprop,
pstatus));
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
else
{
ULONG cbpropT;
// Ansi DocSumInfo property sets have two vector properties
// which are packed. If this is one of those properties,
// we won't fix it yet, but we'll compute the size required
// when the elements are un-packed.
if (fDocSummaryInfo && _CodePage != CP_WINUNICODE)
{
if (ppoT->propid == PID_HEADINGPAIR)
{
fDocSumLengthComputed = _FixHeadingPairVector(
PATCHOP_COMPUTESIZE,
pprop,
&cbpropT);
}
else
if (ppoT->propid == PID_DOCPARTS)
{
fDocSumLengthComputed = _FixDocPartsVector(
PATCHOP_COMPUTESIZE,
pprop,
&cbpropT);
}
}
// If we computed a length above, use it, otherwise calculate
// the length using the standard rules (we've already checked
// for the special cases).
if (fDocSumLengthComputed)
{
cbprop = cbpropT;
#if DBGPROP
fExpandDocSummaryInfo = TRUE;
#endif
}
else
{
cbprop = PropertyLengthNoEH(pprop, DwordAlign(cbprop), 0, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
} // if (ppoT->propid == PID_DICTIONARY) ... else
PROPASSERT(IsDwordAligned(cbprop));
// Now that we know the actual cbprop, use it to update the
// *next* entry in the two arrays of correct offsets.
//
// We want aopropFinal to hold the final, correct offsets,
// so we'll use cbprop to calculate this array.
// But for aopropShrink, we only want it to differ from
// the original array (apoT) when a property is shrinking,
// so we'll use min(cbNew,cbOld) for this array.
poprop = &aopropShrink[ ppoT - apoT ]; // 1st do aopropShrink
poprop[1] = poprop[0] + min(cbprop, cbpropOriginal);
poprop = &aopropFinal[ ppoT - apoT ]; // 2nd do aopropFinal
poprop[1] = poprop[0] + cbprop;
DebugTrace(0, Dbg, (
"_FixPackedPropertySet: pid=%x off=%x->%x\n",
ppoT->propid,
ppoT->dwOffset,
poprop[0],
poprop[0] < ppoT->dwOffset?
" (compact)" :
poprop[0] > ppoT->dwOffset? " (expand)" : ""));
// Is this compaction or an expansion?
// If we computed the doc-sum length, we count it as
// an expansion, even if the total property size didn't change,
// because we need the expand the elements within the vector.
if (cbprop < cbpropOriginal)
{
cCompact++;
}
else
if (cbprop > cbpropOriginal || fDocSumLengthComputed)
{
cExpand++;
}
} // for (ppoT = apoT; ppoT < ppoTMax; ppoT++)
// -------------------------------
// Compact/Expand the Property Set
// -------------------------------
// We've now generated the complete aopropShrink and aopropFinal
// offset arrays. Now, if necessary, let's expand and/or compact
// the property set to match these offsets.
if (cExpand || cCompact)
{
ULONG cbstm;
LONG cbdelta;
cbstm = _oSection + psh->cbSection + _cbTail;
cbdelta = aopropFinal[psh->cProperties] - psh->cbSection;
DebugTrace(0, Dbg, (
"_FixPackedPropertySet: cbstm=%x cbdelta=%x cexpand=%x ccompact=%x\n",
cbstm,
cbdelta,
cExpand,
cCompact));
// -----------------------------
// Grow the Stream if necessary.
// -----------------------------
if (cbdelta > 0)
{
DebugTrace(0, Dbg, (
"SetSize(%x) _FixPackedPropertySet grow %x bytes\n",
cbstm + cbdelta,
cbdelta));
// On the set-size, say that this is a non-persistent
// change, so that the underlying Stream isn't modified.
// At this point, we don't know if this change should remain
// permanent (if the caller closes without making any changes
// the file should remain un-changed).
_MSTM(SetSize)(
cbstm + cbdelta,
FALSE, // Not persistent
(VOID **) &_pph,
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// reload all pointers into mapped image:
psh = _LoadPropertyOffsetPointers(&ppoBase, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If there's another section after this one, move it back
// to the end of the stream now, which will create room for
// our expansion.
if (_cbTail != 0)
{
VOID *pvSrc = _MapAbsOffsetToAddress(cbstm - _cbTail);
PropMoveMemory(
"_FixPackedPropertySet(_cbTail:grow)",
psh,
Add2Ptr(pvSrc, cbdelta),
pvSrc,
_cbTail);
}
} // if (cbdelta > 0)
// This previous step (growing the Stream), was the last one which can
// fail. We're about to modify the actual property set (we've been
// working only with temporary buffers so far). So we're always guaranteed
// a good property set, or the original set, we'll never end up with a
// half-updated set.
// ----------------
// Compaction Phase
// ----------------
// Compact the property set if necessary. I.e., adjust
// the property set buffer so that it matches aopropShrink.
if (cCompact > 0)
{
// Start at the beginning and move each property up.
poprop = aopropShrink;
for (ppoT = apoT; ppoT < ppoTMax; ppoT++, poprop++)
{
if (*poprop != ppoT->dwOffset)
{
PROPASSERT(*poprop < ppoT->dwOffset);
PROPASSERT(poprop[1] > *poprop);
// We're compacting; the property should not grow!
PROPASSERT(
poprop[1] - *poprop <=
ppoT[1].dwOffset - ppoT->dwOffset);
PropMoveMemory(
"_FixPackedPropertySet(compact)",
psh,
Add2Ptr(psh, *poprop),
Add2Ptr(psh, ppoT->dwOffset),
poprop[1] - *poprop);
}
} // for (ppoT = apoT; ppoT < ppoTMax; ppoT++, poprop++)
} // if (cCompact > 0)
// ---------------
// Expansion phase
// ---------------
// Recall that, whether or not we just did a compaction, aopropShrink
// holds the property set offsets as they currently exist in the
// property set.
if (cExpand > 0)
{
// Start at the end and move each property back.
// The 'poprop' gives us the final correct offset
// of the current property.
LONG lOffsetIndex;
poprop = &aopropFinal[psh->cProperties - 1];
// Start at the second-to-last entry in the arrays of offsets
// (the last entry is an artificially added one to mark the end of the
// property set).
for (lOffsetIndex = ppoTMax - apoT - 1, ppoT = ppoTMax - 1;
lOffsetIndex >=0;
lOffsetIndex--, poprop--, ppoT--)
{
// Get a pointer to the final location of this
// property.
SERIALIZEDPROPERTYVALUE *pprop;
pprop = (SERIALIZEDPROPERTYVALUE *)
Add2Ptr(psh, *poprop);
if (*poprop != aopropShrink[ lOffsetIndex ])
{
ULONG cbCopy, cbOld;
PROPASSERT(*poprop > aopropShrink[ lOffsetIndex ]);
PROPASSERT(poprop[1] > *poprop);
PROPASSERT(aopropShrink[ lOffsetIndex+1 ] > aopropShrink[ lOffsetIndex ]);
// How many bytes should we copy? The minimum size of the property
// calculated using the old and new offsets.
cbCopy = poprop[1] - poprop[0];
cbOld = aopropShrink[ lOffsetIndex+1 ]
- aopropShrink[ lOffsetIndex+0 ];
if (cbCopy > cbOld)
{
cbCopy = cbOld;
}
// Copy the property from its old location
// (psh+aopropShrink[lOffsetIndex]) to its new location
// (pprop == psh+*poprop).
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixPackedPropertySet:move pid=%x off=%x->%x "
"cb=%x->%x cbCopy=%x z=%x @%x\n",
ppoT->propid,
ppoT->dwOffset,
*poprop,
cbOld,
poprop[1] - *poprop,
cbCopy,
DwordRemain(cbCopy),
_MapAddressToOffset(Add2Ptr(pprop, cbCopy))));
PropMoveMemory(
"_FixPackedPropertySet(expand)",
psh,
pprop,
Add2Ptr(psh, aopropShrink[ lOffsetIndex ]),
cbCopy);
RtlZeroMemory(
Add2Ptr(pprop, cbCopy),
DwordRemain(cbCopy));
} // if (*poprop != ppoT->dwOffset)
// If this is an older DocSumInfo property set,
// and this property is one of the vector values,
// we must expand the vector elements now that we've
// room for it.
if (fDocSummaryInfo && _CodePage != CP_WINUNICODE)
{
ULONG cbpropT;
if (ppoT->propid == PID_HEADINGPAIR)
{
_FixHeadingPairVector(
PATCHOP_EXPAND,
pprop,
&cbpropT);
}
else
if (ppoT->propid == PID_DOCPARTS)
{
_FixDocPartsVector(
PATCHOP_EXPAND,
pprop,
&cbpropT);
}
} // if (fDocSummaryInfo)
} // for (ppoT = ppoTMax; --ppoT >= apoT; popropNew--)
} // if (cExpand != 0)
// ---------------------------------------------------------
// Patch the section size and the moved properties' offsets.
// ---------------------------------------------------------
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixPackedPropertySet: Patch section size %x->%x\n",
psh->cbSection,
psh->cbSection + cbdelta));
psh->cbSection += cbdelta;
// Iterate through the original PID/Offset array to update the
// offsets.
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
// Search the temporary PID/Offset array (which has the updated
// offsets) for ppo->propid.
for (ppoT = apoT; ppoT < ppoTMax; ppoT++)
{
if (ppo->propid == ppoT->propid)
{
// We've found ppo->propid in the temporary PID/Offset
// array. Copy the offset value from the temporary array
// to the actual array in the property set.
PROPASSERT(ppo->dwOffset == ppoT->dwOffset);
ppo->dwOffset = aopropFinal[ppoT - apoT];
#if DBGPROP
if (ppo->dwOffset != ppoT->dwOffset)
{
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixPackedPropertySet: Patch propid %x"
" offset=%x->%x\n",
ppo->propid,
ppoT->dwOffset,
ppo->dwOffset));
} // if (ppo->dwOffset != ppoT->dwOffset)
#endif
break;
} // if (ppo->propid == ppoT->propid)
} // for (ppoT = apoT; ppoT < ppoTMax; ppoT++)
} // for (ppo = ppoBase; ppo < ppoMax; ppo++)
// ------------
// Fix the tail
// ------------
// If we have a tail, fix it's offset in the FmtID/Offset
// array. Also, if we've overall shrunk this section, bring
// the tail in accordingly.
if (_cbTail != 0)
{
if (cbdelta < 0)
{
VOID *pvSrc = _MapAbsOffsetToAddress(cbstm - _cbTail);
PropMoveMemory(
"_FixPackedPropertySet(_cbTail:shrink)",
psh,
Add2Ptr(pvSrc, cbdelta),
pvSrc,
_cbTail);
}
_PatchSectionOffsets(cbdelta);
} // if (_cbTail != 0)
// If we get to this point we've successfully un-packed (or
// un-over-padded) the property set, so we can clear the
// state flag.
_State &= ~CPSS_PACKEDPROPERTIES;
} // if (cExpand || cCompact)
// ----
// Exit
// ----
Exit:
delete [] apoT;
delete [] aopropShrink;
delete [] aopropFinal;
#if i386 == 0
delete [] (BYTE *) ppropbuf;
#endif // i386
} // CPropertySetStream::_FixPackedPropertySet()
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixDocPartsVector
//
// Synopsis: Align the memory image of a DocParts vector
// The DocParts property is part of the DocSumInfo
// property set (first section). It is a vector
// of strings, and in Ansi property sets it's packed
// and must be un-packed.
//
// Arguments: [PatchOp] -- patch request
// [pprop] -- property value to be patched or sized
// [pcbprop] -- pointer to computed property length
//
// Returns: TRUE if property type and all elements meet expectations;
// FALSE on error
//
// Note: Operate on a DocumentSummaryInformation first section property,
// PID_DOCPARTS. This property is assumed to be an array of
// VT_LPSTRs.
//
// PATCHOP_COMPUTESIZE merely computes the size required to unpack
// the property, and must assume it is currently unaligned.
//
// PATCHOP_ALIGNLENGTHS patches all VT_LPSTR lengths to DWORD
// multiples, and may rely on the property already being aligned.
//
// PATCHOP_EXPAND expands the property from the Src to Dst buffer,
// moving elements to DWORD boundaries, and patching VT_LPSTR
// lengths to DWORD multiples. The Src buffer is assumed to be
// unaligned, and the Dst buffer is assumed to be properly sized.
//---------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_FixDocPartsVector(
IN PATCHOP PatchOp,
IN OUT SERIALIZEDPROPERTYVALUE *pprop,
OUT ULONG *pcbprop)
{
PROPASSERT(
PatchOp == PATCHOP_COMPUTESIZE ||
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
PROPASSERT(pprop != NULL);
PROPASSERT(pcbprop != NULL);
// If the property is a variant vector,
// it's in an ANSI property set, and
// there are an even number of elements, ...
if ( PropByteSwap(pprop->dwType) == (VT_VECTOR | VT_LPSTR)
&&
_CodePage != CP_WINUNICODE)
{
ULONG cString;
VOID *pv;
cString = PropByteSwap( *(DWORD *) pprop->rgb );
pv = Add2Ptr(pprop->rgb, sizeof(DWORD));
if (_FixDocPartsElements(PatchOp, cString, pv, pv, pcbprop))
{
*pcbprop += CB_SERIALIZEDPROPERTYVALUE + sizeof(ULONG);
return(TRUE);
}
}
return(FALSE); // Not a recognizable DocParts vector
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixDocPartsElements
//
// Synopsis: Recursively align the memory image of DocParts elements
//
// Arguments: [PatchOp] -- patch request
// [cString] -- count of strings remaining in the vector
// [pvDst] -- aligned overlapping destination buffer
// [pvSrc] -- unaligned overlapping source buffer
// [pcbprop] -- pointer to computed property length
//
// Returns: TRUE if all remaining elements meet expectations;
// FALSE on error
//
// Note: The pvDst & pvSrc buffers must be in property-set
// byte order (little endian).
//---------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_FixDocPartsElements(
IN PATCHOP PatchOp,
IN ULONG cString,
OUT VOID *pvDst,
IN VOID UNALIGNED const *pvSrc,
OUT ULONG *pcbprop)
{
ULONG cb;
PROPASSERT(
PatchOp == PATCHOP_COMPUTESIZE ||
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
PROPASSERT(pvDst >= pvSrc);
PROPASSERT(PatchOp != PATCHOP_ALIGNLENGTHS || pvDst == pvSrc);
if (cString == 0)
{
*pcbprop = 0;
return(TRUE);
}
cb = sizeof(DWORD) + PropByteSwap( *(DWORD UNALIGNED *) pvSrc );
// If the caller serialized the vector properly, all we need to do is
// to round up the string lengths to DWORD multiples, so readers that
// treat these vectors as byte-aligned get faked out. We expect
// readers will not have problems with a DWORD aligned length, and a
// '\0' character a few bytes earlier than the length indicates.
if (PatchOp == PATCHOP_ALIGNLENGTHS)
{
cb = DwordAlign(cb); // Caller says it's already aligned
}
if (_FixDocPartsElements(
PatchOp,
cString - 1,
Add2Ptr(pvDst, DwordAlign(cb)),
(VOID UNALIGNED const *) Add2ConstPtr(pvSrc, cb),
pcbprop))
{
*pcbprop += DwordAlign(cb);
if (PatchOp == PATCHOP_EXPAND)
{
PropMoveMemory(
"_FixDocPartsElements",
_GetSectionHeader(),
pvDst,
pvSrc,
cb);
RtlZeroMemory(Add2Ptr(pvDst, cb), DwordRemain(cb));
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixDocPartsElements: Move(%x:%s) "
"cb=%x->%x off=%x->%x z=%x @%x\n",
cString,
Add2Ptr(pvDst, sizeof(ULONG)),
cb - sizeof(ULONG),
DwordAlign(cb) - sizeof(ULONG),
_MapAddressToOffset(pvSrc),
_MapAddressToOffset(pvDst),
DwordRemain(cb),
_MapAddressToOffset(Add2Ptr(pvDst, cb))));
}
if (PatchOp != PATCHOP_COMPUTESIZE)
{
PROPASSERT(
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixDocPartsElements: Patch(%x:%s) cb=%x->%x\n",
cString,
Add2Ptr(pvDst, sizeof(ULONG)),
*(ULONG *) pvDst,
DwordAlign(*(ULONG *) pvDst)));
*(ULONG *) pvDst = PropByteSwap( DwordAlign( PropByteSwap( *(ULONG *) pvDst )));
}
return(TRUE);
}
return(FALSE); // Not a recognizable DocParts vector
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixHeadingPairVector
//
// Synopsis: Align the memory image of a HeadingPair vector.
// The HeadingPair property is part of the DocSumInfo
// property set (first section). It's a vector of
// Variants, where the elements are alternating
// strings and I4s (the string is a heading name,
// and the I4 is the count of DocumentParts in that
// heading). In Ansi property sets, these elements
// are packed, and must be un-packed.
//
// Arguments: [PatchOp] -- patch request
// [pprop] -- property value to be patched or sized
// [pcbprop] -- pointer to computed property length
//
// Returns: TRUE if property and all elements meet expectations;
// FALSE on error
//
// Note: Operate on a DocumentSummaryInformation first section property,
// PID_HEADINGPAIR. This property is assumed to be an array of
// VT_VARIANTs with an even number of elements. Each pair must
// consist of a VT_LPSTR followed by a VT_I4.
//
// PATCHOP_COMPUTESIZE merely computes the size required to unpack
// the property, and must assume it is currently unaligned.
//
// PATCHOP_ALIGNLENGTHS patches all VT_LPSTR lengths to DWORD
// multiples, and may rely on the property already being aligned.
//
// PATCHOP_EXPAND expands the property from the Src to Dst buffer,
// moving elements to DWORD boundaries, and patching VT_LPSTR
// lengths to DWORD multiples. The Src buffer is assumed to be
// unaligned, and the Dst buffer is assumed to be properly sized.
//---------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_FixHeadingPairVector(
IN PATCHOP PatchOp,
IN OUT SERIALIZEDPROPERTYVALUE *pprop,
OUT ULONG *pcbprop)
{
ULONG celem;
ULONG cbprop = 0;
PROPASSERT(
PatchOp == PATCHOP_COMPUTESIZE ||
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
PROPASSERT(pprop != NULL);
PROPASSERT(pcbprop != NULL);
// If the property is a variant vector, and
// there are an even number of elements, ...
if( PropByteSwap(pprop->dwType) == (VT_VECTOR | VT_VARIANT)
&&
( (celem = PropByteSwap(*(ULONG *) pprop->rgb) ) & 1) == 0
&&
_CodePage != CP_WINUNICODE)
{
pprop = (SERIALIZEDPROPERTYVALUE *) Add2Ptr(pprop->rgb, sizeof(ULONG));
if (_FixHeadingPairElements(PatchOp, celem/2, pprop, pprop, pcbprop))
{
*pcbprop += CB_SERIALIZEDPROPERTYVALUE + sizeof(ULONG);
return(TRUE);
}
}
return(FALSE); // Not a recognizable HeadingPair vector
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_FixHeadingPairElements
//
// Synopsis: Recursively align the memory image of HeadingPair elements
//
// Arguments: [PatchOp] -- patch request
// [cPairs] -- count of heading pairs remaining
// [ppropDst] -- aligned overlapping destination buffer
// [ppropSrc] -- unaligned overlapping source buffer
// [pcbprop] -- pointer to computed property length
//
// Returns: TRUE if all remaining elements meet expectations;
// FALSE on error
//---------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_FixHeadingPairElements(
IN PATCHOP PatchOp,
IN ULONG cPairs,
OUT SERIALIZEDPROPERTYVALUE *ppropDst,
IN SERIALIZEDPROPERTYVALUE UNALIGNED const *ppropSrc,
OUT ULONG *pcbprop)
{
PROPASSERT(
PatchOp == PATCHOP_COMPUTESIZE ||
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
PROPASSERT(ppropDst >= ppropSrc);
PROPASSERT(PatchOp != PATCHOP_ALIGNLENGTHS || ppropDst == ppropSrc);
if (cPairs == 0)
{
*pcbprop = 0;
return(TRUE);
}
// If the first element of the pair is a VT_LPSTR, ...
if( PropByteSwap(ppropSrc->dwType) == VT_LPSTR )
{
ULONG cb;
// Compute size of the string element.
cb = CB_SERIALIZEDPROPERTYVALUE
+
sizeof(ULONG)
+
PropByteSwap( *(DWORD UNALIGNED *) ppropSrc->rgb );
// If the caller serialized the vector properly, all we need to do is
// to round up the string lengths to DWORD multiples, so readers that
// treat these vectors as byte-aligned get faked out. We expect
// readers will not have problems with a DWORD aligned length, and a
// '\0' character a few bytes earlier than the length indicates.
if (PatchOp == PATCHOP_ALIGNLENGTHS)
{
cb = DwordAlign(cb); // Caller says it's already aligned
}
// and if the second element of the pair is a VT_I4, ...
if ( PropByteSwap( (DWORD) VT_I4 )
==
( (SERIALIZEDPROPERTYVALUE UNALIGNED const *)
Add2ConstPtr(ppropSrc, cb)
)->dwType )
{
cb += CB_SERIALIZEDPROPERTYVALUE + sizeof(DWORD);
if (_FixHeadingPairElements(
PatchOp,
cPairs - 1,
(SERIALIZEDPROPERTYVALUE *)
Add2Ptr(ppropDst, DwordAlign(cb)),
(SERIALIZEDPROPERTYVALUE UNALIGNED const *)
Add2ConstPtr(ppropSrc, cb),
pcbprop))
{
*pcbprop += DwordAlign(cb);
if (PatchOp == PATCHOP_EXPAND)
{
// Move the unaligned VT_I4 property back in memory to an
// aligned boundary, move the string back to a (possibly
// different) aligned boundary, zero the space in between
// the two and patch the string length to be a DWORD
// multiple to fake out code that expects vector elements
// to be byte aligned.
// Adjust byte count to include just the string element.
cb -= CB_SERIALIZEDPROPERTYVALUE + sizeof(ULONG);
// Move the VT_I4 element.
PropMoveMemory(
"_FixHeadingPairElements:I4",
_GetSectionHeader(),
Add2Ptr(ppropDst, DwordAlign(cb)),
Add2ConstPtr(ppropSrc, cb),
CB_SERIALIZEDPROPERTYVALUE + sizeof(ULONG));
// Move the VT_LPSTR element.
PropMoveMemory(
"_FixHeadingPairElements:LPSTR",
_GetSectionHeader(),
ppropDst,
ppropSrc,
cb);
// Zero the space in between.
RtlZeroMemory(Add2Ptr(ppropDst, cb), DwordRemain(cb));
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixHeadingPairElements: Move(%x:%s) "
"cb=%x->%x off=%x->%x z=%x @%x\n",
cPairs,
&ppropDst->rgb[sizeof(ULONG)],
PropByteSwap( *(ULONG *) ppropDst->rgb ),
DwordAlign(PropByteSwap( *(ULONG *) ppropDst->rgb )),
_MapAddressToOffset(ppropSrc),
_MapAddressToOffset(ppropDst),
DwordRemain(cb),
_MapAddressToOffset(Add2Ptr(ppropDst, cb))));
}
if (PatchOp != PATCHOP_COMPUTESIZE)
{
PROPASSERT(
PatchOp == PATCHOP_ALIGNLENGTHS ||
PatchOp == PATCHOP_EXPAND);
#ifdef DBGPROP
SERIALIZEDPROPERTYVALUE const *ppropT =
(SERIALIZEDPROPERTYVALUE const *)
Add2Ptr(ppropDst, DwordAlign(cb));
#endif
DebugTrace(0, DEBTRACE_PROPPATCH, (
"_FixHeadingPairElements: Patch(%x:%s) "
"cb=%x->%x, vt=%x, %x\n",
cPairs,
&ppropDst->rgb[sizeof(ULONG)],
PropByteSwap( *(ULONG *) ppropDst->rgb ),
DwordAlign( PropByteSwap( *(ULONG *) ppropDst->rgb )),
PropByteSwap( ppropT->dwType ),
PropByteSwap( *(ULONG *) ppropT->rgb )));
// Patch the string length to be a DWORD multiple.
*(ULONG *) ppropDst->rgb
= PropByteSwap( DwordAlign( PropByteSwap( *(ULONG *) ppropDst->rgb )));
}
return(TRUE);
}
}
}
return(FALSE); // Not a recognizable HeadingPair vector
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::QueryPropertySet
//
// Synopsis: Return the classid for the property set code
//
// Arguments: [pspss] -- pointer to buffer for output
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//---------------------------------------------------------------------------
#ifndef KERNEL
VOID
CPropertySetStream::QueryPropertySet(OUT STATPROPSETSTG *pspss,
OUT NTSTATUS *pstatus) const
{
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
if ((_State & CPSS_USERDEFINEDDELETED) || _cSection < 1)
{
StatusAccessDenied(pstatus, "QueryPropertySet: deleted or no section");
goto Exit;
}
_MSTM(QueryTimeStamps)(
pspss,
(BOOLEAN) ((_Flags & CREATEPROP_NONSIMPLE) != 0));
pspss->clsid = _pph->clsid;
pspss->fmtid = _GetFormatidOffset(
(_State & CPSS_USERDEFINEDPROPERTIES)? 1 : 0)->fmtid;
pspss->grfFlags = _CodePage == CP_WINUNICODE?
PROPSETFLAG_DEFAULT : PROPSETFLAG_ANSI;
// ----
// Exit
// ----
Exit:
return;
}
#endif // !KERNEL
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::SetClassId
//
// Synopsis: Set the classid for the property set code
//
// Arguments: [pclsid] -- pointer to new ClassId
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//---------------------------------------------------------------------------
#ifndef KERNEL
VOID
CPropertySetStream::SetClassId(IN GUID const *pclsid,
OUT NTSTATUS *pstatus)
{
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
if (IsReadOnlyPropertySet(_Flags, _State))
{
StatusAccessDenied(pstatus, "SetClassId: deleted or read-only");
goto Exit;
}
_SetModified();
_pph->clsid = *pclsid;
// ----
// Exit
// ----
Exit:
return;
}
#endif // KERNEL
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::EnumeratePropids
//
// Synopsis: enumerates the property ids in a prop set
//
// Arguments: [pkey] -- pointer to bookmark (0 implies beginning)
// [pcprop] -- on input: size; on output: # of props returned.
// [apropids] -- output buffer
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: TRUE if more properties are available
//---------------------------------------------------------------------------
#ifndef KERNEL
BOOLEAN
CPropertySetStream::EnumeratePropids(
IN OUT ULONG *pkey,
IN OUT ULONG *pcprop,
OPTIONAL OUT PROPID *apropids,
OUT NTSTATUS *pstatus)
{
PROPERTYIDOFFSET *ppo, *ppoStart, *ppoMax;
ULONG cprop = 0;
BOOLEAN fMorePropids = FALSE;
PROPID propidPrev = *pkey;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "EnumeratePropids: deleted");
goto Exit;
}
if (_LoadPropertyOffsetPointers(&ppoStart, &ppoMax, pstatus) == NULL)
{
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
else
{
if (propidPrev != 0) // if not first call, start w/last propid
{
for (ppo = ppoStart; ppo < ppoMax; ppo++)
{
if (ppo->propid == propidPrev)
{
ppoStart = ++ppo;
break;
}
}
}
for (ppo = ppoStart; ppo < ppoMax; ppo++)
{
if (ppo->propid != PID_DICTIONARY &&
ppo->propid != PID_CODEPAGE &&
ppo->propid != PID_LOCALE)
{
if (cprop >= *pcprop)
{
fMorePropids = TRUE;
break;
}
if (apropids != NULL)
{
apropids[cprop] = ppo->propid;
}
cprop++;
propidPrev = ppo->propid;
}
}
}
*pkey = propidPrev;
*pcprop = cprop;
// ----
// Exit
// ----
Exit:
return(fMorePropids);
}
#endif
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_LoadPropertyOffsetPointers
//
// Synopsis: Load start and (past) end pointers to PROPERTYIDOFFSET array
//
// Arguments: [pppo] -- pointer to base of PROPERTYIDOFFSET array
// [pppoMax] -- pointer past end of PROPERTYIDOFFSET array
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: Pointer to Section Header, NULL if section not present
// or if there was an error.
//---------------------------------------------------------------------------
PROPERTYSECTIONHEADER *
CPropertySetStream::_LoadPropertyOffsetPointers(
OUT PROPERTYIDOFFSET **pppo,
OUT PROPERTYIDOFFSET **pppoMax,
OUT NTSTATUS *pstatus)
{
PROPERTYSECTIONHEADER *psh;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
if (_cSection != 0)
{
psh = _GetSectionHeader();
ULONG cbstm = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Ensure that we can read all of the PID/Offset
// table.
if (cbstm < _oSection + CB_PROPERTYSECTIONHEADER ||
cbstm < _oSection + CB_PROPERTYSECTIONHEADER +
psh->cProperties * CB_PROPERTYIDOFFSET)
{
StatusCorruption(pstatus, "LoadPropertyOffsetPointers: stream size");
goto Exit;
}
*pppo = psh->rgprop;
*pppoMax = psh->rgprop + psh->cProperties;
}
// ----
// Exit
// ----
Exit:
if( !NT_SUCCESS(*pstatus) )
psh = NULL;
return(psh);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_LoadProperty
//
// Synopsis: return a pointer to the specified property value
//
// Arguments: [propid] -- property id for property
// [pcbprop] -- pointer to return property size, 0 on error
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: SERIALIZEDPROPERTYVALUE * -- NULL if not present
//---------------------------------------------------------------------------
SERIALIZEDPROPERTYVALUE *
CPropertySetStream::_LoadProperty(
IN PROPID propid,
OUT OPTIONAL ULONG *pcbprop,
OUT NTSTATUS *pstatus )
{
PROPERTYSECTIONHEADER const *psh;
PROPERTYIDOFFSET *ppo, *ppoBase, *ppoMax;
SERIALIZEDPROPERTYVALUE *pprop = NULL;
*pstatus = STATUS_SUCCESS;
psh = _LoadPropertyOffsetPointers(&ppoBase, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (psh != NULL)
{
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
if (IsDwordAligned(ppo->dwOffset)
&&
ppo->dwOffset >= CB_PROPERTYSECTIONHEADER
+
psh->cProperties * CB_PROPERTYIDOFFSET
&&
psh->cbSection >= ppo->dwOffset + CB_SERIALIZEDPROPERTYVALUE)
{
if (ppo->propid != propid)
{
continue;
}
pprop = (SERIALIZEDPROPERTYVALUE *)
_MapOffsetToAddress(ppo->dwOffset);
if (pcbprop != NULL)
{
ULONG cb;
cb = psh->cbSection - ppo->dwOffset;
if (propid == PID_DICTIONARY)
{
*pcbprop = _DictionaryLength(
(DICTIONARY const *) pprop,
cb,
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
else
{
*pcbprop = PropertyLengthNoEH(pprop, cb, 0, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
}
if (pcbprop == NULL ||
psh->cbSection >= ppo->dwOffset + *pcbprop)
{
// Success
goto Exit;
}
}
pprop = NULL;
StatusCorruption(pstatus, "LoadProperty: property offset");
goto Exit;
}
}
// ----
// Exit
// ----
Exit:
return(pprop);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::GetValue
//
// Synopsis: return a pointer to the specified property value
//
// Arguments: [propid] -- property id of property
// [pcbprop] -- pointer to returned property length
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: pointer to property value
//---------------------------------------------------------------------------
SERIALIZEDPROPERTYVALUE const *
CPropertySetStream::GetValue(
IN PROPID propid,
OUT ULONG *pcbprop,
OUT NTSTATUS *pstatus)
{
SERIALIZEDPROPERTYVALUE *pprop = NULL;
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "GetValue: deleted");
goto Exit;
}
if (propid == PID_DICTIONARY)
{
DebugTrace(0, DEBTRACE_ERROR, ("GetValue: PID_DICTIONARY\n"));
StatusInvalidParameter(pstatus, "GetValue: PID_DICTIONARY");
goto Exit;
}
pprop = NULL;
if (propid == PID_SECURITY || propid == PID_MODIFY_TIME)
{
SERIALIZEDPROPERTYVALUE aprop[2];
PROPASSERT(sizeof(aprop) >= sizeof(ULONG) + sizeof(LONGLONG));
aprop[0].dwType = PropByteSwap( (DWORD) VT_EMPTY );
if (propid == PID_SECURITY)
{
if (_MSTM(QuerySecurity)((ULONG *) aprop[0].rgb))
{
aprop[0].dwType = PropByteSwap( (DWORD) VT_UI4 );
*pcbprop = 2 * sizeof(ULONG);
}
}
else // (propid == PID_MODIFY_TIME)
{
LONGLONG ll;
if (_MSTM(QueryModifyTime)(&ll))
{
*(LONGLONG UNALIGNED *) aprop[0].rgb = PropByteSwap( ll );
aprop[0].dwType = PropByteSwap( (DWORD) VT_FILETIME );
*pcbprop = sizeof(ULONG) + sizeof(LONGLONG);
}
}
if( VT_EMPTY != PropByteSwap(aprop[0].dwType) )
{
pprop = (SERIALIZEDPROPERTYVALUE *)
newk(mtPropSetStream, NULL) BYTE[*pcbprop];
if (pprop == NULL)
{
StatusNoMemory(pstatus, "GetValue: no memory");
goto Exit;
}
DebugTrace(0, Dbg, (
"GetValue: pprop=%lx, vt=%lx, cb=%lx\n",
pprop,
PropByteSwap( aprop[0].dwType ),
*pcbprop));
RtlCopyMemory(pprop, aprop, *pcbprop);
}
} // if (propid == PID_SECURITY || propid == PID_MODIFY_TIME)
else
{
pprop = _LoadProperty(propid, pcbprop, pstatus);
if( !NT_SUCCESS(*pstatus) )
{
pprop = NULL;
goto Exit;
}
} // if (propid == PID_SECURITY || propid == PID_MODIFY_TIME) ... else
#if DBGPROP
if (pprop == NULL)
{
DebugTrace(0, Dbg, ("GetValue: propid=%lx pprop=NULL\n", propid));
}
else
{
char valbuf[CB_VALUESTRING];
DebugTrace(0, Dbg, (
"GetValue: propid=%lx pprop=%l" szX " vt=%hx val=%s cb=%l" szX "\n",
propid,
_MapAddressToOffset(pprop),
PropByteSwap( pprop->dwType ),
ValueToString(pprop, *pcbprop, valbuf),
*pcbprop));
}
#endif
// ----
// Exit
// ----
Exit:
return(pprop);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::SetValue
//
// Synopsis: update/add/delete property values
//
// Arguments: [cprop] -- count of properties
// [pip] -- pointer to indirect indexes
// [avar] -- PROPVARIANT array
// [apinfo] -- PROPERTY_INFORMATION array
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//
// Note: All the properties in the apinfo array can be classified into
// one of the following categories:
//
// PROPOP_IGNORE:
// No change. Deleting a non-existent property or the same
// propid appears later in the apinfo array.
//
// PROPOP_DELETE:
// Deletion of an existing property. Remove the
// PROPERTYIDOFFSET structure from the property offset array and
// and pack the remaining entries. Delete the property value
// and pack remaining property values
//
// PROPOP_INSERT:
// Addition of a new property. Insert the new PROPERTYIDOFFSET
// structure at the end of the property offset array. Insert
// the new property value at the end of the section/stream.
//
// PROPOP_MOVE:
// A property whose value needs to be updated out of place
// because of a change in the property value's size. A property
// value is moved to the end of the section if it grows or
// shrinks across a DWORD boundary. The existing value is
// removed from the section and the remaining values are packed.
// Then, the new value is inserted at the end of the section.
// The idea here is to move variable length properties that are
// being changed frequently as near as possible to the end of
// the stream to minimize the cost of maintaining a packed set
// of property values. Note that the property offset structure
// is not moved around in the array.
//
// PROPOP_UPDATE:
// A property whose value can be updated in-place. The property
// value's new size is equal to the old size. There are a
// number of variant types that take up a fixed amount of space,
// e.g., VT_I4, VT_R8 etc. This would also apply to any
// variable length property that is updated without changing
// the property value's size across a DWORD boundary.
//
// Note that while the property offset array is itself packed out
// of necessity (to conform to the spec), there may be unused
// entries at the end of the array that are not compressed out of
// the stream when properties are deleted. The unused space is
// detected and reused when new properties are added later.
//---------------------------------------------------------------------------
#define CCHUNKSTACK (sizeof(ascnkStack)/sizeof(ascnkStack[0]))
VOID
CPropertySetStream::SetValue(
IN ULONG cprop,
OPTIONAL IN OUT INDIRECTPROPERTY **ppip,
IN PROPVARIANT const avar[],
IN PROPERTY_INFORMATION *apinfo,
OUT NTSTATUS *pstatus)
{
// ------
// Locals
// ------
CStreamChunk ascnkStack[6];
ULONG cpoReserve;
ULONG cDelete, cInsert, cMove, cUpdate;
#if DBGPROP
ULONG cIgnore;
char valbuf[CB_VALUESTRING];
KERNELSELECT(
char valbuf2[CB_VALUESTRING],
char varbuf[CB_VARIANT_TO_STRING]);
#endif
ULONG iprop;
ULONG cbstm;
LONG cbChange, cbInsertMove;
PROPERTYSECTIONHEADER *psh;
int cIndirect = 0;
CStreamChunk *pscnk0 = NULL;
ULONG cbNewSize;
// ----------
// Initialize
// ----------
*pstatus = STATUS_SUCCESS;
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
// Worst case, we will need chunks for:
// - the possible growth of the PROPERTYIDOFFSET array,
// - one for EACH property that is being modified,
// - and one chunk to mark the end of the property data.
CStreamChunkList scl(
1 + cprop + 1,
1 + cprop + 1 <= CCHUNKSTACK? ascnkStack : NULL);
PROPASSERT(_IsMapped());
// Validate that this property set can be written to.
if (IsReadOnlyPropertySet(_Flags, _State))
{
StatusAccessDenied(pstatus, "SetValue: deleted or read-only");
goto Exit;
}
// Mark the propset dirty.
_SetModified();
psh = _GetSectionHeader();
cpoReserve = 0;
cDelete = cInsert = cMove = cUpdate = 0;
#if DBGPROP
cIgnore = 0;
#endif
cbInsertMove = cbChange = 0;
pscnk0 = scl.GetFreeChunk(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
pscnk0->oOld = 0;
pscnk0->cbChange = 0;
PROPASSERT(pscnk0 == scl.GetChunk(0));
cbstm = _oSection + psh->cbSection + _cbTail;
PROPASSERT( cbstm <= _MSTM(GetSize)(pstatus) && NT_SUCCESS(*pstatus) );
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
// ------------------------
// Classify all the updates
// ------------------------
// Each update gets classified as ignore, delete, insert, move,
// or update.
// Lookup the old value for each of the properties specified and
// compute the current size.
for (iprop = 0; iprop < cprop; iprop++)
{
ULONG i;
ULONG cbPropOld;
SERIALIZEDPROPERTYVALUE const *pprop = NULL;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
if (IsReadOnlyPropid(apinfo[iprop].pid))
{
if (cprop != 1 ||
apinfo[0].pid != PID_DICTIONARY ||
apinfo[0].cbprop == 0 ||
( avar == NULL || avar[0].vt != VT_DICTIONARY )
)
{
DebugTrace(0, DEBTRACE_ERROR, (
"SetValue: read-only propid=%lx\n",
apinfo[iprop].pid));
StatusInvalidParameter(pstatus, "SetValue: read-only PROPID");
goto Exit;
}
}
if (apinfo[iprop].pid != PID_ILLEGAL)
{
pprop = _LoadProperty(apinfo[iprop].pid, &cbPropOld, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
}
// If this propid appears later in the array, ignore it.
for (i = iprop + 1; i < cprop; i++)
{
if (apinfo[i].pid == apinfo[iprop].pid)
{
#if DBGPROP
cIgnore++;
#endif
apinfo[iprop].operation = PROPOP_IGNORE;
break;
}
}
// If this propid appears only once or if it's the last instance,
// load the property and compute its size.
if (i == cprop)
{
VOID *pvStart = NULL;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
if (pprop != NULL)
{
ULONG cbPropNew;
PROPASSERT(apinfo[iprop].pid != PID_DICTIONARY);
if (apinfo[iprop].cbprop == 0)
{
DebugTrace(0, Dbg, (
"SetValue: Deleting propid=%lx oOld=%l" szX
" vt=%hx val=%s cb=%l" szX "\n",
apinfo[iprop].pid,
_MapAddressToOffset(pprop),
PropByteSwap( pprop->dwType ),
ValueToString(pprop, cbPropOld, valbuf),
cbPropOld));
cbPropNew = 0;
cDelete++;
apinfo[iprop].operation = PROPOP_DELETE;
}
else
{
DebugTrace(0, Dbg, (
"SetValue: Modifying propid=%lx oOld=%l" szX
" vt=%hx-->%hx cb=%l" szX "-->%l" szX " val=%s-->%s\n",
apinfo[iprop].pid,
_MapAddressToOffset(pprop),
PropByteSwap( pprop->dwType ),
KERNELSELECT(
PropByteSwap( apinfo[iprop].pprop->dwType ),
avar[iprop].vt),
cbPropOld,
apinfo[iprop].cbprop,
ValueToString(pprop, cbPropOld, valbuf),
KERNELSELECT(
ValueToString(
apinfo[iprop].pprop,
apinfo[iprop].cbprop,
valbuf2),
VariantToString(
avar[iprop],
varbuf,
sizeof( varbuf )))));
cbPropNew = apinfo[iprop].cbprop;
if (cbPropOld != cbPropNew)
{
cbInsertMove += apinfo[iprop].cbprop;
cMove++;
apinfo[iprop].operation = PROPOP_MOVE;
}
else
{
cUpdate++;
apinfo[iprop].operation = PROPOP_UPDATE;
}
}
if (apinfo[iprop].operation != PROPOP_UPDATE)
{
// Update the list of chunks that need to be adjusted
CStreamChunk *pscnk = scl.GetFreeChunk(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
pscnk->oOld = _MapAddressToOffset(pprop);
pscnk->cbChange = - (LONG) cbPropOld;
}
// Stream size change
cbChange += cbPropNew - cbPropOld;
}
// Delete non-existent property:
else if (apinfo[iprop].cbprop == 0)
{
#if DBGPROP
cIgnore++;
#endif
PROPASSERT(apinfo[iprop].pid != PID_DICTIONARY);
apinfo[iprop].operation = PROPOP_IGNORE;
}
// Insert new property:
else
{
DebugTrace(0, Dbg, (
"SetValue: Inserting new propid=%lx vt=%hx "
"cbNew=%l" szX " val=%s\n",
apinfo[iprop].pid,
KERNELSELECT(
PropByteSwap( apinfo[iprop].pprop->dwType ),
avar[iprop].vt),
apinfo[iprop].cbprop,
KERNELSELECT(
ValueToString(
apinfo[iprop].pprop,
apinfo[iprop].cbprop,
valbuf),
VariantToString(
avar[iprop],
varbuf,
sizeof( varbuf )))));
PROPASSERT(apinfo[iprop].pid != PID_ILLEGAL);
cbInsertMove += apinfo[iprop].cbprop;
cbChange += apinfo[iprop].cbprop;
cInsert++;
apinfo[iprop].operation = PROPOP_INSERT;
}
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
// In order to delete any old stream or storage type properties
// we count the properties which used to be VT_STREAM etc.
// Also, we count the properties which are to be created as
// streams or storages.
if (ppip != NULL && apinfo[iprop].operation != PROPOP_IGNORE)
{
if ((pprop != NULL && IsIndirectVarType(PropByteSwap(pprop->dwType)))
||
(avar != NULL && IsIndirectVarType(avar[iprop].vt)))
{
cIndirect++;
}
}
} // if (i == cprop)
} // for (iprop = 0; iprop < cprop; iprop++)
// We're now done classifying each of the properties to be added.
// ------------------------------------------------------------
// Put existing, to-be-overwritten, indirect properties in ppip
// ------------------------------------------------------------
// Did the caller give us an INDIRECTPROPERTY buffer, and are
// there indirect properties being added and/or overwritten?
if (ppip != NULL && cIndirect != 0)
{
// allocate needed space for indirect information
INDIRECTPROPERTY *pipUse;
if (cprop != 1)
{
pipUse = *ppip = new INDIRECTPROPERTY[cIndirect + 1];
if (*ppip == NULL)
{
// BUGBUG check no leaks
StatusNoMemory(pstatus, "SetValue: Indirect Name");
goto Exit;
}
RtlZeroMemory( pipUse, sizeof(INDIRECTPROPERTY) * (cIndirect + 1) );
pipUse[cIndirect].Index = MAXULONG;
}
else
{
pipUse = (INDIRECTPROPERTY *) ppip;
RtlZeroMemory( pipUse, sizeof(*pipUse) );
}
int iIndirect = 0;
for (iprop = 0; iprop < cprop; iprop++)
{
ULONG cbPropOld;
SERIALIZEDPROPERTYVALUE const *pprop = NULL;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
if (apinfo[iprop].operation == PROPOP_IGNORE ||
apinfo[iprop].pid == PID_ILLEGAL)
{
continue;
}
pprop = _LoadProperty(apinfo[iprop].pid, &cbPropOld, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
if (pprop != NULL && IsIndirectVarType(PropByteSwap(pprop->dwType)))
{
CHAR *pszName;
BOOL fAlloc = FALSE; // Did we alloc pszName?
// we are overwriting an indirect property value
PROPASSERT(cbPropOld >= 2 * sizeof(ULONG));
cbPropOld -= 2 * sizeof(ULONG);
pszName = (CHAR *) Add2ConstPtr(pprop->rgb, sizeof(ULONG));
// Do we need to convert the name between Ansi & Unicode?
if (_CodePage != CP_WINUNICODE // Ansi propset
&&
OLECHAR_IS_UNICODE) // Unicode OLE APIs
{
// Convert the indirect reference to Unicode
RtlpConvertToUnicode(
pszName,
cbPropOld, //BUGBUG: Could be byte-granular?
_CodePage,
(WCHAR **) &pszName,
&cbPropOld,
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
fAlloc = TRUE; // We need to free pszName
}
else
if (_CodePage == CP_WINUNICODE // Unicode propset
&&
!OLECHAR_IS_UNICODE ) // Ansi OLE APIs
{
// Byte-Swap the Unicode indirect reference value
WCHAR *pwszBuffer = NULL;
// After this call, the appropriately swapped name will be
// in pszName. If an alloc was required, pszBuffer will point
// to the new buffer (we must free this).
PBSInPlaceAlloc( (WCHAR**) &pszName, &pwszBuffer, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Convert the reference value to Ansi.
RtlpConvertToMultiByte(
(WCHAR*) pszName,
cbPropOld,
CP_ACP,
(CHAR **) &pszName,
&cbPropOld,
pstatus);
delete( pwszBuffer );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
fAlloc = TRUE; // We need to free pszName
}
pipUse[iIndirect].poszName =
new OLECHAR[cbPropOld/sizeof(OLECHAR)];
if (pipUse[iIndirect].poszName == NULL)
{
StatusNoMemory(pstatus, "SetValue: Indirect Name2");
goto Exit;
}
RtlCopyMemory(
pipUse[iIndirect].poszName,
pszName,
cbPropOld);
// Is byte-swapping necessary? It is if the property set
// codepage is Unicode, and if OLECHARs are also Unicode.
// If both are Ansi, then no byte-swapping is ever necessary,
// and if one is Ansi and the other is Unicode, then we
// already byte-swapped above during the conversion.
if (_CodePage == CP_WINUNICODE
&&
OLECHAR_IS_UNICODE )
{
// Convert from propset-endian to system-endian.
PBSBuffer( pipUse[iIndirect].poszName, cbPropOld, sizeof(OLECHAR) );
}
// Clean up pszName
if( fAlloc )
{
// In the Unicode/MBCS conversions, we did an alloc which
// we must free now.
PROPASSERT(pszName != NULL);
PROPASSERT(
pszName !=
(CHAR *) Add2ConstPtr(pprop->rgb, sizeof(ULONG)));
delete [] pszName;
}
} // if (pprop != NULL && IsIndirectVarType(PropByteSwap(pprop->dwType)))
else
if (avar == NULL || !IsIndirectVarType(avar[iprop].vt))
{
// Neither the property being overwritten, nor the property
// being written is indirect, so we can continue on to
// check the next property (skipping the pipUse updating
// below).
continue;
}
// If we get here, we know that either this property is
// an indirect type, or it's overwriting an indirect property.
// We established pipUse[].pszName above, so we just need to
// insert the index and move on.
pipUse[iIndirect].Index = iprop;
iIndirect++;
} // for (iprop = 0; iprop < cprop; iprop++)
PROPASSERT(iIndirect == cIndirect);
} // if (ppip != NULL && cIndirect != 0)
DebugTrace(0, Dbg, ("SetValue: Total Props %l" szX "\n", cprop));
DebugTrace(0, Dbg, (
"SetValue: Delete=%l" szX " Insert=%l" szX " Move=%l" szX
" Update=%l" szX " Ignore=%l" szX "\n",
cDelete,
cInsert,
cMove,
cUpdate,
cIgnore));
PROPASSERT(cDelete + cInsert + cMove + cUpdate + cIgnore == cprop);
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
// If we need to grow the property offset array, detect any unused
// entries at the end of the array that are available for reuse.
// and adjust the size difference to reflect the reuse.
if (cInsert > cDelete)
{
ULONG cpoReuse, cpoExpand;
cpoExpand = cInsert - cDelete;
cpoReuse = _CountFreePropertyOffsets(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (cpoReuse > cpoExpand)
{
cpoReuse = cpoExpand;
}
cpoExpand -= cpoReuse;
// If adding a small number of new entries, but not reusing any old
// ones, add 10% more reserved entries (but only up to 10 more) to
// avoid having to continually grow the property offset array for
// clients that insist on adding a few properties at a time.
// We don't do this for the User-Defined property set, however,
// because older apps assume that the dictionary immediately follows
// the last entry in the PID/Offset array.
if (cpoExpand >= 1 && cpoExpand <= 2 && cpoReuse == 0
&&
!(_State & CPSS_USERDEFINEDPROPERTIES)
)
{
cpoReserve = 1 + min(psh->cProperties, 90)/10;
cpoExpand += cpoReserve;
}
DebugTrace(0, Dbg, (
"SetValue: Reusing %l" szX " offsets, Expanding %l" szX
" offsets\n",
cpoReuse,
cpoExpand));
pscnk0->oOld = CB_PROPERTYSECTIONHEADER +
(psh->cProperties + cpoReuse) * CB_PROPERTYIDOFFSET;
pscnk0->cbChange = cpoExpand * CB_PROPERTYIDOFFSET;
cbChange += cpoExpand * CB_PROPERTYIDOFFSET;
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
} // if (cInsert > cDelete)
// Do we instead need to *shrink* the PID/Offset array?
// If so, don't shrink any more than necessary. We'll
// leave up to min(10%,10) blank entries.
// Also, if this is the User-Defined property set,
// there can never be any unused entries (for compatibility
// with older apps), so we do a complete shrink.
else if (cInsert < cDelete)
{
ULONG cpoRemove = 0;
ULONG cpoDelta = cDelete - cInsert;
// How many blank entries do we already have?
ULONG cpoCurBlankEntries = _CountFreePropertyOffsets( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if( _State & CPSS_USERDEFINEDPROPERTIES )
{
cpoRemove = cpoDelta;
}
else
{
// How many blank entries can we have?
ULONG cpoMaxBlankEntries;
cpoMaxBlankEntries = 1 + min(psh->cProperties - cpoDelta, 90)/10;
// If, after deleting the properties, we'd have too many,
// remove only enough to get us down to the max allowable.
if( cpoCurBlankEntries + cpoDelta
>
cpoMaxBlankEntries
)
{
cpoRemove = cpoCurBlankEntries + cpoDelta - cpoMaxBlankEntries;
}
} // if( _State & CPSS_USERDEFINEDPROPERTIES )
// Should we remove any PID/Offset entries?
if( cpoRemove > 0 )
{
// Start removing at cpoRemove entries from the end of the PID/Offset array
pscnk0->oOld = CB_PROPERTYSECTIONHEADER
+
(psh->cProperties + cpoCurBlankEntries - cpoRemove)
*
CB_PROPERTYIDOFFSET;
// Remove the bytes of the cpoRemove entries.
pscnk0->cbChange = - (LONG) (cpoRemove * CB_PROPERTYIDOFFSET );
// Adjust the size of the section equivalently.
cbChange += pscnk0->cbChange;
}
} // else if (cInsert < cDelete)
PROPASSERT(
cbstm + cbChange >=
_oSection + CB_PROPERTYSECTIONHEADER +
(psh->cProperties + cInsert - cDelete) * CB_PROPERTYIDOFFSET +
_cbTail);
// If we need to grow the stream, do it now.
if (cbChange > 0)
{
if (cbstm + cbChange > CBMAXPROPSETSTREAM)
{
StatusDiskFull(pstatus, "SetValue: 256k limit");
goto Exit;
}
DebugTrace(0, Dbg, (
"SetSize(%x) SetValue grow\n",
cbstm + cbChange));
_MSTM(SetSize)(cbstm + cbChange, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// reload all pointers into mapped image:
psh = _GetSectionHeader();
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
// If there's another section after this one, move it back to the
// end of the stream now.
if (_cbTail != 0)
{
VOID *pvSrc = _MapAbsOffsetToAddress(cbstm - _cbTail);
PropMoveMemory(
"SetValue(_cbTail:grow)",
psh,
Add2Ptr(pvSrc, cbChange),
pvSrc,
_cbTail);
}
} // if (cbChange > 0)
// From this point on, the operation should succeed.
// If necessary, the stream has already been grown.
if (cDelete + cInsert + cMove != 0)
{
// Delete and compact property offsets in the section header.
if (cDelete + cMove != 0)
{
_DeleteMovePropertyOffsets(apinfo, cprop, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
psh->cProperties -= cDelete;
}
PROPASSERT(cbstm == _oSection + psh->cbSection + _cbTail);
// Use the last chunk to mark the section end, and sort the chunks
// in ascending order by start offset.
CStreamChunk *pscnk = scl.GetFreeChunk(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
pscnk->oOld = psh->cbSection;
pscnk->cbChange = 0;
scl.SortByStartAddress();
// If we're reducing the number of properties, we may be shrinking
// the PID/Offset array. So, update that array now, since
// we may remove some bytes at the end of it when we compact
// the stream.
if( cDelete > cInsert )
{
_UpdatePropertyOffsets( &scl, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// Compact the Stream following the directions in the
// chunk list.
_CompactStream(&scl);
// If the number of properties is holding constant or increasing,
// we can update the PID/Offset array now (because _CompactStream
// allocated any necessary space for us).
if( cDelete <= cInsert )
{
_UpdatePropertyOffsets( &scl, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// Set the new section size to include the deleted and inserted
// property offsets, and the deleted property values.
psh->cbSection += cbChange;
// Insert new property offsets at the end of the array.
if (cInsert + cMove != 0)
{
_InsertMovePropertyOffsets(
apinfo,
cprop,
psh->cbSection - cbInsertMove,
cpoReserve,
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
psh->cProperties += cInsert;
}
PROPASSERT(cbstm + cbChange == _oSection + psh->cbSection + _cbTail);
if (_cbTail != 0)
{
// There's another section after this one; if we're shrinking
// the stream, move it up to the new end of the stream now.
if (cbChange < 0)
{
VOID *pvSrc = _MapAbsOffsetToAddress(cbstm - _cbTail);
PropMoveMemory(
"SetValue(_cbTail:shrink)",
psh,
Add2Ptr(pvSrc, cbChange),
pvSrc,
_cbTail);
}
_PatchSectionOffsets(cbChange);
}
} // if (cDelete + cInsert + cMove != 0)
// Copy the new values.
// NOTE: It might seem unnecessary to delay the in-place updates until
// this for loop. We do not perform the in-place updates while
// classifying the changes because unmapping, remapping and changing
// the size required for handling other updates can fail. In the event
// of such a failure, the update would not be atomic. By delaying the
// in-place updates, we provide some degree of atomicity.
if (cInsert + cUpdate + cMove != 0)
{
BOOLEAN fDocSummaryInfo = FALSE;
if ((_State &
(CPSS_USERDEFINEDPROPERTIES | CPSS_DOCUMENTSUMMARYINFO)) ==
CPSS_DOCUMENTSUMMARYINFO)
{
fDocSummaryInfo = TRUE;
}
for (iprop = 0; iprop < cprop; iprop++)
{
// Find property in the offset array and copy in the new value.
if (apinfo[iprop].operation == PROPOP_INSERT ||
apinfo[iprop].operation == PROPOP_UPDATE ||
apinfo[iprop].operation == PROPOP_MOVE)
{
SERIALIZEDPROPERTYVALUE *pprop;
ULONG cbprop;
ULONG cIndirectProps;
PROPID propid = apinfo[iprop].pid;
pprop = _LoadProperty(propid, NULL, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(pprop != NULL);
// Special case for SetPropertyNames dictionary creation:
if (propid == PID_DICTIONARY)
{
PROPASSERT(CB_SERIALIZEDPROPERTYVALUE == CB_DICTIONARY);
PROPASSERT(apinfo[iprop].cbprop == CB_SERIALIZEDPROPERTYVALUE);
PROPASSERT(avar[iprop].vt == VT_DICTIONARY);
((DICTIONARY *) pprop)->cEntries = 0;
} // if (propid == PID_DICTIONARY)
else
{
// In User, serialize the PROPVARIANT in avar
// directly into the mapped stream. We ask for the
// count of indirect properties, even though we don't
// use it, in order to tell the routine that we
// can handle them. Any handling that is actually
// required must be handled by our caller.
cbprop = apinfo[iprop].cbprop;
pprop = RtlConvertVariantToPropertyNoEH(
&avar[iprop],
_CodePage,
pprop,
&cbprop,
apinfo[iprop].pid,
FALSE,
&cIndirectProps,
pstatus
);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(pprop != NULL);
PROPASSERT(cbprop == DwordAlign(cbprop));
PROPASSERT(cbprop == apinfo[iprop].cbprop);
// If writing a DocumentSummaryInformation property
// for which an alignment hack is provided, hack it now.
if (fDocSummaryInfo && _CodePage != CP_WINUNICODE)
{
// The two vectors in the DocSumInfo property set
// (if Ansi) are un-packed, but we'll adjust the lengths
// so that if a propset reader expects them to be packed,
// it will still work. E.g., a one character string will
// have a length of 4, with padding of NULL characters.
ULONG cbpropT;
if (propid == PID_HEADINGPAIR)
{
_FixHeadingPairVector(
PATCHOP_ALIGNLENGTHS,
pprop,
&cbpropT);
}
else
if (propid == PID_DOCPARTS)
{
_FixDocPartsVector(
PATCHOP_ALIGNLENGTHS,
pprop,
&cbpropT);
}
}
DebugTrace(0, Dbg, (
"SetValue:Insert: pph=%x pprop=%x cb=%3l" szX
" vt=%4x val=%s o=%x oEnd=%x\n",
_pph,
pprop,
apinfo[iprop].cbprop,
PropByteSwap(pprop->dwType),
ValueToString(pprop, apinfo[iprop].cbprop, valbuf),
_MapAddressToOffset(pprop),
_MapAddressToOffset(pprop) + apinfo[iprop].cbprop));
} // if (propid == PID_DICTIONARY) ... else
} // if (apinfo[iprop].operation == PROPOP_INSERT || ...
} // for (iprop = 0; iprop < cprop; iprop++)
} // if (cInsert + cUpdate + cMove != 0)
// If we need to shrink the stream or if we are cleaning up after a
// previous shrink that failed, do it last.
cbNewSize = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (cbNewSize != cbstm + cbChange)
{
DebugTrace(0, Dbg, (
"SetSize(%x) SetValue shrink\n",
cbstm + cbChange));
_MSTM(SetSize)(cbstm + cbChange, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// ----
// Exit
// ----
Exit:
scl.Delete();
if( !NT_SUCCESS(*pstatus) )
{
if( ppip != NULL && 0 != cIndirect )
{
INDIRECTPROPERTY *pipUse;
pipUse = (1 == cprop) ? (INDIRECTPROPERTY*) ppip
: *ppip;
for (int iFree = 0; iFree < cIndirect; iFree++)
{
delete [] pipUse[iFree].poszName;
}
if (cprop != 1)
{
delete [] pipUse;
*ppip = NULL;
}
}
} // if( !NT_SUCCESS(*pstatus) )
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_CountFreePropertyOffsets, private
//
// Synopsis: counts available (free) property offsets at and of array
//
// Arguments: [pstatus] -- pointer to NTSTATUS code
//
// Returns: count of available property offsets at and of array
//+--------------------------------------------------------------------------
ULONG
CPropertySetStream::_CountFreePropertyOffsets(OUT NTSTATUS *pstatus)
{
PROPERTYIDOFFSET *ppo, *ppoMax;
PROPERTYSECTIONHEADER const *psh;
ULONG oMin = MAXULONG;
ULONG oEnd;
ULONG cFree = 0;
psh = _LoadPropertyOffsetPointers(&ppo, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (psh != NULL)
{
for ( ; ppo < ppoMax; ppo++)
{
if (oMin > ppo->dwOffset)
{
oMin = ppo->dwOffset;
}
}
}
if (oMin == MAXULONG)
{
goto Exit;
}
PROPASSERT(psh != NULL);
oEnd = CB_PROPERTYSECTIONHEADER + psh->cProperties * CB_PROPERTYIDOFFSET;
PROPASSERT(oEnd <= oMin);
cFree = (oMin - oEnd)/CB_PROPERTYIDOFFSET;
Exit:
return( cFree );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_DeleteMovePropertyOffsets, private
//
// Synopsis: updates the offsets following the changes to the stream
//
// Arguments: [apinfo] -- array of property information
// [cprop] -- number of properties
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_DeleteMovePropertyOffsets(
IN PROPERTY_INFORMATION const *apinfo,
IN ULONG cprop,
OUT NTSTATUS *pstatus)
{
ULONG i;
ULONG cDelete;
PROPERTYSECTIONHEADER const *psh;
PROPERTYIDOFFSET *ppo, *ppoBase, *ppoMax;
psh = _LoadPropertyOffsetPointers(&ppoBase, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(psh != NULL);
// Remove the deleted properties
DebugTrace(0, Dbg, ("Marking deleted/moved property offsets\n"));
cDelete = 0;
for (i = 0; i < cprop; i++)
{
if (apinfo[i].operation == PROPOP_DELETE ||
apinfo[i].operation == PROPOP_MOVE)
{
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
if (ppo->propid == apinfo[i].pid)
{
DebugTrace(0, Dbg, (
"%sing propid=%lx oOld=%l" szX "\n",
apinfo[i].operation == PROPOP_DELETE? "Delet" : "Mov",
ppo->propid,
ppo->dwOffset));
if (apinfo[i].operation == PROPOP_DELETE)
{
cDelete++;
ppo->dwOffset = MAXULONG;
}
else
{
ppo->dwOffset = 0;
}
break;
}
}
}
}
// scan once and compact the property offset array.
if (cDelete > 0)
{
PROPERTYIDOFFSET *ppoDst = ppoBase;
DebugTrace(0, Dbg, ("Compacting %l" szX " deleted props\n", cDelete));
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
if (ppo->dwOffset != MAXULONG)
{
if (ppo > ppoDst)
{
*ppoDst = *ppo;
}
DebugTrace(0, Dbg, (
"%sing propid=%lx oOld=%l" szX "\n",
ppo > ppoDst? "Compact" : "Preserv",
ppo->propid,
ppo->dwOffset));
ppoDst++;
}
}
PROPASSERT(cDelete == (ULONG) (ppoMax - ppoDst));
DebugTrace(0, Dbg, ("Zeroing %l" szX " entries\n", cDelete));
RtlZeroMemory(ppoDst, (BYTE *) ppoMax - (BYTE *) ppoDst);
}
// ----
// Exit
// ----
Exit:
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_UpdatePropertyOffsets, private
//
// Synopsis: update property offsets in section header
//
// Arguments: [pscl] -- list of chunks in stream that were changed
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_UpdatePropertyOffsets(
IN CStreamChunkList const *pscl,
OUT NTSTATUS *pstatus)
{
PROPERTYSECTIONHEADER const *psh;
PROPERTYIDOFFSET *ppo, *ppoMax;
// Update the offsets for the existing properties.
DebugTrace(0, Dbg, ("Updating existing property offsets\n"));
psh = _LoadPropertyOffsetPointers(&ppo, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(psh != NULL);
for ( ; ppo < ppoMax; ppo++)
{
if (ppo->dwOffset != 0)
{
#if DBGPROP
ULONG oOld = ppo->dwOffset;
#endif
ppo->dwOffset = _GetNewOffset(pscl, ppo->dwOffset);
DebugTrace(0, Dbg, (
"UpdatePropertyOffsets: propid=%lx offset=%l" szX "-->%l" szX"\n",
ppo->propid,
oOld,
ppo->dwOffset));
}
}
Exit:
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_InsertMovePropertyOffsets, private
//
// Synopsis: updates the offsets following the changes to the stream
//
// Arguments: [apinfo] -- array of property information
// [cprop] -- number of properties
// [oInsert] -- offset in section for new properties
// [cpoReserve] -- newly reserved property offsets to zero
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_InsertMovePropertyOffsets(
IN PROPERTY_INFORMATION const *apinfo,
IN ULONG cprop,
IN ULONG oInsert,
IN ULONG cpoReserve,
OUT NTSTATUS *pstatus)
{
ULONG i;
PROPERTYSECTIONHEADER const *psh;
PROPERTYIDOFFSET *ppo, *ppoBase, *ppoMax;
*pstatus = STATUS_SUCCESS;
psh = _LoadPropertyOffsetPointers(&ppoBase, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(psh != NULL);
// Insert the new property offsets at the end.
DebugTrace(0, Dbg, ("Inserting/Moving/Zeroing property offsets\n"));
for (i = 0; i < cprop; i++)
{
if (apinfo[i].operation == PROPOP_INSERT)
{
ppo = ppoMax++;
ppo->propid = apinfo[i].pid;
}
else if (apinfo[i].operation == PROPOP_MOVE)
{
for (ppo = ppoBase; ppo < ppoMax; ppo++)
{
if (ppo->propid == apinfo[i].pid)
{
PROPASSERT(ppo->dwOffset == 0);
break;
}
}
}
else
{
continue;
}
PROPASSERT(ppo->propid == apinfo[i].pid);
ppo->dwOffset = oInsert;
oInsert += apinfo[i].cbprop;
DebugTrace(0, Dbg, (
"%sing propid=%lx offset=%l" szX " size=%l" szX "\n",
apinfo[i].operation == PROPOP_INSERT? "Insert" : "Mov",
ppo->propid,
ppo->dwOffset,
apinfo[i].cbprop));
}
DebugTrace(0, Dbg, (
"Zeroing %x property offsets o=%l" szX " size=%l" szX "\n",
cpoReserve,
_MapAddressToOffset(ppoMax),
cpoReserve * CB_PROPERTYIDOFFSET));
RtlZeroMemory(ppoMax, cpoReserve * CB_PROPERTYIDOFFSET);
// ----
// Exit
// ----
Exit:
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_CompactStream, private
//
// Synopsis: compact all of the property stream chunks
//
// Arguments: [pscl] -- list of chunks in stream that were changed
//
// Returns: None
//
// Note:
// Each chunk structure represents a contiguous range of the stream to be
// completely removed or added. A terminating chunk is appended to
// transparently mark the end of the data stream. The unmodified data
// after each chunk (except the last one) must be preserved and compacted
// as necessary. Chunk structures contain section-relative offsets.
//
// Invariants:
// - Only the first chunk can represent an insertion; subsequent chunks
// always represent deletions.
// - The first chunk can never cause a deletion, but it might not cause
// any change at all.
// - The last chunk is a dummy used to mark the end of the stream.
//
// Algorithm:
// In the optimal case without insertions, each chunk's trailing data can
// be moved ahead (compacted) individually in ascending chunk index order.
// If the first chunk represents an insertion, then some consecutive
// number of data blocks must be moved back (in *descending* chunk index
// order) to make room for the insertion.
//
// Walk the chunk array to find the first point where the accumulated size
// change is less than or equal to zero.
//
// After (possibly) compacting a single range in descending chunk index
// order, compact all remaining chunks in ascending chunk index order.
//
// Example: the first chunk inserts 18 bytes for new property offsets
// (apo'[]), and the second two delete 10 bytes each (chnk1 & chnk2).
// There are four chunks in the array, and three blocks of data to move.
//
// oOld cbChange | AccumulatedChange oNew
// chunk[0]: 38 +18 | +18 38 (apo'[])
// chunk[1]: 48 -10 | +8 50 (chnk1)
// chunk[2]: 6c -10 | -8 74 (chnk2)
// chunk[3]: 8c 0 | -8 84 (end)
//
// Data blocks are moved in the following sequence to avoid overlap:
// DstOff SrcOff cbMove | Chunk#
// 60 58 14 | 1 chnk1/data2: descending pass (Dst > Src)
// 50 38 10 | 0 apo'[]/data1: descending pass (Dst > Src)
// 74 7c 10 | 2 chnk2/data3: ascending pass (Dst < Src)
//
// SrcOff = oOld - min(cbChange, 0)
// DstOff = SrcOff + AccumulatedChange
// cbMove = chnk[i+1].oOld - SrcOff
//
// Before compacting:
// 0 38 48 58 6c 7c 8c
// | | | | | | |
// V V 10 V -10 V 14 V -10 V 10 V
// +----+-------+----+-------+-------+-------+----------+-------+-------+
// | ph | afo[] | sh | apo[] | data1 | chnk1 | data2 | chnk2 | data3 |
// +----+-------+----+-------+-------+-------+----------+-------+-------+
//
// After compacting:
// 0 38 50 60 74 84
// | | | | | |
// V V +18 V 10 V 14 V 10 V
// +----+-------+----+-------+-----------+-------+----------+-------+
// | ph | afo[] | sh | apo[] | apo'[] | data1 | data2 | data3 |
// +----+-------+----+-------+-----------+-------+----------+-------+
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_CompactStream(
IN CStreamChunkList const *pscl)
{
ULONG i, iMax, iAscend;
LONG cbChangeTotal, cbChangeTotalAscend;
CStreamChunk const *pscnk;
// Subtract one to avoid operating on the terminating chunk directly.
iMax = pscl->Count() - 1;
// If the first chunk does not indicate an insertion, the first for loop is
// exited with i == 0.
//
// If the first chunk represents an insertion, either i == iMax or i itself
// indexes the first chunk that can be compacted normally (in ascending
// chunk index order). In either case, we compact in descending chunk
// index order starting just below i.
DebugTrace(0, Dbg, (
"CompactStream: %l" szX " chunks @%lx\n",
pscl->Count(),
pscl->GetChunk(0)));
cbChangeTotal = 0;
for (i = 0; i < iMax; i++)
{
pscnk = pscl->GetChunk(i);
PROPASSERT(i == 0 || pscnk->cbChange < 0);
if (cbChangeTotal + pscnk->cbChange <= 0)
{
break;
}
cbChangeTotal += pscnk->cbChange;
}
iAscend = i; // save ascending order start
cbChangeTotalAscend = cbChangeTotal;
DebugTrace(0, Dbg, ("CompactStream: iAscend=%l" szX "\n", iAscend));
// First compact range in descending chunk index order if necessary:
while (i-- > 0)
{
pscnk = pscl->GetChunk(i);
PROPASSERT(i == 0 || pscnk->cbChange < 0);
DebugTrace(0, Dbg, ("CompactStream: descend: i=%l" szX "\n", i));
#if DBGPROP
pscl->AssertCbChangeTotal(pscnk, cbChangeTotal);
#endif
_CompactChunk(pscnk, cbChangeTotal, pscl->GetChunk(i + 1)->oOld);
cbChangeTotal -= pscnk->cbChange;
}
// Compact any remaining chunks in ascending chunk index order.
cbChangeTotal = cbChangeTotalAscend;
for (i = iAscend; i < iMax; i++)
{
pscnk = pscl->GetChunk(i);
PROPASSERT(i == 0 || pscnk->cbChange < 0);
DebugTrace(0, Dbg, ("CompactStream: ascend: i=%l" szX "\n", i));
cbChangeTotal += pscnk->cbChange;
#if DBGPROP
pscl->AssertCbChangeTotal(pscnk, cbChangeTotal);
#endif
_CompactChunk(pscnk, cbChangeTotal, pscl->GetChunk(i + 1)->oOld);
}
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_CompactChunk, private
//
// Synopsis: Compact the data block following one chunk
//
// Arguments: [pscnk] -- pointer to stream chunk
// [cbChangeTotal] -- Bias for this chunk
// [oOldNext] -- offset of next chunk
//
// Returns: None
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_CompactChunk(
IN CStreamChunk const *pscnk,
IN LONG cbChangeTotal,
IN ULONG oOldNext)
{
LONG cbDelta = cbChangeTotal + min(pscnk->cbChange, 0); // BUGBUG: temp
DebugTrace(0, Dbg, (
"CompactChunk(pscnk->oOld=%l" szX ", pscnk->cbChange=%s%l" szX "\n"
" cbChangeTotal=%s%l" szX
", cbDelta=%s%l" szX // BUGBUG: temp
", oOldNext=%l" szX ")\n",
pscnk->oOld,
pscnk->cbChange < 0? "-" : "",
pscnk->cbChange < 0? -pscnk->cbChange : pscnk->cbChange,
cbChangeTotal < 0? "-" : "",
cbChangeTotal < 0? -cbChangeTotal : cbChangeTotal,
cbDelta < 0? "-" : "", // BUGBUG: temp
cbDelta < 0? -cbDelta : cbDelta, // BUGBUG: temp
oOldNext));
if (cbChangeTotal != 0)
{
ULONG oSrc;
VOID const *pvSrc;
oSrc = pscnk->oOld - min(pscnk->cbChange, 0);
pvSrc = _MapOffsetToAddress(oSrc);
PropMoveMemory(
"CompactChunk",
_GetSectionHeader(),
(VOID *) Add2ConstPtr(pvSrc, cbChangeTotal),
pvSrc,
oOldNext - oSrc);
}
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_PatchSectionOffsets, private
//
// Synopsis: patch section offsets after moving data around
//
// Arguments: [cbChange] -- size delta
//
// Returns: none
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::_PatchSectionOffsets(
LONG cbChange)
{
ULONG i;
for (i = 0; i < _cSection; i++)
{
FORMATIDOFFSET *pfo;
pfo = _GetFormatidOffset(i);
if (pfo->dwOffset > _oSection)
{
DebugTrace(0, DEBTRACE_PROPPATCH, (
"PatchSectionOffsets(%x): %l" szX " + %l" szX " --> %l" szX "\n",
i,
pfo->dwOffset,
cbChange,
pfo->dwOffset + cbChange));
pfo->dwOffset += cbChange;
}
}
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_GetNewOffset, private
//
// Synopsis: gets the new address
//
// Arguments: [pscl] -- list of stream chunks that were changed
// [oOld] -- old offset
//
// Returns: new offset
//+--------------------------------------------------------------------------
ULONG
CPropertySetStream::_GetNewOffset(
IN CStreamChunkList const *pscl,
IN ULONG oOld) const
{
// The Chunk list is sorted by start offsets. Locate the chunk to which
// the old offset belongs, then use the total change undergone by the chunk
// to compute the new offset.
ULONG i;
ULONG iMax = pscl->Count();
LONG cbChangeTotal = 0;
for (i = 0; i < iMax; i++)
{
CStreamChunk const *pscnk = pscl->GetChunk(i);
if (pscnk->oOld > oOld)
{
break;
}
cbChangeTotal += pscnk->cbChange;
if (pscnk->oOld == oOld)
{
PROPASSERT(pscnk->cbChange >= 0);
break;
}
}
PROPASSERT(i < iMax);
DebugTrace(0, Dbg, (
"GetNewOffset: %l" szX " + %l" szX " --> %l" szX "\n",
oOld,
cbChangeTotal,
oOld + cbChangeTotal));
return(oOld + cbChangeTotal);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_ComputeMinimumSize, private
//
// Synopsis: computes the minimum possible size of a property set stream
//
// Arguments: [cbstm] -- actual stream size
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: computed highest offset in use
//+--------------------------------------------------------------------------
ULONG
CPropertySetStream::_ComputeMinimumSize(
IN ULONG cbstm,
OUT NTSTATUS *pstatus)
{
ULONG oMax = 0;
*pstatus = STATUS_SUCCESS;
// Don't assume *any* class variables except _pph are loaded yet!
if (_pph != NULL && cbstm != 0)
{
ULONG cbMin;
ULONG i;
ULONG cSection;
cSection = 1;
cbMin = 0;
if (_HasPropHeader())
{
cSection = _pph->reserved;
cbMin = CB_PROPERTYSETHEADER + cSection * CB_FORMATIDOFFSET;
}
oMax = cbMin;
// Add the size of each section
for (i = 0; i < cSection; i++)
{
ULONG oSectionEnd;
PROPERTYSECTIONHEADER const *psh = _GetSectionHeader(i, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
cbMin += psh->cbSection;
oSectionEnd = _MapAddressToAbsOffset(psh) + psh->cbSection;
if (oMax < oSectionEnd)
{
oMax = oSectionEnd;
}
}
// The following can't be asserted, because there may be
// a correctable reason why cbstm < oMax at in the Open path
// (see the Excel 5.0a problem in _FixSummaryInformation)
//PROPASSERT(oMax <= cbstm);
PROPASSERT(cbMin <= oMax);
}
// ----
// Exit
// ----
Exit:
// oMax may have been set before an error occurred.
// In this case, set it to zero.
if( !NT_SUCCESS(*pstatus) )
oMax = 0;
return(oMax);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_DictionaryLength
//
// Synopsis: compute length of property set dictionary
//
// Arguments: [pdy] -- pointer to dictionary
// [cbbuf] -- maximum length of accessible memory at pdy
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: Byte-granular count of bytes in dictionary
//+--------------------------------------------------------------------------
ULONG
CPropertySetStream::_DictionaryLength(
IN DICTIONARY const *pdy,
IN ULONG cbbuf,
OUT NTSTATUS *pstatus ) const
{
ENTRY UNALIGNED const *pent;
ULONG cbDict = CB_DICTIONARY;
ULONG i;
*pstatus = STATUS_SUCCESS;
for (i = 0, pent = &pdy->rgEntry[0];
i < PropByteSwap( pdy->cEntries );
i++, pent = _NextDictionaryEntry( pent ))
{
if (cbbuf < cbDict + CB_ENTRY ||
cbbuf < _DictionaryEntryLength( pent ))
{
StatusCorruption(pstatus, "_DictionaryLength: section size");
goto Exit;
}
cbDict += _DictionaryEntryLength( pent );
}
// ----
// Exit
// ----
Exit:
return(cbDict);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_PropertyNameLength
//
// Synopsis: compute length (*byte* count) of a property name
//
// Arguments: [pvName] -- property name, in the codepage of
// the property set
// [pcbName] -- pointer to returned byte length of name
//
// Returns: TRUE if name length is valid; else FALSE
//
// Note: The OLE 2.0 format mandates that the null be included as part
// of the length of the name that is stored in the dictionary.
// If the propset uses the Unicode code page, names contain
// WCHARs, otherwise they contain CHARs. In either case, the
// length is a byte count that includes the L'\0' or '\0'.
//
// Also note that this routine does not concern itself with
// the byte-order of the name: for Ansi names, it's irrelevant;
// and for Unicode names, L'\0' == PropByteSwap(L'\0').
//
//+--------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_PropertyNameLength(
IN VOID const *pvName,
OUT ULONG *pcbName) const
{
ULONG cch;
if (_CodePage == CP_WINUNICODE)
{
cch = Prop_wcslen((WCHAR const *) pvName) + 1;
*pcbName = cch * sizeof(WCHAR);
}
else
{
*pcbName = cch = strlen((char const *) pvName) + 1;
}
return(cch > 1 && cch <= CCH_MAXPROPNAMESZ );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_ComparePropertyNames
//
// Synopsis: Compare two property names.
//
// Pre-Conditions:
// The property names are in the codepage of the
// property set.
//
// Arguments: [pvName1] -- property name 1
// [pvName2] -- property name 2
// [fSameByteOrder]-- TRUE: names are both big- or little-endian
// FALSE: 2nd name is wrong endian
// [cbName] -- byte count of name length
// (includes terminator)
//
// Returns: TRUE if names are equal
//+--------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::_ComparePropertyNames(
IN VOID const *pvName1,
IN VOID const *pvName2,
IN BOOL fSameByteOrder,
IN ULONG cbName) const
{
// BUGBUG: When the property code is moved to OLE32,
// remove awcByteSwap, and compare unicode strings one
// character at a time, using CharLowerW.
WCHAR awcByteSwap[ CCH_MAXPROPNAMESZ ];
#ifdef WINNT
if (_CodePage == CP_WINUNICODE)
{
// On big-endian systems, when the second name
// is byte-swapped, we'll byte-swap it into a new
// buffer to use for the comparisson.
#ifdef BIGENDIAN
if( !fSameByteOrder )
{
ULONG ulIndex = 0;
PROPASSERT( (WCHAR) L'\0' == ByteSwap( (WCHAR) L'\0' ));
do
{
awcByteSwap[ ulIndex ] = ByteSwap( ((WCHAR*)pvName2)[ ulIndex ] );
} while( awcByteSwap[ulIndex++] != L'\0' );
}
#endif // BIGENDIAN
UNICODE_STRING s1, s2;
s1.Buffer = (WCHAR *) pvName1;
#ifdef BIGENDIAN
s2.Buffer = fSameByteOrder ? (WCHAR *) pvName2
: awcByteSwap;
#else
s2.Buffer = (WCHAR *) pvName2;
#endif
s1.Length =
s1.MaximumLength =
s2.Length =
s2.MaximumLength = (USHORT) (cbName - sizeof(WCHAR));
return(RtlEqualUnicodeString(&s1, &s2, TRUE));
} // if (_CodePage == CP_WINUNICODE)
else
{
STRING s1, s2;
s1.Buffer = (CHAR *) pvName1;
s2.Buffer = (CHAR *) pvName2;
s1.Length =
s1.MaximumLength =
s2.Length =
s2.MaximumLength = (USHORT) (cbName - sizeof(CHAR));
return(RtlEqualString(&s1, &s2, TRUE));
} // if (_CodePage == CP_WINUNICODE) ... else
#else // !WINNT
if (_CodePage == CP_WINUNICODE)
{
// On big-endian systems, when the second name
// is byte-swapped, we'll byte-swap it into a new
// buffer to use for the comparisson.
#ifdef BIGENDIAN
if( !fSameByteOrder )
{
ULONG ulIndex = 0;
PROPASSERT( L'\0' == ByteSwap( (WCHAR) L'\0' ));
do
{
awcByteSwap[ ulIndex ] = ByteSwap( ((WCHAR*)pvName2)[ ulIndex ] );
} while( awcByteSwap[ulIndex++] != L'\0' );
}
#endif // BIGENDIAN
// Nashville has no Rtl routines:
return(Prop_wcsnicmp(
(WCHAR const *) pvName1,
#ifdef BIGENDIAN
fSameByteOrder ? (WCHAR const *) pvName2
: awcByteSwap,
#else
(WCHAR const *) pvName2,
#endif
cbName / sizeof(WCHAR) ) == 0);
} // if (_CodePage == CP_WINUNICODE)
else
{
// Nashville has no Rtl routines:
return(_strnicmp(
(char const *) pvName1,
(char const *) pvName2,
cbName) == 0);
} // if (_CodePage == CP_WINUNICODE) ... else
#endif // !WINNT
}
//+---------------------------------------------------------------------------
// Function: CPropertySetStream::DuplicatePropertyName
//
// Synopsis: Duplicate an OLECHAR property name string
//
// Arguments: [poszName] -- input string
// [cbName] -- count of bytes in string (includes null)
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: pointer to new string
//---------------------------------------------------------------------------
OLECHAR *
CPropertySetStream::DuplicatePropertyName(
IN OLECHAR const *poszName,
IN ULONG cbName,
OUT NTSTATUS *pstatus) const
{
OLECHAR *poc = NULL;
*pstatus = STATUS_SUCCESS;
PROPASSERT(cbName != 0);
PROPASSERT(IsOLECHARString(poszName, cbName));
if (cbName != 0)
{
PROPASSERT((ocslen(poszName) + 1) * sizeof(OLECHAR) == cbName);
poc = (OLECHAR *) _pma->Allocate(cbName);
if (NULL == poc)
{
StatusNoMemory(pstatus, "DuplicatePropertyName: no memory");
goto Exit;
}
RtlCopyMemory(poc, poszName, cbName);
}
// ----
// Exit
// ----
Exit:
return(poc);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::QueryPropid
//
// Synopsis: translate a property name to a property id using the
// dictionary on the property stream
//
// Arguments: [poszName] -- name of property
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: propid for property if found; PID_ILLEGAL if not found
//---------------------------------------------------------------------------
PROPID
CPropertySetStream::QueryPropid(
IN OLECHAR const *poszName,
OUT NTSTATUS *pstatus )
{
// ------
// Locals
// ------
ULONG cbname;
DICTIONARY const *pdy;
ENTRY UNALIGNED const *pent;
ULONG cdye;
ULONG cbDict; // BYTE granular size!
VOID const *pvName = NULL;
PROPID propid = PID_ILLEGAL;
// ----------
// Initialize
// ----------
*pstatus = STATUS_SUCCESS;
PROPASSERT(_HasPropHeader());
PROPASSERT(_IsMapped());
PROPASSERT( IsOLECHARString( poszName, MAXULONG ));
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
// Make sure this isn't a UD propset which has been deleted.
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "QueryPropid: deleted");
goto Exit;
}
// Put the name into pvName, converting it if
// necessary to the code-page of the property set.
pvName = poszName;
if (_CodePage == CP_WINUNICODE // Property set is Unicode
&&
!OLECHAR_IS_UNICODE ) // Name is in Ansi
{
// Convert the caller-provided name from the system
// Ansi codepage to Unicode.
ULONG cb = 0;
pvName = NULL;
_OLECHARToWideChar( poszName, (ULONG)-1, CP_ACP,
(WCHAR**)&pvName, &cb, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
else
if (_CodePage != CP_WINUNICODE // Property set is Ansi
&&
OLECHAR_IS_UNICODE ) // Name is in Unicode
{
// Convert the caller-provided name from Unicode
// to the propset's Ansi codepage.
ULONG cb = 0;
pvName = NULL;
_OLECHARToMultiByte( poszName, (ULONG)-1, _CodePage,
(CHAR**)&pvName, &cb, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// How long is this property name (in bytes)?
if (!_PropertyNameLength(pvName, &cbname))
{
// The length is invalid.
StatusInvalidParameter(pstatus, "QueryPropid: name length");
goto Exit;
}
// Get a pointer to the raw dictionary.
pdy = (DICTIONARY const *) _LoadProperty(PID_DICTIONARY, &cbDict, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Is there a dictionary?
if (pdy != NULL)
{
// Yes - there is a dictionary.
PROPERTYSECTIONHEADER const *psh = _GetSectionHeader();
// Search the dictionary for an entry name matching
// pvName.
for (cdye = PropByteSwap(pdy->cEntries), pent = &pdy->rgEntry[0];
cdye > 0;
cdye--, pent = _NextDictionaryEntry( pent ))
{
// Is the length of this dictionary entry valid?
if ( _MapAddressToOffset(pent) + _DictionaryEntryLength( pent )
> psh->cbSection
)
{
StatusCorruption(pstatus, "QueryPropid: section size");
goto Exit;
}
// If the byte-length matches what we're looking for,
// and the names compare successfully, then we're done.
if ( CCh2CB(PropByteSwap( pent->cch )) == cbname
&&
_ComparePropertyNames(pvName, pent->sz,
FALSE, // pvName, pent->sz could be dif Endians
cbname)
)
{
propid = PropByteSwap( pent->propid );
break;
}
} // for (cdye = PropByteSwap(pdy->cEntries), pent = &pdy->rgEntry[0]; ...
PROPASSERT(cdye > 0 || pent == Add2ConstPtr(pdy, cbDict));
} // if (pdy != NULL)
// ----
// Exit
// ----
Exit:
// If we did an alloc on the name to munge it,
// delete that buffer now. We must cast pvName
// as a non-const in order for the compiler to accept
// the free call.
if( pvName != poszName )
_pma->Free( (VOID*) pvName );
return(propid);
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::QueryPropertyNameBuf
//
// Synopsis: convert from a property id to a property name using the
// dictionary in the property set, and putting the result
// in a caller-provided buffer.
//
// Arguments: [propid] -- property id to look up
// [aocName] -- output buffer
// [pcbName] -- IN: length of aocName;
// OUT: actual length of name
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: TRUE if name is found in dictionary
//---------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::QueryPropertyNameBuf(
IN PROPID propid,
OUT OLECHAR *aocName,
IN OUT ULONG *pcbName,
OUT NTSTATUS *pstatus)
{
BOOL fFound = FALSE;
DICTIONARY const *pdy;
ULONG cbDict; // BYTE granular size!
*pstatus = STATUS_SUCCESS;
PROPASSERT(_IsMapped());
PROPASSERT(propid != PID_DICTIONARY);
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
PROPASSERT(NULL != aocName);
// Ensure that this isn't an already-deleted UD propset.
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "QueryPropertyNameBuf: deleted");
goto Exit;
}
// Get a pointer to the raw dictionary.
pdy = (DICTIONARY const *) _LoadProperty(PID_DICTIONARY, &cbDict, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Is there a dictionary?
if (pdy != NULL)
{
// Yes - the dictionary was found.
ULONG cdye;
ENTRY UNALIGNED const *pent;
VOID const *pvDictEnd;
// Get pointers to the first and last+1 entries.
pent = pdy->rgEntry;
pvDictEnd = Add2ConstPtr(pdy, cbDict);
// Scan through the dictionary, searching for 'propid'.
for (cdye = PropByteSwap(pdy->cEntries), pent = &pdy->rgEntry[0];
cdye > 0;
cdye--, pent = _NextDictionaryEntry( pent ))
{
// Make sure this entry doesn't go off the end of the
// dictionary.
if (Add2ConstPtr(pent, _DictionaryEntryLength( pent )) > pvDictEnd)
{
StatusCorruption(pstatus, "QueryPropertyNameBuf: dictionary entry size");
goto Exit;
}
// Is this the PID we're looking for?
if (PropByteSwap(pent->propid) == propid)
{
// Yes. Copy or convert the name into the caller's
// buffer.
// Is a Unicode to Ansi conversion required?
if (_CodePage == CP_WINUNICODE // Property set is Unicode
&&
!OLECHAR_IS_UNICODE ) // Caller's buffer is Ansi
{
WCHAR *pwszName = (WCHAR*) pent->sz;
// If we're byte-swapping, alloc a new buffer, swap
// pwszName into it (getting the string into system-endian
// byte-order), and point pwszName to the result.
PBSInPlaceAlloc( &pwszName, NULL, pstatus );
if( !NT_SUCCESS( *pstatus )) goto Exit;
// Convert the Unicode string in the property set
// to the system default codepage.
_WideCharToOLECHAR( pwszName, (ULONG)-1, CP_ACP,
&aocName, pcbName, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If we allocated a buffer for byte-swapping,
// we don't need it any longer.
if( pwszName != (WCHAR*) pent->sz )
delete pwszName;
}
// Or is an Ansi to Unicode conversion required?
else
if (_CodePage != CP_WINUNICODE // Property set is Ansi
&&
OLECHAR_IS_UNICODE ) // Caller's buffer is Unicode
{
// Convert the Ansi property set name from the
// propset's codepage to Unicode.
_MultiByteToOLECHAR( (CHAR*) pent->sz, (ULONG)-1, _CodePage,
&aocName, pcbName, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// Otherwise, no conversion of the name is required
else
{
// Copy the name into the caller's buffer.
RtlCopyMemory(aocName, pent->sz,
min(CCh2CB(PropByteSwap(pent->cch)), *pcbName));
// BUGBUG: Shouldn't we terminate the string if we truncated it?
// Swap the name to the correct endian
// (This will do nothing if OLECHARs are CHARs).
PBSBuffer( aocName,
min( CCh2CB(PropByteSwap( pent->cch )), *pcbName),
sizeof(OLECHAR) );
// Tell the caller the actual size of the name.
*pcbName = CCh2CB( PropByteSwap( pent->cch ));
}
PROPASSERT( NULL == aocName || IsOLECHARString( aocName, MAXULONG ));
fFound = TRUE;
break;
} // if (pent->propid == propid)
} // for (cdye = pdy->cEntries, pent = &pdy->rgEntry[0]; ...
PROPASSERT(fFound || pent == pvDictEnd);
} // if (pdy != NULL)
// ----
// Exit
// ----
Exit:
return( fFound );
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::QueryPropertyNames
//
// Synopsis: query dictionary names for the passed property ids.
//
// Arguments: [cprop] -- count of name to propid mappings to change
// [apid] -- array of property ids
// [aposz] -- array of pointers to the new names
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: TRUE if the property exists.
//+--------------------------------------------------------------------------
BOOLEAN
CPropertySetStream::QueryPropertyNames(
IN ULONG cprop,
IN PROPID const *apid,
OUT OLECHAR *aposz[],
OUT NTSTATUS *pstatus)
{
DICTIONARY const *pdy;
ULONG cbDict; // BYTE granular size!
ULONG iprop;
BOOLEAN fFound = FALSE;
*pstatus = STATUS_SUCCESS;
PROPASSERT(_HasPropHeader());
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
// If this is an attempt to access a deleted UD
// propset, exit now.
if (_State & CPSS_USERDEFINEDDELETED)
{
StatusAccessDenied(pstatus, "QueryPropertyNames: deleted");
goto Exit;
}
// Validate the input array of strings.
for (iprop = 0; iprop < cprop; iprop++)
{
PROPASSERT(aposz[iprop] == NULL);
}
// Get a pointer to the beginning of the dictionary
pdy = (DICTIONARY const *) _LoadProperty(PID_DICTIONARY, &cbDict, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Did we get a dictionary?
if (pdy != NULL)
{
// Yes, the dictionary exists.
ULONG i;
ENTRY UNALIGNED const *pent;
// Iterate through each of the entries in the dictionary.
for (i = 0, pent = &pdy->rgEntry[0];
i < PropByteSwap( pdy->cEntries );
i++, pent = _NextDictionaryEntry( pent ))
{
// Scan the input array of PIDs to see if one matches
// this dictionary entry.
for (iprop = 0; iprop < cprop; iprop++)
{
if( PropByteSwap(pent->propid) == apid[iprop] )
{
// We've found an entry in the dictionary
// that's in the input PID array. Put the property's
// name in the caller-provided array (aposz).
PROPASSERT(aposz[iprop] == NULL);
// Do we need to convert to Unicode?
if (_CodePage != CP_WINUNICODE // Ansi property set
&&
OLECHAR_IS_UNICODE) // Unicode property names
{
ULONG cbName = 0;
_MultiByteToOLECHAR( (CHAR*)pent->sz, (ULONG)-1, _CodePage,
&aposz[iprop], &cbName, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// Or, do we need to convert to Ansi?
else
if (_CodePage == CP_WINUNICODE // Unicode property set
&&
!OLECHAR_IS_UNICODE) // Ansi property names
{
ULONG cbName = 0;
WCHAR *pwszName = (WCHAR*) pent->sz;
// If necessary, swap the Unicode name in the dictionary,
// pointing pwszName to the new, byte-swapped, buffer.
PBSInPlaceAlloc( &pwszName, NULL, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// And convert to Ansi.
_WideCharToOLECHAR( pwszName, (ULONG)-1, CP_ACP,
&aposz[iprop], &cbName, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If we alloced a new buffer for byte-swapping,
// we can free it now.
if( pwszName != (WCHAR*) pent->sz )
delete pwszName;
} // else if (_CodePage == CP_WINUNICODE ...
// Otherwise, both the propset & in-memory property names
// are both Unicode or both Ansi, so we can just do
// an alloc & copy.
else
{
aposz[iprop] = DuplicatePropertyName(
(OLECHAR *) pent->sz,
CCh2CB( PropByteSwap( pent->cch )),
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// If necessary, swap the in-memory copy.
PBSBuffer( (OLECHAR*) aposz[iprop],
CCh2CB( PropByteSwap( pent->cch )),
sizeof(OLECHAR) );
} // if (_CodePage != CP_WINUNICODE ... else if ... else
PROPASSERT( IsOLECHARString( aposz[iprop], MAXULONG ));
fFound = TRUE;
} // if (pent->propid == apid[iprop])
} // for (iprop = 0; iprop < cprop; iprop++)
} // for (i = 0, pent = &pdy->rgEntry[0];
PROPASSERT(pent == Add2ConstPtr(pdy, cbDict));
} // if (pdy != NULL)
// ----
// Exit
// ----
Exit:
// If the property name simply didn't exist, return
// a special success code.
if( !fFound && NT_SUCCESS(*pstatus) )
*pstatus = STATUS_BUFFER_ALL_ZEROS;
return( fFound );
} // CPropertySetStream::QueryPropertyNames
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::SetPropertyNames
//
// Synopsis: changes dictionary entry names associated with property ids.
//
// Arguments: [cprop] -- count of name to propid mappings to change
// [apid] -- array of property ids
// [aposz] -- array of pointers to the new names
// [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//
// Note: Attempting to set a property name for a property that does not
// exist in the property set is not an error.
//
// Attempting to set a property name or property id that would
// result in a duplicate name or property id causes the existing
// entry(ies) to be replaced.
//+--------------------------------------------------------------------------
VOID
CPropertySetStream::SetPropertyNames(
IN ULONG cprop,
IN const PROPID *apid,
IN OPTIONAL OLECHAR const * const aposz[],
OUT NTSTATUS *pstatus )
{
// ------
// Locals
// ------
DICTIONARY *pdy = NULL;
ULONG cbDictOld = 0; // Byte granular Old dictionary size
ULONG cbDictOldD = 0; // Dword granular Old dictionary size
ULONG iprop = 0;
ULONG i = 0;
ULONG cDel, cAdd;
LONG cbDel, cbAdd; // Byte granular sizes
LONG cbChangeD; // Dword granular size
ENTRY UNALIGNED *pent;
BOOLEAN fDupPropid = FALSE;
BOOLEAN fDupName = FALSE;
BOOLEAN fDeleteByName = FALSE;
BOOLEAN fDeleteAll = FALSE;
VOID **appvNames = NULL;
ULONG cbstm;
ULONG oDictionary;
ULONG cbTail;
ULONG cbNewSize;
// ----------
// Initialize
// ----------
*pstatus = STATUS_SUCCESS;
DebugTrace(0, Dbg, (
"SetPropertyNames(cprop=%x, apid=%x, apwsz=%x)\n",
cprop,
apid,
aposz));
PROPASSERT(_HasPropHeader());
PROPASSERT(_IsMapped());
PROPASSERT(PROPSET_BYTEORDER == _pph->wByteOrder);
// --------
// Validate
// --------
// Verify that this propset is modifiable.
if (IsReadOnlyPropertySet(_Flags, _State))
{
StatusAccessDenied(pstatus, "SetPropertyNames: deleted or read-only");
goto Exit;
}
// Verify that none of the names are illegally long.
if (aposz != NULL)
{
for (iprop = 0; iprop < cprop; iprop++)
{
PROPASSERT( IsOLECHARString( aposz[iprop], MAXULONG ));
if (ocslen( aposz[iprop] ) > CCH_MAXPROPNAME)
{
StatusInvalidParameter(pstatus, "SetPropertyNames: Name is too long" );
goto Exit;
}
}
} // if (apwsz != NULL)
// ----------------------------------------------------------------
// If necessary, convert each of the caller-provided names:
// to Unicode (if the property set is Unicode) or Ansi (otherwise).
// ----------------------------------------------------------------
// In the end, appvNames will have the names in the same codepage
// as the property set.
appvNames = (VOID **) aposz;
if (appvNames != NULL)
{
// Do we need to convert the caller's names to Ansi?
if( _CodePage != CP_WINUNICODE // Property set is Ansi
&&
OLECHAR_IS_UNICODE ) // Caller's names are Unicode
{
// Allocate an array of cprop string pointers.
appvNames = (VOID **) newk(mtPropSetStream, NULL) char *[cprop];
if (appvNames == NULL)
{
StatusNoMemory(pstatus, "SetpropertyNames: Ansi Name Pointers");
goto Exit;
}
RtlZeroMemory(appvNames, cprop * sizeof(appvNames[0]));
// Convert the caller-provided property names from Unicode to
// the property set's codepage.
for (iprop = 0; iprop < cprop; iprop++)
{
ULONG cb = 0;
appvNames[iprop] = NULL;
_OLECHARToMultiByte( (OLECHAR*) aposz[iprop], (ULONG)-1, _CodePage,
(CHAR**) &appvNames[iprop], &cb, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
} // if( _CodePage != CP_WINUNICODE ...
// Or, do we need to convert the caller's names to Unicode?
if( _CodePage == CP_WINUNICODE // Property set is Unicode
&&
!OLECHAR_IS_UNICODE ) // Caller's names are Ansi
{
// Allocate an array of cprop string pointers.
appvNames = (VOID **) newk(mtPropSetStream, NULL) WCHAR *[cprop];
if (appvNames == NULL)
{
StatusNoMemory(pstatus, "SetpropertyNames: Unicode Name Pointers");
goto Exit;
}
RtlZeroMemory(appvNames, cprop * sizeof(appvNames[0]));
// Convert the caller-provided property names from the system
// default Ansi codepage to Unicode.
for (iprop = 0; iprop < cprop; iprop++)
{
ULONG cb = 0;
appvNames[iprop] = NULL;
_OLECHARToWideChar( (OLECHAR*) aposz[iprop], (ULONG)-1, CP_ACP,
(WCHAR**) &appvNames[iprop], &cb, pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
} // if( _CodePage == CP_WINUNICODE )
} // if (appvNames != NULL)
// -----------------------------------------------------
// Compute total size of entries to be modified or added
// -----------------------------------------------------
cbAdd = 0;
cAdd = 0;
for (iprop = 0; iprop < cprop; iprop++)
{
// Did the caller give us no array of names? If so,
// it means that the name for this PID is to be deleted.
if (appvNames == NULL)
{
// If the PID is for the dictionary, then it must be the
// only entry in apid, and it indicates that we're going to
// delete all the names in the dictionary.
if (apid[iprop] == PID_DICTIONARY)
{
if (cprop != 1)
{
StatusInvalidParameter(pstatus, "SetPropertyNames: DeleteAll parms");
goto Exit;
}
fDeleteAll = TRUE;
}
}
// Otherwise, we're setting a new name for this PID.
else
{
ULONG cbname;
// Validate the caller-provided length.
if (!_PropertyNameLength(appvNames[iprop], &cbname))
{
StatusInvalidParameter(pstatus, "SetPropertyNames: name length");
goto Exit;
}
// See if this propid or name appears later in the array.
for (i = iprop + 1; i < cprop; i++)
{
ULONG cbname2;
if (apid[i] == apid[iprop])
{
fDupPropid = TRUE;
break;
}
_PropertyNameLength(appvNames[i], &cbname2);
if (cbname == cbname2 &&
_ComparePropertyNames(
appvNames[iprop],
appvNames[i],
TRUE, // Both names are in the same byte-order
cbname))
{
fDupName = TRUE;
break;
}
}
// If this propid appears only once or if it's the last instance,
// count it. If the property set is Unicode, include DWORD padding.
if (i == cprop)
{
DebugTrace(0, Dbg, (
_CodePage == CP_WINUNICODE?
"Adding New Entry: propid=%lx L'%ws'\n" :
"Adding New Entry: propid=%lx '%s'\n",
apid[iprop],
appvNames[iprop]));
cAdd++;
cbAdd += CB_ENTRY + cbname;
if( _CodePage == CP_WINUNICODE )
{
cbAdd = DwordAlign( cbAdd );
}
}
}
}
PROPASSERT( _CodePage == CP_WINUNICODE ? IsDwordAligned( cbAdd ) : TRUE );
// ---------------------------------------------
// Get the dictionary, creating it if necessary.
// ---------------------------------------------
_SetModified();
for (i = 0; ; i++)
{
PROPERTY_INFORMATION pinfo;
PROPVARIANT var;
pdy = (DICTIONARY *) _LoadProperty(PID_DICTIONARY, &cbDictOld, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (pdy != NULL)
{
break;
}
PROPASSERT(i == 0);
if (cprop == 0 || appvNames == NULL)
{
// no dictionary and we are deleting or doing nothing -- return
goto Exit;
}
// create dictionary if it doesn't exist
DebugTrace(0, Dbg, ("Creating empty dictionary\n"));
PROPASSERT(CB_SERIALIZEDPROPERTYVALUE == CB_DICTIONARY);
pinfo.cbprop = CB_SERIALIZEDPROPERTYVALUE;
pinfo.pid = PID_DICTIONARY;
var.vt = VT_DICTIONARY;
SetValue(1, NULL, &var, &pinfo, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
Validate(pstatus); // Make sure dictionary was properly created
if( !NT_SUCCESS(*pstatus) ) goto Exit;
DebugTrace(0, Dbg, ("Created empty dictionary\n"));
} // for (i = 0; ; i++)
// ----------------------------------------------------------------
// Compute total size of existing entries to be modified or deleted
// ----------------------------------------------------------------
// Walk the dictionary looking for entries which are referenced
// in the caller's 'apid' array or 'appvNames' array.
cbDel = 0;
cDel = 0;
for (i = 0, pent = &pdy->rgEntry[0];
i < PropByteSwap( pdy->cEntries );
i++, pent = _NextDictionaryEntry( pent ))
{
DebugTrace(0, Dbg, (
_CodePage == CP_WINUNICODE?
"Dictionary Entry @%lx: propid=%lx L'%ws'\n" :
"Dictionary Entry @%lx: propid=%lx '%s'\n",
pent,
PropByteSwap( pent->propid ),
pent->sz ));
// For this dictionary entry, walk the caller's
// 'apid' and 'appvNames' arrays, looking for a match.
for (iprop = 0; iprop < cprop; iprop++)
{
// If we get to the bottom of this 'for' loop,
// then we know that we've found an entry to delete.
// If fDeleteAll, or the PID in apid matches this
// dictionary entry, then we can fall to the bottom.
// Otherwise, the following 'if' block checks the
// name in 'appvNames' against this dictionary entry.
if (!fDeleteAll
&&
apid[iprop] != PropByteSwap( pent->propid ))
{
// The caller's PID didn't match this dictionary entry,
// does the name?
ULONG cbname;
// If we have no names from the caller, then we obviously
// don't have a match, and we can continue on to check this
// dictionary entry against the next of the caller's PIDs.
if (appvNames == NULL)
{
continue;
}
// Or, if this name from the caller doesn't match this
// dictionary entry, we again can continue on to check
// the next of the caller's properties.
_PropertyNameLength(appvNames[iprop], &cbname);
if (cbname != CCh2CB( PropByteSwap( pent->cch ))
||
!_ComparePropertyNames(
appvNames[iprop],
pent->sz,
FALSE, // appvNames & pent->sz may be dif endians.
cbname)
)
{
continue;
}
fDeleteByName = TRUE;
} // if (!fDeleteAll ...
// If we reach this point, we're going to delete this entry
// in the dictionary. So update cDel & cbDel.
DebugTrace(0, Dbg, (
"Deleting Entry (%s) @%lx: propid=%lx\n",
fDeleteAll? "DeleteAll" :
apid[iprop] == PropByteSwap(pent->propid)
? "replace by propid"
: "replace by name",
pent,
PropByteSwap( pent->propid )));
cDel++;
cbDel += _DictionaryEntryLength( pent );
// We don't need to continue through the caller's arrays,
// we can move on to the next dictionary entry.
break;
} // for (iprop = 0; iprop < cprop; iprop++)
} // for (i = 0, pent = &pdy->rgEntry[0]; ...
PROPASSERT(pent == Add2Ptr(pdy, cbDictOld));
PROPASSERT( _CodePage == CP_WINUNICODE ? IsDwordAligned( cbDel ) : TRUE );
cbDictOldD = DwordAlign(cbDictOld);
cbChangeD = DwordAlign(cbDictOld + cbAdd - cbDel) - cbDictOldD;
cbstm = _oSection + _GetSectionHeader()->cbSection + _cbTail;
oDictionary = _MapAddressToOffset(pdy);
cbTail;
cbTail = cbstm - (_oSection + oDictionary + cbDictOldD);
// --------------------------------------------------------
// Before we change anything, grow the stream if necessary.
// --------------------------------------------------------
if (cbChangeD > 0)
{
DebugTrace(0, Dbg, (
"SetSize(%x) dictionary grow\n", cbstm + cbChangeD));
if (cbstm + cbChangeD > CBMAXPROPSETSTREAM)
{
StatusDiskFull(pstatus, "SetPropertyNames: 256k limit");
goto Exit;
}
_MSTM(SetSize)(cbstm + cbChangeD, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// reload all pointers into mapped image:
pdy = (DICTIONARY *) _MapOffsetToAddress(oDictionary);
// move everything after the dictionary back by cbChangeD bytes.
PropMoveMemory(
"SetPropertyNames:TailBack",
_GetSectionHeader(),
Add2Ptr(pdy, cbDictOldD + cbChangeD),
Add2Ptr(pdy, cbDictOldD),
cbTail);
}
// -------------------------------------------------------------------
// Walk through the existing dictionary and compact unmodified entries
// toward the front. New and modified entries will be appended later.
// -------------------------------------------------------------------
VOID *pvSrc;
VOID *pvDst;
ULONG cbCopy;
pvDst = pvSrc = pent = &pdy->rgEntry[0];
cbCopy = 0;
if (!fDeleteAll)
{
ULONG cb;
for (i = 0; i < PropByteSwap(pdy->cEntries); i++)
{
for (iprop = 0; iprop < cprop; iprop++)
{
if( apid[iprop] == PropByteSwap(pent->propid) )
{
break;
}
if (fDeleteByName) // if deleting any properties by name
{
ULONG cbname;
_PropertyNameLength(appvNames[iprop], &cbname);
if (cbname == CCh2CB( PropByteSwap( pent->cch ))
&&
_ComparePropertyNames(
appvNames[iprop],
pent->sz,
FALSE, // appvNames & pent->sz may be dif endians
cbname)
)
{
break; // found an entry to be removed.
}
}
} // for (iprop = 0; iprop < cprop; iprop++)
cb = _DictionaryEntryLength( pent );
pent = _NextDictionaryEntry( pent );
if (iprop == cprop) // keep the dictionary entry
{
cbCopy += cb;
}
else // remove the dictionary entry
{
if (cbCopy != 0)
{
if (pvSrc != pvDst)
{
PropMoveMemory(
"SetPropertyNames:Compact",
_GetSectionHeader(),
pvDst,
pvSrc,
cbCopy);
}
pvDst = Add2Ptr(pvDst, cbCopy);
cbCopy = 0;
}
pvSrc = pent;
}
} // for (i = 0; i < PropByteSwap(pdy->cEntries); i++)
// Compact last chunk and point past compacted entries.
if (cbCopy != 0 && pvSrc != pvDst)
{
PropMoveMemory(
"SetPropertyNames:CompactLast",
_GetSectionHeader(),
pvDst,
pvSrc,
cbCopy);
}
pent = (ENTRY UNALIGNED *) Add2Ptr(pvDst, cbCopy);
} // if (!fDeleteAll)
pdy->cEntries = PropByteSwap( PropByteSwap(pdy->cEntries) - cDel );
// ------------------------------------
// Append new and modified entries now.
// ------------------------------------
if (appvNames != NULL)
{
// Add each name to the property set.
for (iprop = 0; iprop < cprop; iprop++)
{
// See if this propid appears later in the array.
i = cprop;
if (fDupPropid)
{
for (i = iprop + 1; i < cprop; i++)
{
if (apid[i] == apid[iprop])
{
break;
}
}
}
// See if this name appears later in the array.
if (i == cprop && fDupName)
{
ULONG cbname;
_PropertyNameLength(appvNames[iprop], &cbname);
for (i = iprop + 1; i < cprop; i++)
{
ULONG cbname2;
_PropertyNameLength(appvNames[i], &cbname2);
if (cbname == cbname2 &&
_ComparePropertyNames(
appvNames[iprop],
appvNames[i],
TRUE, // Both names are the same endian
cbname))
{
break;
}
}
}
// If this propid appears only once or if it's the last instance,
// append the mapping entry.
if (i == cprop)
{
ULONG cbname;
// Set the PID & character-count fields for this entry.
_PropertyNameLength(appvNames[iprop], &cbname);
pent->propid = PropByteSwap( apid[iprop] );
pent->cch = PropByteSwap( CB2CCh( cbname ));
// Copy the name into the dictionary.
RtlCopyMemory(pent->sz, appvNames[iprop], cbname);
// If this is a Unicode property set, we need to correct
// the byte-order.
if( CP_WINUNICODE == _CodePage )
{
PBSBuffer( pent->sz, cbname, sizeof(WCHAR) );
}
// Zero-out the pad bytes.
RtlZeroMemory(
Add2Ptr(pent->sz, cbname),
DwordRemain((ULONG) pent->sz + cbname));
pent = _NextDictionaryEntry( pent );
}
} // for (iprop = 0; iprop < cprop; iprop++)
// We've added all the names, now let's update the entry count.
pdy->cEntries = PropByteSwap( PropByteSwap(pdy->cEntries) + cAdd );
} // if (appvNames != NULL)
// Zero the possible partial DWORD at the end of the dictionary.
{
ULONG cb = (ULONG) ((BYTE *) pent - (BYTE *) pdy);
PROPASSERT(DwordAlign(cb) == cbDictOldD + cbChangeD);
RtlZeroMemory(pent, DwordRemain(cb));
}
// -----------------------------------------------------
// Adjust the remaining property offsets in the section.
// -----------------------------------------------------
PROPERTYIDOFFSET *ppo, *ppoMax;
PROPERTYSECTIONHEADER *psh;
psh = _LoadPropertyOffsetPointers(&ppo, &ppoMax, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
PROPASSERT(psh != NULL);
// Don't rely on the dictionary being the first property.
// Skip PID_DICTIONARY and adjust every other higher entry.
for ( ; ppo < ppoMax; ppo++)
{
if (ppo->dwOffset > oDictionary)
{
ppo->dwOffset += cbChangeD;
PROPASSERT(ppo->propid != PID_DICTIONARY);
}
}
// Update the size of the section
psh->cbSection += cbChangeD;
if (cbChangeD < 0)
{
// move everything after the dictionary forward by cbChangeD bytes.
PropMoveMemory(
"SetPropertyNames:TailUp",
_GetSectionHeader(),
Add2Ptr(pdy, cbDictOldD + cbChangeD),
Add2Ptr(pdy, cbDictOldD),
cbTail);
}
if (_cbTail != 0)
{
_PatchSectionOffsets(cbChangeD);
}
// If we need to shrink the stream or if we are cleaning up after a
// previous shrink that failed, do it last.
cbNewSize = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if ( cbNewSize != cbstm + cbChangeD)
{
DebugTrace(0, Dbg, (
"SetSize(%x) dictionary shrink\n",
cbstm + cbChangeD));
_MSTM(SetSize)(cbstm + cbChangeD, TRUE, (VOID **) &_pph, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
// ----
// Exit
// ----
Exit:
// If we had to convert the array of names into a different
// codepage, delete those temporary buffers now.
if (appvNames != NULL && appvNames != (VOID **) aposz)
{
for (iprop = 0; iprop < cprop; iprop++)
{
_pma->Free( appvNames[iprop] );
}
delete [] (char **) appvNames;
}
DebugTrace(0, Dbg, ("SetPropertyNames() ==> s=%x\n", STATUS_SUCCESS));
return;
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_ValidateStructure
//
// Synopsis: validate property set structure
//
// Arguments: [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
#if DBGPROP
VOID
CPropertySetStream::_ValidateStructure(OUT NTSTATUS *pstatus)
{
PROPID propid;
ULONG cb;
OLECHAR aocName[ CCH_MAXPROPNAMESZ ];
ULONG cbName;
*pstatus = STATUS_SUCCESS;
// Walk through properties to make sure all properties are consistent
// and are contained within the section size. A NULL return value
// means _LoadProperty walked the entire section, so we can quit then.
for (propid = PID_CODEPAGE; propid != PID_ILLEGAL; propid++)
{
SERIALIZEDPROPERTYVALUE const *pprop;
pprop = GetValue(propid, &cb, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (NULL == pprop)
{
break;
}
}
// Walk through dictionary entries to make sure all entries are consistent
// and are contained within the dictionary size. A FALSE return value
// means QueryPropertyNameBuf walked the entire dictionary, so quit then.
for (propid = PID_CODEPAGE + 1; propid != PID_ILLEGAL; propid++)
{
BOOL fExists;
cb = 0;
cbName = sizeof(aocName);
fExists = QueryPropertyNameBuf(propid, aocName, &cbName, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if( !fExists )
{
break;
}
}
if (_cSection > 1)
{
FORMATIDOFFSET const *pfo;
if (_cSection != 2)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateStructure: csection(%x) != 2",
_cSection));
StatusCorruption(pstatus, "_ValidateStructure: csection != 2");
goto Exit;
}
pfo = _GetFormatidOffset(0);
if (pfo->fmtid != guidDocumentSummary)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateStructure: DocumentSummary[0] fmtid"));
StatusCorruption(pstatus, "_ValidateStructure: DocumentSummary[0] fmtid");
goto Exit;
}
if (!IsDwordAligned(pfo->dwOffset))
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateStructure: dwOffset[0] = %x",
pfo->dwOffset));
StatusCorruption(pstatus, "_ValidateStructure: dwOffset[0]");
goto Exit;
}
pfo = _GetFormatidOffset(1);
if (pfo->fmtid != guidDocumentSummarySection2)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateStructure: DocumentSummary[1] fmtid"));
StatusCorruption(pstatus, "_ValidateStructure: DocumentSummary[1] fmtid");
goto Exit;
}
if (!IsDwordAligned(pfo->dwOffset))
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateStructure: dwOffset[1] = %x",
pfo->dwOffset));
StatusCorruption(pstatus, "_ValidateStructure: dwOffset[1]");
goto Exit;
}
} // if (_cSection > 1)
// ----
// Exit
// ----
Exit:
return;
}
#endif
//+--------------------------------------------------------------------------
// Member: fnPropidCompare
//
// Synopsis: qsort helper to compare propids in a PROPERTYIDOFFSET array.
//
// Arguments: [ppo1] -- pointer to PROPERTYIDOFFSET 1
// [ppo2] -- pointer to PROPERTYIDOFFSET 2
//
// Returns: difference
//+--------------------------------------------------------------------------
#if DBGPROP
INT _CRTAPI1
fnPropidCompare(VOID const *ppo1, VOID const *ppo2)
{
return(((PROPERTYIDOFFSET const *) ppo1)->propid -
((PROPERTYIDOFFSET const *) ppo2)->propid);
}
#endif
//+--------------------------------------------------------------------------
// Member: fnOffsetCompare
//
// Synopsis: qsort helper to compare offsets in a PROPERTYIDOFFSET array.
//
// Arguments: [ppo1] -- pointer to PROPERTYIDOFFSET 1
// [ppo2] -- pointer to PROPERTYIDOFFSET 2
//
// Returns: difference
//+--------------------------------------------------------------------------
INT _CRTAPI1
fnOffsetCompare(VOID const *ppo1, VOID const *ppo2)
{
return(((PROPERTYIDOFFSET const *) ppo1)->dwOffset -
((PROPERTYIDOFFSET const *) ppo2)->dwOffset);
}
//+--------------------------------------------------------------------------
// Member: GetStringLength
//
// Synopsis: return length of possibly unicode string.
//
// Arguments: [CodePage] -- TRUE if string is Unicode
// [pwsz] -- pointer to string
// [cb] -- MAXULONG or string length with L'\0' or '\0'
//
// Returns: length of string in bytes including trailing L'\0' or '\0'
//+--------------------------------------------------------------------------
ULONG
GetStringLength(
IN USHORT CodePage,
IN WCHAR const *pwsz,
IN ULONG cb)
{
ULONG i;
if (CodePage == CP_WINUNICODE)
{
for (i = 0; i < cb/sizeof(WCHAR); i++)
{
if (pwsz[i] == L'\0')
{
break;
}
}
PROPASSERT(cb == MAXULONG || cb == (i + 1) * sizeof(WCHAR));
return((i + 1) * sizeof(WCHAR));
}
else
{
char *psz = (char *) pwsz;
for (i = 0; i < cb; i++)
{
if (psz[i] == '\0')
{
break;
}
}
PROPASSERT(cb == MAXULONG || cb == (i + 1) * sizeof(char));
return((i + 1) * sizeof(char));
}
}
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_ValidateProperties
//
// Synopsis: validate properties
//
// Arguments: [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
#if DBGPROP
VOID
CPropertySetStream::_ValidateProperties(OUT NTSTATUS *pstatus) const
{
PROPERTYIDOFFSET *apo = NULL;
PROPERTYSECTIONHEADER const *psh = _GetSectionHeader();
static ULONG cValidate = 0;
ULONG cbwasted = 0;
ULONG cbtotal = 0;
*pstatus = STATUS_SUCCESS;
cValidate++;
DebugTrace(0, DEBTRACE_PROPVALIDATE, (
"_ValidateProperties(%x ppsstm=%x state=%x pph=%x)\n",
cValidate,
this,
_State,
_pph));
if (psh->cProperties != 0)
{
PROPERTYIDOFFSET *ppo, *ppoMax;
apo = newk(mtPropSetStream, NULL) PROPERTYIDOFFSET[psh->cProperties + 1];
if (apo == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
RtlCopyMemory(
apo,
psh->rgprop,
psh->cProperties * CB_PROPERTYIDOFFSET);
ppoMax = apo + psh->cProperties;
ppoMax->propid = PID_ILLEGAL;
ppoMax->dwOffset = psh->cbSection;
// Sort by property id and check for duplicate propids:
qsort(apo, psh->cProperties, sizeof(apo[0]), fnPropidCompare);
for (ppo = apo; ppo < ppoMax; ppo++)
{
if (ppo->propid == PID_ILLEGAL ||
ppo->propid == ppo[1].propid)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateProperties(bad propid=%x @%x)\n",
ppo->propid,
ppo->dwOffset));
StatusCorruption(pstatus, "_ValidateProperties: bad or dup propid");
goto Exit;
}
}
// Sort by offset and check for overlapping values:
qsort(apo, psh->cProperties, sizeof(apo[0]), fnOffsetCompare);
cbtotal = _oSection;
for (ppo = apo; ppo < ppoMax; ppo++)
{
ULONG cbdiff, cbprop, cbpropraw;
SERIALIZEDPROPERTYVALUE const *pprop;
cbprop = MAXULONG;
cbpropraw = cbprop;
cbdiff = ppo[1].dwOffset - ppo->dwOffset;
if (IsDwordAligned(ppo->dwOffset) &&
IsDwordAligned(ppo[1].dwOffset))
{
pprop = (SERIALIZEDPROPERTYVALUE const *)
_MapOffsetToAddress(ppo->dwOffset);
if (ppo->propid == PID_DICTIONARY)
{
cbprop = _DictionaryLength(
(DICTIONARY const *) pprop,
cbdiff,
pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
cbpropraw = cbprop;
cbprop = DwordAlign(cbprop);
}
else
{
cbprop = PropertyLengthNoEH(pprop, cbdiff, 0, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
cbpropraw = cbprop;
}
DebugTrace(0, DEBTRACE_PROPVALIDATE, (
"_ValidateProperties(%x) i=%x cb=%x/%x/%x @%x/%x pid=%x\n",
cValidate,
ppo - apo,
cbprop,
cbdiff,
ppo->dwOffset,
pprop,
ppo->propid));
cbtotal += cbdiff;
// Technically, the OLE spec allows extra unused space
// between properties, but this implementation never
// writes out streams with space between properties.
if (cbdiff == cbprop)
{
continue;
}
}
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateProperties(bad value length: propid=%x @%x/%x cb=%x/%x/%x ppsstm=%x)\n",
ppo->propid,
ppo->dwOffset,
pprop,
cbpropraw,
cbprop,
cbdiff,
this));
StatusCorruption(pstatus, "_ValidateProperties: bad property length");
goto Exit;
} // for (ppo = apo; ppo < ppoMax; ppo++)
} // if (psh->cProperties != 0)
// ----
// Exit
// ----
Exit:
delete [] apo;
DebugTrace(0, cbwasted != 0? 0 : Dbg, (
"_ValidateProperties(wasted %x bytes, total=%x)\n",
cbwasted,
cbtotal));
}
#endif
#if DBGPROP
typedef struct tagENTRYVALIDATE // ev
{
ENTRY UNALIGNED const *pent;
CPropertySetStream const *ppsstm;
} ENTRYVALIDATE;
#endif
//+--------------------------------------------------------------------------
// Member: fnEntryPropidCompare
//
// Synopsis: qsort helper to compare propids in a ENTRYVALIDATE array.
//
// Arguments: [pev1] -- pointer to ENTRYVALIDATE 1
// [pev2] -- pointer to ENTRYVALIDATE 2
//
// Returns: difference
//+--------------------------------------------------------------------------
#if DBGPROP
INT _CRTAPI1
fnEntryPropidCompare(VOID const *pev1, VOID const *pev2)
{
return(((ENTRYVALIDATE const *) pev1)->pent->propid -
((ENTRYVALIDATE const *) pev2)->pent->propid);
}
#endif
//+--------------------------------------------------------------------------
// Member: fnEntryNameCompare
//
// Synopsis: qsort helper to compare names in a ENTRYVALIDATE array.
//
// Arguments: [pev1] -- pointer to ENTRYVALIDATE 1
// [pev2] -- pointer to ENTRYVALIDATE 2
//
// Returns: difference
//+--------------------------------------------------------------------------
#if DBGPROP
INT _CRTAPI1
fnEntryNameCompare(VOID const *pev1, VOID const *pev2)
{
ENTRY UNALIGNED const *pent1;
ENTRY UNALIGNED const *pent2;
INT rc;
pent1 = ((ENTRYVALIDATE const *) pev1)->pent;
pent2 = ((ENTRYVALIDATE const *) pev2)->pent;
rc = PropByteSwap(pent1->cch) - PropByteSwap(pent2->cch);
if (rc == 0)
{
rc = !((ENTRYVALIDATE const *) pev1)->ppsstm->_ComparePropertyNames(
pent1->sz,
pent2->sz,
TRUE, // Both names have the same byte-order
( (ENTRYVALIDATE const *)
pev1
)->ppsstm->CCh2CB(PropByteSwap( pent1->cch )));
}
return(rc);
}
#endif
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::_ValidateDictionary
//
// Synopsis: validate property set dictionary
//
// Arguments: [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
#if DBGPROP
VOID
CPropertySetStream::_ValidateDictionary(OUT NTSTATUS *pstatus)
{
DICTIONARY const *pdy;
ULONG cbDict; // BYTE granular size!
ENTRYVALIDATE *aev = NULL;
ENTRYVALIDATE *pev, *pevMax;
PROPERTYSECTIONHEADER const *psh;
ENTRY UNALIGNED const *pent;
ENTRY entMax;
VOID const *pvDictEnd;
*pstatus = STATUS_SUCCESS;
pdy = (DICTIONARY const *) _LoadProperty(PID_DICTIONARY, &cbDict, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
if (pdy != NULL && PropByteSwap(pdy->cEntries) != 0)
{
aev = newk (mtPropSetStream, NULL)
ENTRYVALIDATE[ PropByteSwap(pdy->cEntries) + 1 ];
if (aev == NULL)
{
*pstatus = STATUS_NO_MEMORY;
goto Exit;
}
psh = _GetSectionHeader();
pent = pdy->rgEntry;
pvDictEnd = Add2ConstPtr(pdy, cbDict);
pevMax = aev + PropByteSwap( pdy->cEntries );
for (pev = aev; pev < pevMax; pev++)
{
ULONG cb = _DictionaryEntryLength( pent );
if (Add2ConstPtr(pent, cb) > pvDictEnd)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateDictionary(bad entry size for propid=%x)\n",
PropByteSwap( pev->pent->propid )));
StatusCorruption(pstatus, "ValidateDictionary: entry size");
goto Exit;
}
pev->pent = pent;
pev->ppsstm = this;
#if DBGPROP
#ifdef LITTLEENDIAN
if (_CodePage == CP_WINUNICODE)
{
PROPASSERT(IsUnicodeString((WCHAR const *) pent->sz,
CCh2CB(PropByteSwap( pent->cch ))));
}
else
{
PROPASSERT(IsAnsiString((char const *) pent->sz,
CCh2CB( PropByteSwap( pent->cch ))));
}
#endif
#endif
pent = _NextDictionaryEntry( pent );
}
if ((VOID const *) pent != pvDictEnd)
{
StatusCorruption(pstatus, "ValidateDictionary: end offset");
goto Exit;
}
entMax.cch = 0;
entMax.propid = PID_ILLEGAL;
pevMax->pent = &entMax;
pevMax->ppsstm = this;
// Sort by property id and check for duplicate propids:
qsort(aev, PropByteSwap(pdy->cEntries), sizeof(aev[0]), fnEntryPropidCompare);
for (pev = aev; pev < pevMax; pev++)
{
if (PID_ILLEGAL == PropByteSwap(pev->pent->propid)
||
pev[1].pent->propid == pev->pent->propid)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateDictionary(bad propid=%x)\n",
PropByteSwap( pev->pent->propid )));
StatusCorruption(pstatus, "_ValidateDictionary: bad or dup propid");
goto Exit;
}
}
// Sort by property name and check for duplicate names:
qsort(aev, PropByteSwap(pdy->cEntries), sizeof(aev[0]), fnEntryNameCompare);
for (pev = aev; pev < pevMax; pev++)
{
if (pev->pent->cch == 0
||
( pev->pent->cch == pev[1].pent->cch
&&
_ComparePropertyNames(
pev->pent->sz,
pev[1].pent->sz,
TRUE, // Names are the same byte-order
CCh2CB(PropByteSwap(pev->pent->cch)))
)
)
{
DebugTrace(0, DEBTRACE_ERROR, (
"_ValidateDictionary(bad name for propid=%x)\n",
PropByteSwap( pev->pent->propid )));
StatusCorruption(pstatus, "_ValidateDictionary: bad or dup name");
goto Exit;
}
} // for (pev = aev; pev < pevMax; pev++)
} // if (pdy != NULL && pdy->cEntries != 0)
// ----
// Exit
// ----
Exit:
delete [] aev;
}
#endif // DBGPROP
//+--------------------------------------------------------------------------
// Member: CPropertySetStream::Validate
//
// Synopsis: validate entire property stream
//
// Arguments: [pstatus] -- pointer to NTSTATUS code
//
// Returns: None
//+--------------------------------------------------------------------------
#if DBGPROP
extern "C" BOOLEAN fValidatePropSets = KERNELSELECT(DBG, TRUE);
VOID
CPropertySetStream::Validate(OUT NTSTATUS *pstatus)
{
if (fValidatePropSets && (_State & CPSS_USERDEFINEDDELETED) == 0)
{
ULONG cbstm = _MSTM(GetSize)(pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
// Walk through section headers to make sure all sections are contained
// within the stream size.
if (_ComputeMinimumSize(cbstm, pstatus) != 0)
{
// If an error had occurred in the above call,
// it would have returned zero.
_ValidateStructure( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
_ValidateProperties( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
_ValidateDictionary( pstatus );
if( !NT_SUCCESS(*pstatus) ) goto Exit;
_ComputeMinimumSize(cbstm, pstatus);
if( !NT_SUCCESS(*pstatus) ) goto Exit;
}
} // if (fValidatePropSets && (_State & CPSS_USERDEFINEDDELETED) == 0)
// ----
// Exit
// ----
Exit:
return;
}
#endif
//+--------------------------------------------------------------------------
// Function: CopyPropertyValue
//
// Synopsis: copy a property value into a supplied buffer
//
// Arguments: [pprop] -- property value (possibly NULL)
// [cb] -- property length
// [ppropDst] -- output buffer for property value
// [pcb] -- length of buffer (in); actual length (out)
//
// Returns: None
//---------------------------------------------------------------------------
#ifdef WINNT
VOID
CopyPropertyValue(
IN OPTIONAL SERIALIZEDPROPERTYVALUE const *pprop,
IN ULONG cb,
OUT SERIALIZEDPROPERTYVALUE *ppropDst,
OUT ULONG *pcb)
{
#if DBG==1
NTSTATUS Status;
#endif
if (pprop == NULL)
{
static SERIALIZEDPROPERTYVALUE prop = { VT_EMPTY, };
pprop = &prop;
cb = CB_SERIALIZEDPROPERTYVALUE;
}
PROPASSERT(cb == PropertyLengthNoEH(pprop, cb, 0, &Status)
&&
NT_SUCCESS(Status) );
RtlCopyMemory(ppropDst, pprop, min(cb, *pcb));
*pcb = cb;
}
#endif // WINNT
Reference in New Issue Copy Permalink