//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1995 // // File: PropRec.cxx // // Contents: Record format for persistent property store // // Classes: CPropertyRecord // // History: 28-Dec-19 KyleP Created // //---------------------------------------------------------------------------- #include #pragma hdrstop #include #include #include #include #include class CCTMABufferAllocator : public PMemoryAllocator { public: void *Allocate(ULONG cbSize) { return CoTaskMemAlloc( cbSize ); } void Free(void *pv) { CoTaskMemFree( pv ); } }; class CNonAlignAllocator : public PMemoryAllocator { public: inline CNonAlignAllocator(ULONG cbBuffer, VOID *pvBuffer) { _cbFree = cbBuffer; _pvCur = _pvBuffer = pvBuffer; } VOID *Allocate(ULONG cb) { VOID *pv; cb = (cb + sizeof(LONGLONG) - 1) & ~(sizeof(LONGLONG) - 1); if (cb > _cbFree) { return(NULL); } pv = _pvCur; _pvCur = (BYTE *) _pvCur + cb; _cbFree -= cb; return(pv); } VOID Free(VOID *pv) { } inline ULONG GetFreeSize(VOID) { return(_cbFree); } private: ULONG _cbFree; VOID *_pvCur; VOID *_pvBuffer; }; //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::ReadFixed, public // // Synopsis: Read fixed-length property // // Arguments: [Ordinal] -- Ordinal of property to locate. // [mask] -- Bitmask of ordinal. Pre-computed for efficiency. // [oStart] -- Offset to start of specific fixed property. // [cTotal] -- Total number of properties in record. // [Type] -- Data type of value // [var] -- Value returned here. // [pbExtra] -- Indirect data stored here // [pcbExtra] -- On input, size of [pbExtra]. On output, // amount used. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- void COnDiskPropertyRecord::ReadFixed( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG Type, PROPVARIANT & var, BYTE * pbExtra, unsigned * pcbExtra ) { if ( !IsStored( Ordinal, Mask ) ) { var.vt = VT_EMPTY; *pcbExtra = 0; } else { var.vt = (USHORT)Type; // // Start is after existance bitmap // ULONG const * pulStart = &_aul[ (cTotal-1) / 16 + 1 + oStart]; switch ( Type ) { case VT_I1: case VT_UI1: var.bVal = *(BYTE *)pulStart; *pcbExtra = 0; break; case VT_I2: case VT_UI2: case VT_BOOL: var.uiVal = *(USHORT *)pulStart; *pcbExtra = 0; break; case VT_I4: case VT_UI4: case VT_R4: case VT_ERROR: var.ulVal = *pulStart; *pcbExtra = 0; break; case VT_I8: case VT_UI8: case VT_R8: case VT_CY: case VT_DATE: case VT_FILETIME: RtlCopyMemory( &var.hVal, pulStart, sizeof(var.hVal) ); *pcbExtra = 0; break; case VT_CLSID: if ( *pcbExtra < sizeof(CLSID) ) { *pcbExtra = sizeof(CLSID); return; } if ( *pcbExtra == 0xFFFFFFFF ) var.puuid = (CLSID *)CoTaskMemAlloc( sizeof(CLSID) ); else { *pcbExtra = sizeof(CLSID); var.puuid = (CLSID *)pbExtra; } RtlCopyMemory( var.puuid, pulStart, sizeof(CLSID) ); break; default: ciDebugOut(( DEB_ERROR, "PROPSTORE: Reading invalid fixed type %d.\n", Type )); Win4Assert( !"How did I get here?" ); ReportCorruptComponent( L"PropertyRecord1" ); THROW( CException( CI_CORRUPT_DATABASE ) ); break; } } } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::ReadVariable, public // // Synopsis: Read variable-length property // // Arguments: [Ordinal] -- Ordinal of property to locate. // [mask] -- Bitmask of ordinal. Pre-computed for efficiency. // [oStart] -- Offset to start of variable storage area. // [cTotal] -- Total number of properties in record. // [cFixed] -- Count of fixed length properties // [var] -- Value returned here. // [pbExtra] -- Indirect data stored here // [pcbExtra] -- On input, size of [pbExtra]. On output, // amount used. // // Returns: FALSE if value must be stored in overflow record. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- BOOL COnDiskPropertyRecord::ReadVariable( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG cFixed, PROPVARIANT & var, BYTE * pbExtra, unsigned * pcbExtra ) { if ( !IsStored( Ordinal, Mask ) ) { var.vt = VT_EMPTY; *pcbExtra = 0; } else { // // Check for overflow. // if ( IsStoredOnOverflow( Ordinal, Mask ) ) return FALSE; // // Start is after existance bitmap and fixed properties. // ULONG * pulStart = FindVariableProp( Ordinal, cFixed, cTotal, oStart ); Win4Assert( !IsOverflow( *pulStart ) ); // // Compute the length of the property. // ULONG cbProp = UsedSize( *pulStart ) * 4; pulStart++; // Skip size field. ciDebugOut(( DEB_PROPSTORE, "Reading variable prop, ordinal %d at offset 0x%x (%d) in record. Size = %d bytes.\n", Ordinal, (ULONG)pulStart - (ULONG)this, (ULONG)pulStart - (ULONG)this, cbProp )); ULONG cb = PropertyLengthAsVariant( (SERIALIZEDPROPERTYVALUE *)pulStart, cbProp, CP_WINUNICODE, 0 ); if ( cb <= *pcbExtra ) { if ( *pcbExtra == 0xFFFFFFFF ) { // // Unmarshall the property. Extra allocation via CoTaskMemAlloc // CCTMABufferAllocator BufferMgr; RtlConvertPropertyToVariant( (SERIALIZEDPROPERTYVALUE *)pulStart, CP_WINUNICODE, &var, &BufferMgr ); #if CIDBG==1 if ( (var.vt&0x0fff) > VT_CLSID ) { ciDebugOut(( DEB_ERROR, "Bad Variant Type 0x%X\n", var.vt )); Win4Assert( !"Call KyleP" ); } #endif // CIDBG==1 } else { // // Unmarshall the property. // CNonAlignAllocator BufferMgr( *pcbExtra, pbExtra ); RtlConvertPropertyToVariant( (SERIALIZEDPROPERTYVALUE *)pulStart, CP_WINUNICODE, &var, &BufferMgr ); #if CIDBG==1 if ( (var.vt&0x0fff) > VT_CLSID ) { ciDebugOut(( DEB_ERROR, "Bad Variant Type 0x%X\n", var.vt )); Win4Assert( !"Call KyleP" ); } #endif // CIDBG==1 } } *pcbExtra = cb; } return TRUE; } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::WriteFixed, public // // Synopsis: Write fixed-length property // // Arguments: [Ordinal] -- Ordinal of property to locate. // [mask] -- Bitmask of ordinal. Pre-computed for efficiency. // [oStart] -- Offset to start of specific property. // [Type] -- Expected data type (for type checking) // [cTotal] -- Total number of properties in record. // [var] -- Value to store. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- void COnDiskPropertyRecord::WriteFixed( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG Type, ULONG cTotal, CStorageVariant const & var ) { if ( var.Type() != (VARENUM)Type ) { # if CIDBG == 1 if ( var.Type() != VT_EMPTY ) ciDebugOut(( DEB_WARN, "Type mismatch (%d vs. %d) writing fixed property\n", var.Type(), Type )); # endif ClearStored( Ordinal, Mask ); return; } // // Start is after existance bitmap // ULONG * pulStart = &_aul[ (cTotal-1) / 16 + 1 + oStart]; ciDebugOut(( DEB_PROPSTORE, "Writing fixed prop, ordinal %d (type %d) at offset 0x%x (%d) in record.\n", Ordinal, var.Type(), (ULONG)pulStart - (ULONG)this, (ULONG)pulStart - (ULONG)this )); switch ( var.Type() ) { case VT_I1: case VT_UI1: Win4Assert( !"Fix this!" ); //*(BYTE *)pulStart = var.GetUI1(); break; case VT_I2: case VT_UI2: case VT_BOOL: { ULONG ul = var.GetUI2(); *pulStart = ul; } break; case VT_I4: case VT_UI4: case VT_R4: case VT_ERROR: *pulStart = var.GetUI4(); break; case VT_I8: case VT_UI8: case VT_R8: case VT_CY: case VT_DATE: case VT_FILETIME: { ULARGE_INTEGER uli = var.GetUI8(); RtlCopyMemory( pulStart, &uli, sizeof(uli) ); } break; case VT_CLSID: RtlCopyMemory( pulStart, var.GetCLSID(), sizeof(CLSID) ); break; default: Win4Assert( !"How did I get here?" ); ClearStored( Ordinal, Mask ); break; } SetStored( Ordinal, Mask ); } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::WriteVariable, public // // Synopsis: Write variable-length property // // Arguments: [Ordinal] -- Ordinal of property to locate. // [mask] -- Bitmask of ordinal. Pre-computed for efficiency. // [oStart] -- Offset to start of variable length area. // [cTotal] -- Total number of properties in record. // [cFixed] -- Count of fixed length properties // [culRec] -- Size (in dwords) of record // [var] -- Value to store. // // Returns: FALSE if record must be stored in overflow record. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- BOOL COnDiskPropertyRecord::WriteVariable( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG cFixed, ULONG culRec, CStorageVariant const & var ) { ULONG * pulStart = FindVariableProp( Ordinal, cFixed, cTotal, oStart ); // // Are we freeing this property? // if ( var.Type() == VT_EMPTY ) { ClearStored( Ordinal, Mask ); ClearStoredOnOverflow( Ordinal, Mask ); // // Overflow case: We need to fake the overflow to clean up linked records. // if ( IsOverflow( *pulStart ) ) { SetUsedSize( pulStart, 0 ); return FALSE; } else { // // Adjust size field, and total variable space for record. // Win4Assert( _culVariableUsed >= UsedSize( *pulStart ) ); _culVariableUsed -= UsedSize( *pulStart ); SetUsedSize( pulStart, 0 ); return TRUE; } } // // No matter what happens, we want to indicate the property was stored. // SetStored( Ordinal, Mask ); ClearStoredOnOverflow( Ordinal, Mask ); // // Compute the length of the property. // ULONG cul = 0; RtlConvertVariantToProperty( (PROPVARIANT *)(ULONG)&var, CP_WINUNICODE, 0, &cul, pidInvalid, FALSE, 0 ); Win4Assert( cul > 0 ); cul = (cul - 1) / 4 + 1; ULONG culPrevUsed = UsedSize( *pulStart ); // // Do we fit? // if ( cul > AllocatedSize( *pulStart ) ) { // // Can we fit? // if ( cul > UsedSize( *pulStart ) + FreeVariableSpace( cTotal, cFixed, oStart, culRec ) ) { ciDebugOut(( DEB_PROPSTORE, "Need overflow buffer for ordinal %u\n", Ordinal )); // // If we had a previous value, adjust total variable space for record. // if ( !IsOverflow( *pulStart ) ) { Win4Assert( _culVariableUsed >= UsedSize( *pulStart ) ); _culVariableUsed -= UsedSize( *pulStart ); } MarkOverflow( pulStart ); SetStoredOnOverflow( Ordinal, Mask ); return FALSE; } // // Need to move properties, but there *is* room in record for the shift. // // // First, compress previous properties. // #if CIDBG ULONG * pulOldStart = pulStart; #endif pulStart = LeftCompress( FindVariableProp( cFixed, cFixed, cTotal, oStart ), 0, pulStart ); ciDebugOut(( DEB_PROPSTORE, "Freeing up %d bytes for variable prop %d via left compression\n", (pulOldStart - pulStart) * 4, Ordinal )); // // Then, if needed, push additional properties farther out. // if ( cul > AllocatedSize( *pulStart ) ) { ULONG * pulNext = pulStart + AllocatedSize(*pulStart) + 1; ULONG culDelta = cul - AllocatedSize(*pulStart); ciDebugOut(( DEB_PROPSTORE, "Freeing up %d bytes for variable prop %d, starting at offset 0x%x (%d) via right compression\n", culDelta * 4, Ordinal, (ULONG)pulNext - (ULONG)this, (ULONG)pulNext - (ULONG)this )); Win4Assert( Ordinal < cTotal ); RightCompress( pulNext, // Next property culDelta, // Amount to shift cTotal - Ordinal - 1 ); // # props left in record SetAllocatedSize( pulStart, cul ); } Win4Assert( cul <= AllocatedSize( *pulStart ) ); } // // Adjust size field, and total variable space for record. // _culVariableUsed += cul - culPrevUsed; SetUsedSize( pulStart, cul ); pulStart++; // Skip size field Win4Assert( AllocatedSize( *(pulStart - 1)) >= UsedSize( *(pulStart - 1) ) ); ciDebugOut(( DEB_PROPSTORE, "Writing variable prop, ordinal %d at offset 0x%x (%d) in record. Size = %d bytes.\n", Ordinal, (ULONG)pulStart - (ULONG)this, (ULONG)pulStart - (ULONG)this, UsedSize(*(pulStart - 1)) * 4 )); cul *= 4; if ( 0 == RtlConvertVariantToProperty( (PROPVARIANT *)(ULONG)&var, CP_WINUNICODE, (SERIALIZEDPROPERTYVALUE *)pulStart, &cul, pidInvalid, FALSE, 0 ) ) { ciDebugOut(( DEB_ERROR, "Error marshalling property!\n" )); ReportCorruptComponent( L"PropertyRecord2" ); THROW( CException( CI_CORRUPT_DATABASE ) ); } return TRUE; } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::CountRecordsToStore, public // // Synopsis: Compute size of value // // Arguments: [cTotal] -- Total number of properties in record. // [culRec] -- Size (in dwords) of record // [var] -- Value to store. // // Returns: Size in records needed to store property. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- ULONG COnDiskPropertyRecord::CountRecordsToStore( ULONG cTotal, ULONG culRec, CStorageVariant const & var ) { // // Compute the length of the property. // ULONG cul = 0; RtlConvertVariantToProperty( (PROPVARIANT *)(ULONG)&var, CP_WINUNICODE, 0, &cul, pidInvalid, FALSE, 0 ); Win4Assert( cul > 0 ); cul = (cul - 1) / 4 + 1; // // Add on the fixed overhead. // cul += FixedOverhead() + // Fixed overhead (cTotal - 1) / 16 + 1 + // Existence bitmap cTotal; // Used/Alloc sizes return (cul - 1) / culRec + 1; } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::RightCompress, public // // Synopsis: Moves data from [pul], [cul] dwords up. // // Arguments: [pul] -- Start of area to move. // [cul] -- Count of dwords to move // [cRemaining] -- Count of values remaining in buffer. Needed // because it is impossible to distinguish // used/alloc blocks from empty space. // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- void COnDiskPropertyRecord::RightCompress( ULONG * pul, ULONG cul, ULONG cRemaining ) { // // Termination condition for recursion: We've scanned all variable // properties in this record. Any remaining space in record is // guaranteed to be free. // if ( 0 == cRemaining ) return; ULONG FreeSpace = AllocatedSize(*pul) - UsedSize(*pul); if ( FreeSpace >= cul ) { SetAllocatedSize( pul, AllocatedSize(*pul) - cul ); } else { RightCompress( pul + AllocatedSize(*pul) + 1, cul - FreeSpace, cRemaining - 1 ); SetAllocatedSize( pul, UsedSize(*pul) ); } RtlMoveMemory( pul + cul, pul, (UsedSize(*pul) + 1) * 4 ); } //+--------------------------------------------------------------------------- // // Member: COnDiskPropertyRecord::LeftCompress, public // // Synopsis: Moves data from [pul], [cul] dwords down. // // Arguments: [pul] -- Start of area to move. // [cul] -- Count of dwords to move // [pulEnd] -- Terminating property. This property will have // it's allocated size increased with all the slack // from previous properties and have its used size // set to 0. // // Returns: New pointer to pulEnd (which moved down by [cul] bytes). // // History: 27-Dec-95 KyleP Created. // //---------------------------------------------------------------------------- ULONG * COnDiskPropertyRecord::LeftCompress( ULONG * pul, ULONG cul, ULONG * pulEnd ) { // // Terminating recursion? Just copy the allocated info. Used size is // zero, because data isn't copied. // if ( pul == pulEnd ) { pul -= cul; SetAllocatedSize( pul, AllocatedSize(*pulEnd) + cul ); SetUsedSize( pul, 0 ); return pul; } // // First, move current record. // if ( cul > 0 ) { RtlMoveMemory( pul - cul, pul, (UsedSize(*pul) + 1) * 4 ); pul -= cul; } // // Adjust allocation size. // cul += ( AllocatedSize(*pul) - UsedSize(*pul) ); SetAllocatedSize( pul, UsedSize(*pul) ); return LeftCompress( pul + cul + UsedSize(*pul) + 1, cul, pulEnd ); }