cmsubs2.c File Reference

#include "cmp.h"

Go to the source code of this file.

Defines
#define	ALIGN_OFFSET(Offset)
#define	ALIGN_OFFSET64(Offset)
Functions
PUCHAR	CmpGetValueDataFromCache (IN PHHIVE Hive, IN PPCM_CACHED_VALUE ContainingList, IN PCELL_DATA ValueKey, IN BOOLEAN ValueCached)
VOID	CmpFreeValue (PHHIVE Hive, HCELL_INDEX Cell)
NTSTATUS	CmpQueryKeyData (PHHIVE Hive, PCM_KEY_NODE Node, KEY_INFORMATION_CLASS KeyInformationClass, PVOID KeyInformation, ULONG Length, PULONG ResultLength)
NTSTATUS	CmpQueryKeyValueData (PHHIVE Hive, PPCM_CACHED_VALUE ContainingList, PCM_KEY_VALUE ValueKey, BOOLEAN ValueCached, KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, PVOID KeyValueInformation, ULONG Length, PULONG ResultLength)

---

Define Documentation

#define ALIGN_OFFSET (  Offset   )

Value: (ULONG) \ ((((ULONG)(Offset) + sizeof(ULONG)-1)) & (~(sizeof(ULONG) - 1))) Definition at line 45 of file cmsubs2.c. Referenced by CmpQueryKeyData(), and CmpQueryKeyValueData().

#define ALIGN_OFFSET64 (  Offset   )

Value: (ULONG) \ ((((ULONG)(Offset) + sizeof(ULONGLONG)-1)) & (~(sizeof(ULONGLONG) - 1))) Definition at line 48 of file cmsubs2.c. Referenced by CmpQueryKeyValueData().

---

Function Documentation

VOID CmpFreeValue (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 53 of file cmsubs2.c. References Cell, CmpIsHKeyValueSmall, _CM_KEY_VALUE::Data, _CM_KEY_VALUE::DataLength, Hive, HvFreeCell(), HvGetCell, _CELL_DATA::_u::KeyValue, and _CELL_DATA::u. Referenced by CmDeleteValueKey(), CmpFreeKeyByCell(), and CmpFreeKeyValues(). : Free the value entry Hive.Cell refers to, including its name and data cells. Arguments: Hive - supplies a pointer to the hive control structure for the hive Cell - supplies index of value to delete Return Value: NTSTATUS - Result code from call, among the following: <TBS> --*/ { PCELL_DATA value; ULONG realsize; BOOLEAN small; // // map in the cell // value = HvGetCell(Hive, Cell); // // free data if present // small = CmpIsHKeyValueSmall(realsize, value->u.KeyValue.DataLength); if ((! small) && (realsize > 0)) { HvFreeCell(Hive, value->u.KeyValue.Data); } // // free the cell itself // HvFreeCell(Hive, Cell); return; }

PUCHAR CmpGetValueDataFromCache (  IN PHHIVE  Hive, IN PPCM_CACHED_VALUE  ContainingList, IN PCELL_DATA  ValueKey, IN BOOLEAN  ValueCached )

Definition at line 403 of file cmsubs2.c. References ASSERT, CM_CACHE_DATA_CACHED, CM_CACHE_DATA_NOT_CACHED, CM_CACHE_DATA_TOO_BIG, CMP_GET_CACHED_ADDRESS, CMP_MARK_CELL_CACHED, CmpMakeSpecialPoolReadOnly, CmpMakeSpecialPoolReadWrite, _CM_CACHED_VALUE::DataCacheType, ExAllocatePoolWithTag, ExFreePool(), Hive, HvGetCell, HvGetCellSize(), _CM_CACHED_VALUE::KeyValue, MAXIMUM_CACHED_DATA, PagedPool, and _CM_CACHED_VALUE::ValueKeySize. Referenced by CmpQueryKeyValueData(). : Get the cached Value Data given a value node. Arguments: Hive - pointer to hive control structure for hive of interest ContainingList - Address that stores the allocation address of the value node. We need to update this when we do a re-allocate to cache both value key and value data. ValueKey - pointer to the Value Key ValueCached - Indicating whether Value key is cached or not. Return Value: Pointer to the Valve Index. --*/ { // // Cache the data if needed. // PCM_CACHED_VALUE OldEntry; PCM_CACHED_VALUE NewEntry; PUCHAR datapointer; PUCHAR Cacheddatapointer; ULONG AllocSize; ULONG CopySize; ULONG DataSize; if (ValueCached) { OldEntry = (PCM_CACHED_VALUE) CMP_GET_CACHED_ADDRESS(*ContainingList); if (OldEntry->DataCacheType == CM_CACHE_DATA_CACHED) { // // Data is already cached, use it. // datapointer = (PUCHAR) ((ULONG_PTR) ValueKey + OldEntry->ValueKeySize); } else if (OldEntry->DataCacheType == CM_CACHE_DATA_TOO_BIG) { // // Data is too big to warrent caching, get it from the registry. // datapointer = (PUCHAR)HvGetCell(Hive, ValueKey->u.KeyValue.Data); } else { // // consistency check // ASSERT(OldEntry->DataCacheType == CM_CACHE_DATA_NOT_CACHED); // // Value data is not cached. // Check the size of value data, if it is smaller than MAXIMUM_CACHED_DATA, cache it. // datapointer = (PUCHAR)HvGetCell(Hive, ValueKey->u.KeyValue.Data); DataSize = (ULONG) HvGetCellSize(Hive, datapointer); if (DataSize <= MAXIMUM_CACHED_DATA) { // // Data is not cached and now we are going to do it. // Reallocate a new cached entry for both value key and value data. // CopySize = DataSize + OldEntry->ValueKeySize; AllocSize = CopySize + FIELD_OFFSET(CM_CACHED_VALUE, KeyValue); // Dragos: Changed to catch the memory violator // it didn't work //NewEntry = (PCM_CACHED_VALUE) ExAllocatePoolWithTagPriority(PagedPool, AllocSize, CM_CACHE_VALUE_DATA_TAG,NormalPoolPrioritySpecialPoolUnderrun); NewEntry = (PCM_CACHED_VALUE) ExAllocatePoolWithTag(PagedPool, AllocSize, CM_CACHE_VALUE_DATA_TAG); if (NewEntry) { // // Now fill the data to the new cached entry // NewEntry->DataCacheType = CM_CACHE_DATA_CACHED; NewEntry->ValueKeySize = OldEntry->ValueKeySize; RtlCopyMemory((PVOID)&(NewEntry->KeyValue), (PVOID)&(OldEntry->KeyValue), NewEntry->ValueKeySize); Cacheddatapointer = (PUCHAR) ((ULONG_PTR) &(NewEntry->KeyValue) + OldEntry->ValueKeySize); RtlCopyMemory(Cacheddatapointer, datapointer, DataSize); // Trying to catch the BAD guy who writes over our pool. CmpMakeSpecialPoolReadWrite( OldEntry ); *ContainingList = (PCM_CACHED_VALUE) CMP_MARK_CELL_CACHED(NewEntry); // Trying to catch the BAD guy who writes over our pool. CmpMakeSpecialPoolReadOnly( NewEntry ); // // Free the old entry // ExFreePool(OldEntry); } } else { // Trying to catch the BAD guy who writes over our pool. CmpMakeSpecialPoolReadWrite( OldEntry ); // // Mark the type and do not cache it. // OldEntry->DataCacheType = CM_CACHE_DATA_TOO_BIG; // Trying to catch the BAD guy who writes over our pool. CmpMakeSpecialPoolReadOnly( OldEntry ); } } } else { datapointer = (PUCHAR)HvGetCell(Hive, ValueKey->u.KeyValue.Data); } return (datapointer); }

NTSTATUS CmpQueryKeyData (  PHHIVE  Hive, PCM_KEY_NODE  Node, KEY_INFORMATION_CLASS  KeyInformationClass, PVOID  KeyInformation, ULONG  Length, PULONG  ResultLength )

Definition at line 110 of file cmsubs2.c. References ALIGN_OFFSET, _CM_KEY_NODE::Class, _CM_KEY_NODE::ClassLength, CmpCopyCompressedName(), CmpHKeyNameLen, _CHILD_LIST::Count, _CM_KEY_NODE::Flags, Hive, HvGetCell, KEY_COMP_NAME, _KEY_INFORMATION::KeyBasicInformation, _KEY_INFORMATION::KeyFullInformation, _KEY_INFORMATION::KeyNodeInformation, _CM_KEY_NODE::LastWriteTime, _CM_KEY_NODE::MaxClassLen, _CM_KEY_NODE::MaxNameLen, _CM_KEY_NODE::MaxValueDataLen, _CM_KEY_NODE::MaxValueNameLen, _CM_KEY_NODE::Name, Name, _CM_KEY_NODE::NameLength, NTSTATUS(), Stable, _CM_KEY_NODE::SubKeyCounts, USHORT, _CM_KEY_NODE::ValueList, and Volatile. Referenced by CmEnumerateKey(), and CmQueryKey(). : Do the actual copy of data for a key into caller's buffer. If KeyInformation is not long enough to hold all requested data, STATUS_BUFFER_OVERFLOW will be returned, and ResultLength will be set to the number of bytes actually required. Arguments: Hive - supplies a pointer to the hive control structure for the hive Node - Supplies pointer to node whose subkeys are to be found KeyInformationClass - Specifies the type of information returned in Buffer. One of the following types: KeyBasicInformation - return last write time, title index, and name. (see KEY_BASIC_INFORMATION structure) KeyNodeInformation - return last write time, title index, name, class. (see KEY_NODE_INFORMATION structure) KeyInformation -Supplies pointer to buffer to receive the data. Length - Length of KeyInformation in bytes. ResultLength - Number of bytes actually written into KeyInformation. Return Value: NTSTATUS - Result code from call, among the following: <TBS> --*/ { NTSTATUS status; PCELL_DATA pclass; ULONG requiredlength; LONG leftlength; ULONG offset; ULONG minimumlength; PKEY_INFORMATION pbuffer; USHORT NameLength; pbuffer = (PKEY_INFORMATION)KeyInformation; NameLength = CmpHKeyNameLen(Node); switch (KeyInformationClass) { case KeyBasicInformation: // // LastWriteTime, TitleIndex, NameLength, Name requiredlength = FIELD_OFFSET(KEY_BASIC_INFORMATION, Name) + NameLength; minimumlength = FIELD_OFFSET(KEY_BASIC_INFORMATION, Name); *ResultLength = requiredlength; status = STATUS_SUCCESS; if (Length < minimumlength) { status = STATUS_BUFFER_TOO_SMALL; } else { pbuffer->KeyBasicInformation.LastWriteTime = Node->LastWriteTime; pbuffer->KeyBasicInformation.TitleIndex = 0; pbuffer->KeyBasicInformation.NameLength = NameLength; leftlength = Length - minimumlength; requiredlength = NameLength; if (leftlength < (LONG)requiredlength) { requiredlength = leftlength; status = STATUS_BUFFER_OVERFLOW; } if (Node->Flags & KEY_COMP_NAME) { CmpCopyCompressedName(pbuffer->KeyBasicInformation.Name, leftlength, Node->Name, Node->NameLength); } else { RtlCopyMemory( &(pbuffer->KeyBasicInformation.Name[0]), &(Node->Name[0]), requiredlength ); } } break; case KeyNodeInformation: // // LastWriteTime, TitleIndex, ClassOffset, ClassLength // NameLength, Name, Class // requiredlength = FIELD_OFFSET(KEY_NODE_INFORMATION, Name) + NameLength + Node->ClassLength; minimumlength = FIELD_OFFSET(KEY_NODE_INFORMATION, Name); *ResultLength = requiredlength; status = STATUS_SUCCESS; if (Length < minimumlength) { status = STATUS_BUFFER_TOO_SMALL; } else { pbuffer->KeyNodeInformation.LastWriteTime = Node->LastWriteTime; pbuffer->KeyNodeInformation.TitleIndex = 0; pbuffer->KeyNodeInformation.ClassLength = Node->ClassLength; pbuffer->KeyNodeInformation.NameLength = NameLength; leftlength = Length - minimumlength; requiredlength = NameLength; if (leftlength < (LONG)requiredlength) { requiredlength = leftlength; status = STATUS_BUFFER_OVERFLOW; } if (Node->Flags & KEY_COMP_NAME) { CmpCopyCompressedName(pbuffer->KeyNodeInformation.Name, leftlength, Node->Name, Node->NameLength); } else { RtlCopyMemory( &(pbuffer->KeyNodeInformation.Name[0]), &(Node->Name[0]), requiredlength ); } if (Node->ClassLength > 0) { offset = FIELD_OFFSET(KEY_NODE_INFORMATION, Name) + NameLength; offset = ALIGN_OFFSET(offset); pbuffer->KeyNodeInformation.ClassOffset = offset; pclass = HvGetCell(Hive, Node->Class); pbuffer = (PKEY_INFORMATION)((PUCHAR)pbuffer + offset); leftlength = (((LONG)Length - (LONG)offset) < 0) ? 0 : Length - offset; requiredlength = Node->ClassLength; if (leftlength < (LONG)requiredlength) { requiredlength = leftlength; status = STATUS_BUFFER_OVERFLOW; } RtlMoveMemory( pbuffer, pclass, requiredlength ); } else { pbuffer->KeyNodeInformation.ClassOffset = (ULONG)-1; } } break; case KeyFullInformation: // // LastWriteTime, TitleIndex, ClassOffset, ClassLength, // SubKeys, MaxNameLen, MaxClassLen, Values, MaxValueNameLen, // MaxValueDataLen, Class // requiredlength = FIELD_OFFSET(KEY_FULL_INFORMATION, Class) + Node->ClassLength; minimumlength = FIELD_OFFSET(KEY_FULL_INFORMATION, Class); *ResultLength = requiredlength; status = STATUS_SUCCESS; if (Length < minimumlength) { status = STATUS_BUFFER_TOO_SMALL; } else { pbuffer->KeyFullInformation.LastWriteTime = Node->LastWriteTime; pbuffer->KeyFullInformation.TitleIndex = 0; pbuffer->KeyFullInformation.ClassLength = Node->ClassLength; if (Node->ClassLength > 0) { pbuffer->KeyFullInformation.ClassOffset = FIELD_OFFSET(KEY_FULL_INFORMATION, Class); pclass = HvGetCell(Hive, Node->Class); leftlength = Length - minimumlength; requiredlength = Node->ClassLength; if (leftlength < (LONG)requiredlength) { requiredlength = leftlength; status = STATUS_BUFFER_OVERFLOW; } RtlMoveMemory( &(pbuffer->KeyFullInformation.Class[0]), pclass, requiredlength ); } else { pbuffer->KeyFullInformation.ClassOffset = (ULONG)-1; } pbuffer->KeyFullInformation.SubKeys = Node->SubKeyCounts[Stable] + Node->SubKeyCounts[Volatile]; pbuffer->KeyFullInformation.Values = Node->ValueList.Count; pbuffer->KeyFullInformation.MaxNameLen = Node->MaxNameLen; pbuffer->KeyFullInformation.MaxClassLen = Node->MaxClassLen; pbuffer->KeyFullInformation.MaxValueNameLen = Node->MaxValueNameLen; pbuffer->KeyFullInformation.MaxValueDataLen = Node->MaxValueDataLen; } break; default: status = STATUS_INVALID_PARAMETER; break; } return status; }

NTSTATUS CmpQueryKeyValueData (  PHHIVE  Hive, PPCM_CACHED_VALUE  ContainingList, PCM_KEY_VALUE  ValueKey, BOOLEAN  ValueCached, KEY_VALUE_INFORMATION_CLASS  KeyValueInformationClass, PVOID  KeyValueInformation, ULONG  Length, PULONG  ResultLength )

Definition at line 531 of file cmsubs2.c. References ALIGN_OFFSET, ALIGN_OFFSET64, ASSERT, CM_KEY_VALUE_SMALL, CmpCopyCompressedName(), CmpGetValueDataFromCache(), CmpIsHKeyValueSmall, CmpValueNameLen, _CM_KEY_VALUE::Data, _CM_KEY_VALUE::DataLength, _CM_KEY_VALUE::Flags, Hive, _CELL_DATA::_u::KeyValue, _KEY_VALUE_INFORMATION::KeyValueBasicInformation, _KEY_VALUE_INFORMATION::KeyValueFullInformation, _KEY_VALUE_INFORMATION::KeyValuePartialInformation, _KEY_VALUE_INFORMATION::KeyValuePartialInformationAlign64, _CM_KEY_VALUE::Name, Name, _CM_KEY_VALUE::NameLength, NTSTATUS(), TRUE, _CM_KEY_VALUE::Type, _CELL_DATA::u, USHORT, and VALUE_COMP_NAME. Referenced by CmEnumerateValueKey(), and CmQueryValueKey(). 00543 : 00544 00545 Do the actual copy of data for a key value into caller's buffer. 00546 00547 If KeyValueInformation is not long enough to hold all requested data, 00548 STATUS_BUFFER_OVERFLOW will be returned, and ResultLength will be 00549 set to the number of bytes actually required. 00550 00551 Arguments: 00552 00553 Hive - supplies a pointer to the hive control structure for the hive 00554 00555 Cell - supplies index of node to whose sub keys are to be found 00556 00557 KeyValueInformationClass - Specifies the type of information returned in 00558 KeyValueInformation. One of the following types: 00559 00560 KeyValueInformation -Supplies pointer to buffer to receive the data. 00561 00562 Length - Length of KeyInformation in bytes. 00563 00564 ResultLength - Number of bytes actually written into KeyInformation. 00565 00566 Return Value: 00567 00568 NTSTATUS - Result code from call, among the following: 00569 00570 <TBS> 00571 00572 --*/ 00573 { 00574 NTSTATUS status; 00575 PKEY_VALUE_INFORMATION pbuffer; 00576 PCELL_DATA pcell; 00577 LONG leftlength; 00578 ULONG requiredlength; 00579 ULONG minimumlength; 00580 ULONG offset; 00581 ULONG base; 00582 ULONG realsize; 00583 PUCHAR datapointer; 00584 BOOLEAN small; 00585 USHORT NameLength; 00586 00587 pbuffer = (PKEY_VALUE_INFORMATION)KeyValueInformation; 00588 00589 pcell = (PCELL_DATA) ValueKey; 00590 NameLength = CmpValueNameLen(&pcell->u.KeyValue); 00591 00592 switch (KeyValueInformationClass) { 00593 00594 case KeyValueBasicInformation: 00595 00596 // 00597 // TitleIndex, Type, NameLength, Name 00598 // 00599 requiredlength = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) + 00600 NameLength; 00601 00602 minimumlength = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name); 00603 00604 *ResultLength = requiredlength; 00605 00606 status = STATUS_SUCCESS; 00607 00608 if (Length < minimumlength) { 00609 00610 status = STATUS_BUFFER_TOO_SMALL; 00611 00612 } else { 00613 00614 pbuffer->KeyValueBasicInformation.TitleIndex = 0; 00615 00616 pbuffer->KeyValueBasicInformation.Type = 00617 pcell->u.KeyValue.Type; 00618 00619 pbuffer->KeyValueBasicInformation.NameLength = 00620 NameLength; 00621 00622 leftlength = Length - minimumlength; 00623 requiredlength = NameLength; 00624 00625 if (leftlength < (LONG)requiredlength) { 00626 requiredlength = leftlength; 00627 status = STATUS_BUFFER_OVERFLOW; 00628 } 00629 00630 if (pcell->u.KeyValue.Flags & VALUE_COMP_NAME) { 00631 CmpCopyCompressedName(pbuffer->KeyValueBasicInformation.Name, 00632 requiredlength, 00633 pcell->u.KeyValue.Name, 00634 pcell->u.KeyValue.NameLength); 00635 } else { 00636 RtlCopyMemory(&(pbuffer->KeyValueBasicInformation.Name[0]), 00637 &(pcell->u.KeyValue.Name[0]), 00638 requiredlength); 00639 } 00640 } 00641 00642 break; 00643 00644 00645 00646 case KeyValueFullInformation: 00647 case KeyValueFullInformationAlign64: 00648 00649 // 00650 // TitleIndex, Type, DataOffset, DataLength, NameLength, 00651 // Name, Data 00652 // 00653 small = CmpIsHKeyValueSmall(realsize, pcell->u.KeyValue.DataLength); 00654 00655 requiredlength = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) + 00656 NameLength + 00657 realsize; 00658 00659 minimumlength = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name); 00660 if (realsize > 0) { 00661 base = requiredlength - realsize; 00662 00663 #if defined(_WIN64) 00664 00665 offset = ALIGN_OFFSET64(base); 00666 00667 #else 00668 00669 if (KeyValueInformationClass == KeyValueFullInformationAlign64) { 00670 offset = ALIGN_OFFSET64(base); 00671 00672 } else { 00673 offset = ALIGN_OFFSET(base); 00674 } 00675 00676 #endif 00677 00678 if (offset > base) { 00679 requiredlength += (offset - base); 00680 } 00681 00682 #if DBG && defined(_WIN64) 00683 00684 // 00685 // Some clients will have passed in a structure that they "know" 00686 // will be exactly the right size. The fact that alignment 00687 // has changed on NT64 may cause these clients to have problems. 00688 // 00689 // The solution is to fix the client, but print out some debug 00690 // spew here if it looks like this is the case. This problem 00691 // isn't particularly easy to spot from the client end. 00692 // 00693 00694 if((KeyValueInformationClass == KeyValueFullInformation) && 00695 (Length != minimumlength) && 00696 (requiredlength > Length) && 00697 ((requiredlength - Length) <= 00698 (ALIGN_OFFSET64(base) - ALIGN_OFFSET(base)))) { 00699 00700 KdPrint(("ntos/config-64 KeyValueFullInformation: " 00701 "Possible client buffer size problem.\n")); 00702 00703 KdPrint((" Required size = %d\n", requiredlength)); 00704 KdPrint((" Supplied size = %d\n", Length)); 00705 } 00706 00707 #endif 00708 00709 } 00710 00711 *ResultLength = requiredlength; 00712 00713 status = STATUS_SUCCESS; 00714 00715 if (Length < minimumlength) { 00716 00717 status = STATUS_BUFFER_TOO_SMALL; 00718 00719 } else { 00720 00721 pbuffer->KeyValueFullInformation.TitleIndex = 0; 00722 00723 pbuffer->KeyValueFullInformation.Type = 00724 pcell->u.KeyValue.Type; 00725 00726 pbuffer->KeyValueFullInformation.DataLength = 00727 realsize; 00728 00729 pbuffer->KeyValueFullInformation.NameLength = 00730 NameLength; 00731 00732 leftlength = Length - minimumlength; 00733 requiredlength = NameLength; 00734 00735 if (leftlength < (LONG)requiredlength) { 00736 requiredlength = leftlength; 00737 status = STATUS_BUFFER_OVERFLOW; 00738 } 00739 00740 if (pcell->u.KeyValue.Flags & VALUE_COMP_NAME) { 00741 CmpCopyCompressedName(pbuffer->KeyValueFullInformation.Name, 00742 requiredlength, 00743 pcell->u.KeyValue.Name, 00744 pcell->u.KeyValue.NameLength); 00745 } else { 00746 RtlMoveMemory( 00747 &(pbuffer->KeyValueFullInformation.Name[0]), 00748 &(pcell->u.KeyValue.Name[0]), 00749 requiredlength 00750 ); 00751 } 00752 00753 if (realsize > 0) { 00754 00755 if (small == TRUE) { 00756 datapointer = (PUCHAR)(&(pcell->u.KeyValue.Data)); 00757 } else { 00758 datapointer = CmpGetValueDataFromCache(Hive, ContainingList, pcell, ValueCached); 00759 } 00760 00761 pbuffer->KeyValueFullInformation.DataOffset = offset; 00762 00763 leftlength = (((LONG)Length - (LONG)offset) < 0) ? 00764 0 : 00765 Length - offset; 00766 00767 requiredlength = realsize; 00768 00769 if (leftlength < (LONG)requiredlength) { 00770 requiredlength = leftlength; 00771 status = STATUS_BUFFER_OVERFLOW; 00772 } 00773 00774 ASSERT((small ? (requiredlength <= CM_KEY_VALUE_SMALL) : TRUE)); 00775 00776 RtlMoveMemory( 00777 ((PUCHAR)pbuffer + offset), 00778 datapointer, 00779 requiredlength 00780 ); 00781 00782 } else { 00783 pbuffer->KeyValueFullInformation.DataOffset = (ULONG)-1; 00784 } 00785 } 00786 00787 break; 00788 00789 00790 case KeyValuePartialInformation: 00791 00792 // 00793 // TitleIndex, Type, DataLength, Data 00794 // 00795 small = CmpIsHKeyValueSmall(realsize, pcell->u.KeyValue.DataLength); 00796 requiredlength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + 00797 realsize; 00798 00799 minimumlength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data); 00800 00801 *ResultLength = requiredlength; 00802 00803 status = STATUS_SUCCESS; 00804 00805 if (Length < minimumlength) { 00806 00807 status = STATUS_BUFFER_TOO_SMALL; 00808 00809 } else { 00810 00811 pbuffer->KeyValuePartialInformation.TitleIndex = 0; 00812 00813 pbuffer->KeyValuePartialInformation.Type = 00814 pcell->u.KeyValue.Type; 00815 00816 pbuffer->KeyValuePartialInformation.DataLength = 00817 realsize; 00818 00819 leftlength = Length - minimumlength; 00820 requiredlength = realsize; 00821 00822 if (leftlength < (LONG)requiredlength) { 00823 requiredlength = leftlength; 00824 status = STATUS_BUFFER_OVERFLOW; 00825 } 00826 00827 if (realsize > 0) { 00828 00829 if (small == TRUE) { 00830 datapointer = (PUCHAR)(&(pcell->u.KeyValue.Data)); 00831 } else { 00832 datapointer = CmpGetValueDataFromCache(Hive, ContainingList, pcell, ValueCached); 00833 } 00834 00835 ASSERT((small ? (requiredlength <= CM_KEY_VALUE_SMALL) : TRUE)); 00836 00837 RtlMoveMemory((PUCHAR)&(pbuffer->KeyValuePartialInformation.Data[0]), 00838 datapointer, 00839 requiredlength); 00840 } 00841 } 00842 00843 break; 00844 case KeyValuePartialInformationAlign64: 00845 00846 // 00847 // TitleIndex, Type, DataLength, Data 00848 // 00849 small = CmpIsHKeyValueSmall(realsize, pcell->u.KeyValue.DataLength); 00850 requiredlength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, Data) + 00851 realsize; 00852 00853 minimumlength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, Data); 00854 00855 *ResultLength = requiredlength; 00856 00857 status = STATUS_SUCCESS; 00858 00859 if (Length < minimumlength) { 00860 00861 status = STATUS_BUFFER_TOO_SMALL; 00862 00863 } else { 00864 00865 pbuffer->KeyValuePartialInformationAlign64.Type = 00866 pcell->u.KeyValue.Type; 00867 00868 pbuffer->KeyValuePartialInformationAlign64.DataLength = 00869 realsize; 00870 00871 leftlength = Length - minimumlength; 00872 requiredlength = realsize; 00873 00874 if (leftlength < (LONG)requiredlength) { 00875 requiredlength = leftlength; 00876 status = STATUS_BUFFER_OVERFLOW; 00877 } 00878 00879 if (realsize > 0) { 00880 00881 if (small == TRUE) { 00882 datapointer = (PUCHAR)(&(pcell->u.KeyValue.Data)); 00883 } else { 00884 datapointer = CmpGetValueDataFromCache(Hive, ContainingList, pcell, ValueCached); 00885 } 00886 00887 ASSERT((small ? (requiredlength <= CM_KEY_VALUE_SMALL) : TRUE)); 00888 RtlMoveMemory((PUCHAR)&(pbuffer->KeyValuePartialInformationAlign64.Data[0]), 00889 datapointer, 00890 requiredlength); 00891 } 00892 } 00893 00894 break; 00895 00896 default: 00897 status = STATUS_INVALID_PARAMETER; 00898 break; 00899 } 00900 return status; 00901 } }

---